From 180b7aee4f23f32687a3c3c44200fe6716181efa Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=B1=88=E8=BD=A9?= Date: Fri, 15 Feb 2019 17:12:54 +0800 Subject: [PATCH] =?UTF-8?q?host=E6=94=AF=E6=8C=81ceph?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- pkg/compute/models/storagedrivers.go | 36 +++++ pkg/compute/models/storages.go | 186 ++++++++++++++------------ pkg/compute/service/service.go | 1 + pkg/compute/storagedrivers/base.go | 21 +++ pkg/compute/storagedrivers/local.go | 30 +++++ pkg/compute/storagedrivers/nfs.go | 60 +++++++++ pkg/compute/storagedrivers/rbd.go | 100 ++++++++++++++ pkg/hostman/storageman/core.go | 2 +- pkg/hostman/storageman/disk_rbd.go | 103 ++++++++++++++ pkg/hostman/storageman/storage_rbd.go | 93 +++++++++++++ 10 files changed, 549 insertions(+), 83 deletions(-) create mode 100644 pkg/compute/models/storagedrivers.go create mode 100644 pkg/compute/storagedrivers/base.go create mode 100644 pkg/compute/storagedrivers/local.go create mode 100644 pkg/compute/storagedrivers/nfs.go create mode 100644 pkg/compute/storagedrivers/rbd.go create mode 100644 pkg/hostman/storageman/disk_rbd.go create mode 100644 pkg/hostman/storageman/storage_rbd.go diff --git a/pkg/compute/models/storagedrivers.go b/pkg/compute/models/storagedrivers.go new file mode 100644 index 0000000000..370036b4bd --- /dev/null +++ b/pkg/compute/models/storagedrivers.go @@ -0,0 +1,36 @@ +package models + +import ( + "context" + + "yunion.io/x/jsonutils" + "yunion.io/x/log" + "yunion.io/x/onecloud/pkg/mcclient" +) + +type IStorageDriver interface { + GetStorageType() string + + ValidateCreateData(ctx context.Context, userCred mcclient.TokenCredential, data *jsonutils.JSONDict) (*jsonutils.JSONDict, error) + + PostCreate(ctx context.Context, userCred mcclient.TokenCredential, storage *SStorage, data jsonutils.JSONObject) +} + +var storageDrivers map[string]IStorageDriver + +func init() { + storageDrivers = make(map[string]IStorageDriver) +} + +func RegisterStorageDriver(driver IStorageDriver) { + storageDrivers[driver.GetStorageType()] = driver +} + +func GetStorageDriver(storageType string) IStorageDriver { + driver, ok := storageDrivers[storageType] + if ok { + return driver + } + log.Fatalf("Unsupported storageType %s", storageType) + return nil +} diff --git a/pkg/compute/models/storages.go b/pkg/compute/models/storages.go index 2332f71dcd..a62bf1344c 100644 --- a/pkg/compute/models/storages.go +++ b/pkg/compute/models/storages.go @@ -4,8 +4,6 @@ import ( "context" "fmt" "path" - "strings" - "time" "yunion.io/x/jsonutils" "yunion.io/x/log" @@ -177,11 +175,13 @@ func (self *SStorage) AllowDeleteItem(ctx context.Context, userCred mcclient.Tok func (manager *SStorageManager) ValidateCreateData(ctx context.Context, userCred mcclient.TokenCredential, ownerProjId string, query jsonutils.JSONObject, data *jsonutils.JSONDict) (*jsonutils.JSONDict, error) { storageType, _ := data.GetString("storage_type") mediumType, _ := data.GetString("medium_type") - capacity, _ := data.Int("capacity") - if capacity < 0 { - return nil, httperrors.NewInputParameterError("Invalid capacity") - } - data.Set("capacity", jsonutils.NewInt(capacity)) + /* + capacity, _ := data.Int("capacity") + if capacity < 0 { + return nil, httperrors.NewInputParameterError("Invalid capacity") + } + data.Set("capacity", jsonutils.NewInt(capacity)) + */ if !utils.IsInStringArray(storageType, STORAGE_TYPES) { return nil, httperrors.NewInputParameterError("Invalid storage type %s", storageType) } @@ -197,23 +197,36 @@ func (manager *SStorageManager) ValidateCreateData(ctx context.Context, userCred return nil, httperrors.NewResourceNotFoundError("zone %s", zoneId) } data.Set("zone_id", jsonutils.NewString(zone.GetId())) - if storageType == STORAGE_RBD { - conf, err := manager.ValidateRbdConfData(data) - if err != nil { - return nil, httperrors.NewBadRequestError("Vaildata rbd conf error: %s", err.Error()) - } - data.Set("storage_conf", conf) - // data.Set("capacity", rbdConf) - } else if storageType == STORAGE_NFS { - conf, err := manager.ValidataNfsConfdata(data) - if err != nil { - return nil, httperrors.NewBadRequestError("Vaildata nfs conf error: %s", err.Error()) - } - data.Set("storage_conf", conf) + + storageDirver := GetStorageDriver(storageType) + if storageDirver == nil { + return nil, httperrors.NewUnsupportOperationError("Not support create %s storage", storageType) } + + data, err = storageDirver.ValidateCreateData(ctx, userCred, data) + if err != nil { + return nil, err + } + /* + if storageType == STORAGE_RBD { + conf, err := manager.ValidateRbdConfData(data) + if err != nil { + return nil, httperrors.NewBadRequestError("Vaildata rbd conf error: %s", err.Error()) + } + data.Set("storage_conf", conf) + // data.Set("capacity", rbdConf) + } else if storageType == STORAGE_NFS { + conf, err := manager.ValidataNfsConfdata(data) + if err != nil { + return nil, httperrors.NewBadRequestError("Vaildata nfs conf error: %s", err.Error()) + } + data.Set("storage_conf", conf) + } + */ return manager.SStandaloneResourceBaseManager.ValidateCreateData(ctx, userCred, ownerProjId, query, data) } +/* func (manager *SStorageManager) ValidataNfsConfdata(data *jsonutils.JSONDict) (*jsonutils.JSONDict, error) { conf := jsonutils.NewDict() if nfsHost, err := data.GetString("nfs_host"); err != nil { @@ -228,7 +241,9 @@ func (manager *SStorageManager) ValidataNfsConfdata(data *jsonutils.JSONDict) (* } return conf, nil } +*/ +/* func (manager *SStorageManager) ValidateRbdConfData(data *jsonutils.JSONDict) (*jsonutils.JSONDict, error) { conf := jsonutils.NewDict() for k, v := range data.Value() { @@ -257,7 +272,7 @@ func (manager *SStorageManager) ValidateRbdConfData(data *jsonutils.JSONDict) (* } // TODO??? ensure rbd pool can use and get capacity return conf, nil -} +}*/ func (self *SStorage) ValidateDeleteCondition(ctx context.Context) error { if self.GetHostCount() > 0 || self.GetDiskCount() > 0 || self.GetSnapshotCount() > 0 { @@ -268,74 +283,81 @@ func (self *SStorage) ValidateDeleteCondition(ctx context.Context) error { func (self *SStorage) PostCreate(ctx context.Context, userCred mcclient.TokenCredential, ownerProjId string, query jsonutils.JSONObject, data jsonutils.JSONObject) { self.SStandaloneResourceBase.PostCreate(ctx, userCred, ownerProjId, query, data) - storageConf, _ := data.Get("storage_conf") - if storageConf != nil { - _, err := self.GetModelManager().TableSpec().Update(self, func() error { - self.StorageConf = storageConf - return nil - }) - if err != nil { - log.Errorln(err) - return - } + + storageDriver := GetStorageDriver(self.StorageType) + if storageDriver != nil { + storageDriver.PostCreate(ctx, userCred, self, data) } - if self.StorageType == STORAGE_RBD { - var storages = make([]SStorage, 0) - err := StorageManager.Query().Equals("storage_type", STORAGE_RBD).All(&storages) - if err != nil { - log.Errorln(err) - return - } - nMonHost, _ := storageConf.GetString("mon_host") - nKey, _ := storageConf.GetString("key") - for i := 0; i < len(storages); i++ { - monHost, _ := storages[i].StorageConf.GetString("mon_host") - key, _ := storages[i].StorageConf.GetString("key") - if monHost == nMonHost && nKey == key { - _, err := self.GetModelManager().TableSpec().Update(self, func() error { - self.StoragecacheId = storages[i].StoragecacheId - return nil - }) - if err != nil { - log.Errorln(err) - return - } - break + + /* + storageConf, _ := data.Get("storage_conf") + if storageConf != nil { + _, err := self.GetModelManager().TableSpec().Update(self, func() error { + self.StorageConf = storageConf + return nil + }) + if err != nil { + log.Errorln(err) + return } } - if len(self.StoragecacheId) == 0 { + if self.StorageType == STORAGE_RBD { + var storages = make([]SStorage, 0) + err := StorageManager.Query().Equals("storage_type", STORAGE_RBD).All(&storages) + if err != nil { + log.Errorln(err) + return + } + nMonHost, _ := storageConf.GetString("mon_host") + nKey, _ := storageConf.GetString("key") + for i := 0; i < len(storages); i++ { + monHost, _ := storages[i].StorageConf.GetString("mon_host") + key, _ := storages[i].StorageConf.GetString("key") + if monHost == nMonHost && nKey == key { + _, err := self.GetModelManager().TableSpec().Update(self, func() error { + self.StoragecacheId = storages[i].StoragecacheId + return nil + }) + if err != nil { + log.Errorln(err) + return + } + break + } + } + if len(self.StoragecacheId) == 0 { + sc := &SStoragecache{} + sc.SetModelManager(StoragecacheManager) + sc.Name = fmt.Sprintf("imagecache-%s", self.Id) + pool, _ := storageConf.GetString("pool") + sc.Path = fmt.Sprintf("rbd:%s", pool) + err := StorageManager.TableSpec().Insert(sc) + if err != nil { + log.Errorln(err) + } + } + } else if self.StorageType == STORAGE_NFS { sc := &SStoragecache{} - sc.SetModelManager(StoragecacheManager) - sc.Name = fmt.Sprintf("imagecache-%s", self.Id) - pool, _ := storageConf.GetString("pool") - sc.Path = fmt.Sprintf("rbd:%s", pool) - err := StoragecacheManager.TableSpec().Insert(sc) + sc.Path = options.Options.NfsDefaultImageCacheDir + sc.ExternalId = self.Id + sc.Name = "nfs-" + self.Name + time.Now().Format("2006-01-02 15:04:05") + if err := StoragecacheManager.TableSpec().Insert(sc); err != nil { + log.Errorln(err) + return + } + if err := StoragecacheManager.Query().Equals("external_id", self.Id).First(sc); err != nil { + log.Errorln(err) + return + } + _, err := self.GetModelManager().TableSpec().Update(self, func() error { + self.StoragecacheId = sc.Id + self.Status = STORAGE_ONLINE + return nil + }) if err != nil { log.Errorln(err) } - } - } else if self.StorageType == STORAGE_NFS { - sc := &SStoragecache{} - sc.Path = options.Options.NfsDefaultImageCacheDir - sc.ExternalId = self.Id - sc.Name = "nfs-" + self.Name + time.Now().Format("2006-01-02 15:04:05") - if err := StoragecacheManager.TableSpec().Insert(sc); err != nil { - log.Errorln(err) - return - } - if err := StoragecacheManager.Query().Equals("external_id", self.Id).First(sc); err != nil { - log.Errorln(err) - return - } - _, err := self.GetModelManager().TableSpec().Update(self, func() error { - self.StoragecacheId = sc.Id - self.Status = STORAGE_ONLINE - return nil - }) - if err != nil { - log.Errorln(err) - } - } + }*/ } func (self *SStorage) SetStatus(userCred mcclient.TokenCredential, status string, reason string) error { diff --git a/pkg/compute/service/service.go b/pkg/compute/service/service.go index 3e5e30273f..67cc96a8b3 100644 --- a/pkg/compute/service/service.go +++ b/pkg/compute/service/service.go @@ -11,6 +11,7 @@ import ( _ "yunion.io/x/onecloud/pkg/compute/guestdrivers" _ "yunion.io/x/onecloud/pkg/compute/hostdrivers" _ "yunion.io/x/onecloud/pkg/compute/regiondrivers" + _ "yunion.io/x/onecloud/pkg/compute/storagedrivers" _ "yunion.io/x/onecloud/pkg/compute/tasks" _ "yunion.io/x/onecloud/pkg/util/aliyun/provider" _ "yunion.io/x/onecloud/pkg/util/aws/provider" diff --git a/pkg/compute/storagedrivers/base.go b/pkg/compute/storagedrivers/base.go new file mode 100644 index 0000000000..aa519a0df2 --- /dev/null +++ b/pkg/compute/storagedrivers/base.go @@ -0,0 +1,21 @@ +package storagedrivers + +import ( + "context" + "fmt" + + "yunion.io/x/jsonutils" + "yunion.io/x/onecloud/pkg/compute/models" + "yunion.io/x/onecloud/pkg/mcclient" +) + +type SBaseStorageDriver struct { +} + +func (self *SBaseStorageDriver) ValidateCreateData(ctx context.Context, userCred mcclient.TokenCredential, data *jsonutils.JSONDict) (*jsonutils.JSONDict, error) { + return nil, fmt.Errorf("Not Implement ValidateCreateData") +} + +func (self *SBaseStorageDriver) PostCreate(ctx context.Context, userCred mcclient.TokenCredential, storage *models.SStorage, data jsonutils.JSONObject) { + +} diff --git a/pkg/compute/storagedrivers/local.go b/pkg/compute/storagedrivers/local.go new file mode 100644 index 0000000000..2e443bbac9 --- /dev/null +++ b/pkg/compute/storagedrivers/local.go @@ -0,0 +1,30 @@ +package storagedrivers + +import ( + "context" + + "yunion.io/x/jsonutils" + "yunion.io/x/onecloud/pkg/compute/models" + "yunion.io/x/onecloud/pkg/mcclient" +) + +type SLocalStorageDriver struct { + SBaseStorageDriver +} + +func init() { + driver := SLocalStorageDriver{} + models.RegisterStorageDriver(&driver) +} + +func (self *SLocalStorageDriver) GetStorageType() string { + return models.STORAGE_LOCAL +} + +func (self *SLocalStorageDriver) ValidateCreateData(ctx context.Context, userCred mcclient.TokenCredential, data *jsonutils.JSONDict) (*jsonutils.JSONDict, error) { + return data, nil +} + +func (self *SLocalStorageDriver) PostCreate(ctx context.Context, userCred mcclient.TokenCredential, storage *models.SStorage, data jsonutils.JSONObject) { + +} diff --git a/pkg/compute/storagedrivers/nfs.go b/pkg/compute/storagedrivers/nfs.go new file mode 100644 index 0000000000..ee6b61debf --- /dev/null +++ b/pkg/compute/storagedrivers/nfs.go @@ -0,0 +1,60 @@ +package storagedrivers + +import ( + "context" + "time" + + "yunion.io/x/jsonutils" + "yunion.io/x/log" + "yunion.io/x/onecloud/pkg/compute/models" + "yunion.io/x/onecloud/pkg/compute/options" + "yunion.io/x/onecloud/pkg/httperrors" + "yunion.io/x/onecloud/pkg/mcclient" +) + +type SNfsStorageDriver struct { + SBaseStorageDriver +} + +func init() { + driver := SNfsStorageDriver{} + models.RegisterStorageDriver(&driver) +} + +func (self *SNfsStorageDriver) GetStorageType() string { + return models.STORAGE_NFS +} + +func (self *SNfsStorageDriver) ValidateCreateData(ctx context.Context, userCred mcclient.TokenCredential, data *jsonutils.JSONDict) (*jsonutils.JSONDict, error) { + conf := jsonutils.NewDict() + for _, v := range []string{"nfs_host", "nfs_shared_dir"} { + value, _ := data.GetString(v) + if len(value) == 0 { + return nil, httperrors.NewMissingParameterError(v) + } + conf.Set(v, jsonutils.NewString(value)) + } + + data.Set("storage_conf", conf) + + return data, nil +} + +func (self *SNfsStorageDriver) PostCreate(ctx context.Context, userCred mcclient.TokenCredential, storage *models.SStorage, data jsonutils.JSONObject) { + sc := &models.SStoragecache{} + sc.Path = options.Options.NfsDefaultImageCacheDir + sc.ExternalId = storage.Id + sc.Name = "nfs-" + storage.Name + time.Now().Format("2006-01-02 15:04:05") + if err := models.StoragecacheManager.TableSpec().Insert(sc); err != nil { + log.Errorf("insert storagecache for storage %s error: %v", storage.Name, err) + return + } + _, err := storage.GetModelManager().TableSpec().Update(storage, func() error { + storage.StoragecacheId = sc.Id + storage.Status = models.STORAGE_ONLINE + return nil + }) + if err != nil { + log.Errorf("update storagecache info for storage %s error: %v", storage.Name, err) + } +} diff --git a/pkg/compute/storagedrivers/rbd.go b/pkg/compute/storagedrivers/rbd.go new file mode 100644 index 0000000000..afc1b27746 --- /dev/null +++ b/pkg/compute/storagedrivers/rbd.go @@ -0,0 +1,100 @@ +package storagedrivers + +import ( + "context" + "fmt" + "strings" + + "yunion.io/x/jsonutils" + "yunion.io/x/log" + "yunion.io/x/onecloud/pkg/cloudcommon/db" + "yunion.io/x/onecloud/pkg/compute/models" + "yunion.io/x/onecloud/pkg/httperrors" + "yunion.io/x/onecloud/pkg/mcclient" +) + +type SRbdStorageDriver struct { + SBaseStorageDriver +} + +func init() { + driver := SRbdStorageDriver{} + models.RegisterStorageDriver(&driver) +} + +func (self *SRbdStorageDriver) GetStorageType() string { + return models.STORAGE_RBD +} + +func (self *SRbdStorageDriver) ValidateCreateData(ctx context.Context, userCred mcclient.TokenCredential, data *jsonutils.JSONDict) (*jsonutils.JSONDict, error) { + conf := jsonutils.NewDict() + for _, v := range []string{"rbd_mon_host", "rbd_pool"} { + if !data.Contains(v) { + return nil, httperrors.NewMissingParameterError(v) + } + value, _ := data.GetString(v) + conf.Add(jsonutils.NewString(value), strings.TrimLeft(v, "rbd_")) + } + if key, _ := data.GetString("rbd_key"); len(key) > 0 { + conf.Add(jsonutils.NewString(key), "key") + } + + storages := []models.SStorage{} + q := models.StorageManager.Query().Equals("storage_type", models.STORAGE_RBD) + if err := db.FetchModelObjects(models.StorageManager, q, &storages); err != nil { + return nil, httperrors.NewGeneralError(err) + } + + for i := 0; i < len(storages); i++ { + if conf.Equals(storages[i].StorageConf) { + return nil, httperrors.NewDuplicateResourceError("This RBD Storage[%s/%s] has already exist", storages[i].Name, conf.String()) + } + } + + data.Set("storage_conf", conf) + + return data, nil +} + +func (self *SRbdStorageDriver) PostCreate(ctx context.Context, userCred mcclient.TokenCredential, storage *models.SStorage, data jsonutils.JSONObject) { + storages := []models.SStorage{} + q := models.StorageManager.Query().Equals("storage_type", models.STORAGE_RBD) + if err := db.FetchModelObjects(models.StorageManager, q, &storages); err != nil { + log.Errorf("fetch storages error: %v", err) + return + } + newRbdHost, _ := data.GetString("rbd_mon_host") + newRbdKey, _ := data.GetString("rbd_key") + for i := 0; i < len(storages); i++ { + rbdHost, _ := storages[i].StorageConf.GetString("mon_host") + rbdKey, _ := storages[i].StorageConf.GetString("key") + if newRbdHost == rbdHost && newRbdKey == rbdKey { + _, err := storage.GetModelManager().TableSpec().Update(self, func() error { + storage.StoragecacheId = storages[i].StoragecacheId + return nil + }) + if err != nil { + log.Errorf("Update storagecacheId error: %v", err) + return + } + } + } + if len(storage.StoragecacheId) == 0 { + sc := &models.SStoragecache{} + sc.SetModelManager(models.StoragecacheManager) + sc.Name = fmt.Sprintf("imagecache-%s", storage.Id) + pool, _ := data.GetString("rbd_pool") + sc.Path = fmt.Sprintf("rbd:%s", pool) + if err := models.StoragecacheManager.TableSpec().Insert(sc); err != nil { + log.Errorf("insert storagecache for storage %s error: %v", storage.Name, err) + return + } + _, err := storage.GetModelManager().TableSpec().Update(storage, func() error { + storage.StoragecacheId = sc.Id + return nil + }) + if err != nil { + log.Errorf("update storagecache info for storage %s error: %v", storage.Name, err) + } + } +} diff --git a/pkg/hostman/storageman/core.go b/pkg/hostman/storageman/core.go index 387ada91ab..7d825099b7 100644 --- a/pkg/hostman/storageman/core.go +++ b/pkg/hostman/storageman/core.go @@ -250,7 +250,7 @@ func (s *SStorageManager) NewSharedStorageInstance(mountPoint, storageType strin } else if storageType == storagetypes.STORAGE_RBD || strings.HasPrefix(mountPoint, storagetypes.STORAGE_RBD) { // TODO - // return NewRBDStorage(s, mountPoint) + return NewRBDStorage(s, mountPoint) } return nil } diff --git a/pkg/hostman/storageman/disk_rbd.go b/pkg/hostman/storageman/disk_rbd.go new file mode 100644 index 0000000000..2a99b1f047 --- /dev/null +++ b/pkg/hostman/storageman/disk_rbd.go @@ -0,0 +1,103 @@ +package storageman + +import ( + "context" + + "yunion.io/x/jsonutils" + "yunion.io/x/onecloud/pkg/cloudcommon/storagetypes" + "yunion.io/x/onecloud/pkg/hostman/guestfs" +) + +type SRBDDisk struct { + SBaseDisk +} + +func NewRBDDisk(storage IStorage, id string) *SRBDDisk { + var ret = new(SRBDDisk) + ret.SBaseDisk = *NewBaseDisk(storage, id) + return ret +} + +func (d *SRBDDisk) GetType() string { + return storagetypes.STORAGE_RBD +} + +func (d *SRBDDisk) Probe() error { + return nil +} + +func (d *SRBDDisk) GetPath() string { + return "" +} + +func (d *SRBDDisk) GetSnapshotDir() string { + return "" +} + +func (d *SRBDDisk) GetDiskDesc() jsonutils.JSONObject { + return nil +} + +func (d *SRBDDisk) GetDiskSetupScripts(idx int) string { + return "" +} + +func (d *SRBDDisk) DeleteAllSnapshot() error { + return nil +} + +func (d *SRBDDisk) Delete(ctx context.Context, params interface{}) (jsonutils.JSONObject, error) { + return nil, nil +} + +func (d *SRBDDisk) Resize(ctx context.Context, params interface{}) (jsonutils.JSONObject, error) { + return nil, nil +} + +func (d *SRBDDisk) PrepareSaveToGlance(ctx context.Context, params interface{}) (jsonutils.JSONObject, error) { + return nil, nil +} + +func (d *SRBDDisk) ResetFromSnapshot(ctx context.Context, params interface{}) (jsonutils.JSONObject, error) { + return nil, nil +} + +func (d *SRBDDisk) CleanupSnapshots(ctx context.Context, params interface{}) (jsonutils.JSONObject, error) { + return nil, nil +} + +func (d *SRBDDisk) PrepareMigrate(liveMigrate bool) (string, error) { + return "", nil +} + +func (d *SRBDDisk) CreateFromUrl(context.Context, string) error { + return nil +} + +func (d *SRBDDisk) CreateFromTemplate(context.Context, string, string, int64) (jsonutils.JSONObject, error) { + return nil, nil +} + +func (d *SRBDDisk) CreateFromImageFuse(context.Context, string) error { + return nil +} + +func (d *SRBDDisk) CreateRaw(ctx context.Context, sizeMb int, diskFromat string, fsFormat string, encryption bool, diskId string, back string) (jsonutils.JSONObject, error) { + return nil, nil +} + +func (d *SRBDDisk) PostCreateFromImageFuse() { + +} + +func (d *SRBDDisk) CreateSnapshot(snapshotId string) error { + return nil +} + +func (d *SRBDDisk) DeleteSnapshot(snapshotId, convertSnapshot string, pendingDelete bool) error { + return nil +} + +func (d *SRBDDisk) DeployGuestFs(diskPath string, guestDesc *jsonutils.JSONDict, deployInfo *guestfs.SDeployInfo) (jsonutils.JSONObject, error) { + return nil, nil +} diff --git a/pkg/hostman/storageman/storage_rbd.go b/pkg/hostman/storageman/storage_rbd.go new file mode 100644 index 0000000000..d88768ccfe --- /dev/null +++ b/pkg/hostman/storageman/storage_rbd.go @@ -0,0 +1,93 @@ +package storageman + +import ( + "context" + + "yunion.io/x/jsonutils" + "yunion.io/x/onecloud/pkg/cloudcommon/storagetypes" +) + +type SRBDStorage struct { + SBaseStorage +} + +func NewRBDStorage(manager *SStorageManager, path string) *SRBDStorage { + var ret = new(SRBDStorage) + ret.SBaseStorage = *NewBaseStorage(manager, path) + return ret +} + +func (s *SRBDStorage) StorageType() string { + return storagetypes.STORAGE_RBD +} + +func (s *SRBDStorage) GetSnapshotPathByIds(diskId, snapshotId string) string { + return "" +} + +func (s *SRBDStorage) GetSnapshotDir() string { + return "" +} + +func (s *SRBDStorage) GetFuseTmpPath() string { + return "" +} + +func (s *SRBDStorage) GetFuseMountPath() string { + return "" +} + +func (s *SRBDStorage) GetImgsaveBackupPath() string { + return "" +} + +func (s *SRBDStorage) SyncStorageInfo() (jsonutils.JSONObject, error) { + return nil, nil +} + +func (s *SRBDStorage) GetDiskById(diskId string) IDisk { + s.DiskLock.Lock() + defer s.DiskLock.Unlock() + for i := 0; i < len(s.Disks); i++ { + if s.Disks[i].GetId() == diskId { + if s.Disks[i].Probe() == nil { + return s.Disks[i] + } + } + } + var disk = NewRBDDisk(s, diskId) + if disk.Probe() == nil { + s.Disks = append(s.Disks, disk) + return disk + } else { + return nil + } +} + +func (s *SRBDStorage) CreateDisk(diskId string) IDisk { + s.DiskLock.Lock() + defer s.DiskLock.Unlock() + disk := NewRBDDisk(s, diskId) + s.Disks = append(s.Disks, disk) + return disk +} + +func (s *SRBDStorage) Accessible() bool { + return true +} + +func (s *SRBDStorage) DeleteDiskfile(diskpath string) error { + return nil +} + +func (s *SRBDStorage) SaveToGlance(ctx context.Context, params interface{}) (jsonutils.JSONObject, error) { + return nil, nil +} + +func (s *SRBDStorage) CreateSnapshotFormUrl(ctx context.Context, snapshotUrl, diskId, snapshotPath string) error { + return nil +} + +func (s *SRBDStorage) DeleteSnapshots(ctx context.Context, params interface{}) (jsonutils.JSONObject, error) { + return nil, nil +}