[lxc-devel] [lxd/master] storage: simplify

brauner on Github lxc-bot at linuxcontainers.org
Sun Feb 26 02:46:02 UTC 2017


A non-text attachment was scrubbed...
Name: not available
Type: text/x-mailbox
Size: 301 bytes
Desc: not available
URL: <http://lists.linuxcontainers.org/pipermail/lxc-devel/attachments/20170226/268220f0/attachment.bin>
-------------- next part --------------
From 5b0b0f6adde351e0d8a1ac847dafab53f64899eb Mon Sep 17 00:00:00 2001
From: Christian Brauner <christian.brauner at ubuntu.com>
Date: Sat, 25 Feb 2017 19:43:35 +0100
Subject: [PATCH 1/3] storage: remove unused function argument

Signed-off-by: Christian Brauner <christian.brauner at ubuntu.com>
---
 lxd/storage.go       | 13 +++++--------
 lxd/storage_btrfs.go |  2 +-
 lxd/storage_dir.go   |  2 +-
 lxd/storage_lvm.go   |  2 +-
 lxd/storage_mock.go  |  2 +-
 lxd/storage_zfs.go   |  2 +-
 6 files changed, 10 insertions(+), 13 deletions(-)

diff --git a/lxd/storage.go b/lxd/storage.go
index 9eba5dd..10650e6 100644
--- a/lxd/storage.go
+++ b/lxd/storage.go
@@ -98,7 +98,8 @@ func filesystemDetect(path string) (string, error) {
 
 // storageRsyncCopy copies a directory using rsync (with the --devices option).
 func storageRsyncCopy(source string, dest string) (string, error) {
-	if err := os.MkdirAll(dest, 0755); err != nil {
+	err := os.MkdirAll(dest, 0755)
+	if err != nil {
 		return "", err
 	}
 
@@ -182,7 +183,7 @@ type storage interface {
 	storageCoreInfo
 
 	// Functions dealing with storage pool.
-	StoragePoolInit(config map[string]interface{}) (storage, error)
+	StoragePoolInit() (storage, error)
 	StoragePoolCheck() error
 	StoragePoolCreate() error
 	StoragePoolDelete() error
@@ -331,14 +332,12 @@ func storageInit(d *Daemon, poolName string, volumeName string, volumeType int)
 }
 
 func storagePoolInit(d *Daemon, poolName string) (storage, error) {
-	var config map[string]interface{}
-
 	s, err := storageInit(d, poolName, "", -1)
 	if err != nil {
 		return nil, err
 	}
 
-	return s.StoragePoolInit(config)
+	return s.StoragePoolInit()
 }
 
 func storagePoolVolumeImageInit(d *Daemon, poolName string, imageFingerprint string) (storage, error) {
@@ -360,15 +359,13 @@ func storagePoolVolumeContainerLoadInit(d *Daemon, containerName string) (storag
 }
 
 func storagePoolVolumeInit(d *Daemon, poolName string, volumeName string, volumeType int) (storage, error) {
-	var config map[string]interface{}
-
 	// No need to detect storage here, its a new container.
 	s, err := storageInit(d, poolName, volumeName, volumeType)
 	if err != nil {
 		return nil, err
 	}
 
-	storage, err := s.StoragePoolInit(config)
+	storage, err := s.StoragePoolInit()
 	if err != nil {
 		return nil, err
 	}
diff --git a/lxd/storage_btrfs.go b/lxd/storage_btrfs.go
index 1f8a0d8..7eaaca0 100644
--- a/lxd/storage_btrfs.go
+++ b/lxd/storage_btrfs.go
@@ -76,7 +76,7 @@ func (s *storageBtrfs) StorageCoreInit() (*storageCore, error) {
 	return &sCore, nil
 }
 
-func (s *storageBtrfs) StoragePoolInit(config map[string]interface{}) (storage, error) {
+func (s *storageBtrfs) StoragePoolInit() (storage, error) {
 	_, err := s.StorageCoreInit()
 	if err != nil {
 		return s, err
diff --git a/lxd/storage_dir.go b/lxd/storage_dir.go
index 9703b82..654c92a 100644
--- a/lxd/storage_dir.go
+++ b/lxd/storage_dir.go
@@ -35,7 +35,7 @@ func (s *storageDir) StorageCoreInit() (*storageCore, error) {
 }
 
 // Initialize a full storage interface.
-func (s *storageDir) StoragePoolInit(config map[string]interface{}) (storage, error) {
+func (s *storageDir) StoragePoolInit() (storage, error) {
 	_, err := s.StorageCoreInit()
 	if err != nil {
 		return s, err
diff --git a/lxd/storage_lvm.go b/lxd/storage_lvm.go
index 46dc90e..f50588e 100644
--- a/lxd/storage_lvm.go
+++ b/lxd/storage_lvm.go
@@ -290,7 +290,7 @@ func (s *storageLvm) StorageCoreInit() (*storageCore, error) {
 	return &sCore, nil
 }
 
-func (s *storageLvm) StoragePoolInit(config map[string]interface{}) (storage, error) {
+func (s *storageLvm) StoragePoolInit() (storage, error) {
 	_, err := s.StorageCoreInit()
 	if err != nil {
 		return s, err
diff --git a/lxd/storage_mock.go b/lxd/storage_mock.go
index d46ab9f..4938864 100644
--- a/lxd/storage_mock.go
+++ b/lxd/storage_mock.go
@@ -28,7 +28,7 @@ func (s *storageMock) StorageCoreInit() (*storageCore, error) {
 	return &sCore, nil
 }
 
-func (s *storageMock) StoragePoolInit(config map[string]interface{}) (storage, error) {
+func (s *storageMock) StoragePoolInit() (storage, error) {
 	_, err := s.StorageCoreInit()
 	if err != nil {
 		return s, err
diff --git a/lxd/storage_zfs.go b/lxd/storage_zfs.go
index 3fa9ed8..9b1946e 100644
--- a/lxd/storage_zfs.go
+++ b/lxd/storage_zfs.go
@@ -80,7 +80,7 @@ func (s *storageZfs) StorageCoreInit() (*storageCore, error) {
 }
 
 // Functions dealing with storage pools.
-func (s *storageZfs) StoragePoolInit(config map[string]interface{}) (storage, error) {
+func (s *storageZfs) StoragePoolInit() (storage, error) {
 	_, err := s.StorageCoreInit()
 	if err != nil {
 		return s, err

From 0ecd36a067c8893faed61afb1d832c82835cc521 Mon Sep 17 00:00:00 2001
From: Christian Brauner <christian.brauner at ubuntu.com>
Date: Sat, 25 Feb 2017 19:55:11 +0100
Subject: [PATCH 2/3] storage: simplifiy StoragePoolInit()

Signed-off-by: Christian Brauner <christian.brauner at ubuntu.com>
---
 lxd/storage.go       | 15 ++++++++++-----
 lxd/storage_btrfs.go |  6 +++---
 lxd/storage_dir.go   |  6 +++---
 lxd/storage_lvm.go   | 14 +++++++-------
 lxd/storage_mock.go  |  6 +++---
 lxd/storage_zfs.go   |  6 +++---
 6 files changed, 29 insertions(+), 24 deletions(-)

diff --git a/lxd/storage.go b/lxd/storage.go
index 10650e6..3164afe 100644
--- a/lxd/storage.go
+++ b/lxd/storage.go
@@ -183,7 +183,7 @@ type storage interface {
 	storageCoreInfo
 
 	// Functions dealing with storage pool.
-	StoragePoolInit() (storage, error)
+	StoragePoolInit() error
 	StoragePoolCheck() error
 	StoragePoolCreate() error
 	StoragePoolDelete() error
@@ -337,7 +337,12 @@ func storagePoolInit(d *Daemon, poolName string) (storage, error) {
 		return nil, err
 	}
 
-	return s.StoragePoolInit()
+	err = s.StoragePoolInit()
+	if err != nil {
+		return nil, err
+	}
+
+	return s, nil
 }
 
 func storagePoolVolumeImageInit(d *Daemon, poolName string, imageFingerprint string) (storage, error) {
@@ -365,17 +370,17 @@ func storagePoolVolumeInit(d *Daemon, poolName string, volumeName string, volume
 		return nil, err
 	}
 
-	storage, err := s.StoragePoolInit()
+	err = s.StoragePoolInit()
 	if err != nil {
 		return nil, err
 	}
 
-	err = storage.StoragePoolCheck()
+	err = s.StoragePoolCheck()
 	if err != nil {
 		return nil, err
 	}
 
-	return storage, nil
+	return s, nil
 }
 
 // {LXD_DIR}/storage-pools/<pool>
diff --git a/lxd/storage_btrfs.go b/lxd/storage_btrfs.go
index 7eaaca0..ea8e1a2 100644
--- a/lxd/storage_btrfs.go
+++ b/lxd/storage_btrfs.go
@@ -76,13 +76,13 @@ func (s *storageBtrfs) StorageCoreInit() (*storageCore, error) {
 	return &sCore, nil
 }
 
-func (s *storageBtrfs) StoragePoolInit() (storage, error) {
+func (s *storageBtrfs) StoragePoolInit() error {
 	_, err := s.StorageCoreInit()
 	if err != nil {
-		return s, err
+		return err
 	}
 
-	return s, nil
+	return nil
 }
 
 func (s *storageBtrfs) StoragePoolCheck() error {
diff --git a/lxd/storage_dir.go b/lxd/storage_dir.go
index 654c92a..51ec27c 100644
--- a/lxd/storage_dir.go
+++ b/lxd/storage_dir.go
@@ -35,13 +35,13 @@ func (s *storageDir) StorageCoreInit() (*storageCore, error) {
 }
 
 // Initialize a full storage interface.
-func (s *storageDir) StoragePoolInit() (storage, error) {
+func (s *storageDir) StoragePoolInit() error {
 	_, err := s.StorageCoreInit()
 	if err != nil {
-		return s, err
+		return err
 	}
 
-	return s, nil
+	return nil
 }
 
 // Initialize a full storage interface.
diff --git a/lxd/storage_lvm.go b/lxd/storage_lvm.go
index f50588e..13f30b9 100644
--- a/lxd/storage_lvm.go
+++ b/lxd/storage_lvm.go
@@ -290,10 +290,10 @@ func (s *storageLvm) StorageCoreInit() (*storageCore, error) {
 	return &sCore, nil
 }
 
-func (s *storageLvm) StoragePoolInit() (storage, error) {
+func (s *storageLvm) StoragePoolInit() error {
 	_, err := s.StorageCoreInit()
 	if err != nil {
-		return s, err
+		return err
 	}
 
 	source := s.pool.Config["source"]
@@ -304,25 +304,25 @@ func (s *storageLvm) StoragePoolInit() (storage, error) {
 	}
 
 	if source == "" {
-		return s, fmt.Errorf("Loop backed lvm storage pools are not supported.")
+		return fmt.Errorf("Loop backed lvm storage pools are not supported.")
 	} else {
 		if filepath.IsAbs(source) {
 			if !shared.IsBlockdevPath(source) {
-				return s, fmt.Errorf("Loop backed lvm storage pools are not supported.")
+				return fmt.Errorf("Loop backed lvm storage pools are not supported.")
 			}
 		} else {
 			ok, err := storageVGExists(source)
 			if err != nil {
 				// Internal error.
-				return s, err
+				return err
 			} else if !ok {
 				// Volume group does not exist.
-				return s, fmt.Errorf("The requested volume group \"%s\" does not exist.", source)
+				return fmt.Errorf("The requested volume group \"%s\" does not exist.", source)
 			}
 		}
 	}
 
-	return s, nil
+	return nil
 }
 
 func (s *storageLvm) StoragePoolCheck() error {
diff --git a/lxd/storage_mock.go b/lxd/storage_mock.go
index 4938864..8b15486 100644
--- a/lxd/storage_mock.go
+++ b/lxd/storage_mock.go
@@ -28,13 +28,13 @@ func (s *storageMock) StorageCoreInit() (*storageCore, error) {
 	return &sCore, nil
 }
 
-func (s *storageMock) StoragePoolInit() (storage, error) {
+func (s *storageMock) StoragePoolInit() error {
 	_, err := s.StorageCoreInit()
 	if err != nil {
-		return s, err
+		return err
 	}
 
-	return s, nil
+	return nil
 }
 
 func (s *storageMock) StoragePoolCheck() error {
diff --git a/lxd/storage_zfs.go b/lxd/storage_zfs.go
index 9b1946e..239f585 100644
--- a/lxd/storage_zfs.go
+++ b/lxd/storage_zfs.go
@@ -80,10 +80,10 @@ func (s *storageZfs) StorageCoreInit() (*storageCore, error) {
 }
 
 // Functions dealing with storage pools.
-func (s *storageZfs) StoragePoolInit() (storage, error) {
+func (s *storageZfs) StoragePoolInit() error {
 	_, err := s.StorageCoreInit()
 	if err != nil {
-		return s, err
+		return err
 	}
 
 	// Detect whether we have been given a zfs dataset as source.
@@ -91,7 +91,7 @@ func (s *storageZfs) StoragePoolInit() (storage, error) {
 		s.dataset = s.pool.Config["zfs.pool_name"]
 	}
 
-	return s, nil
+	return nil
 }
 
 func (s *storageZfs) StoragePoolCheck() error {

From e7770b797c33dca1602219f180f33ef8e7576ce1 Mon Sep 17 00:00:00 2001
From: Christian Brauner <christian.brauner at ubuntu.com>
Date: Sat, 25 Feb 2017 23:13:30 +0100
Subject: [PATCH 3/3] storage: remove storage core

It's not needed anymore with a few adaptions.

Signed-off-by: Christian Brauner <christian.brauner at ubuntu.com>
---
 lxd/api_1.0.go        |  2 +-
 lxd/storage.go        | 84 ++++++++++++++++++++++++++++++++++++++++-----------
 lxd/storage_btrfs.go  | 25 +++++++--------
 lxd/storage_core.go   | 55 ---------------------------------
 lxd/storage_dir.go    | 19 +++++-------
 lxd/storage_lvm.go    | 25 +++++++--------
 lxd/storage_mock.go   | 17 +++++------
 lxd/storage_shared.go | 16 +++++++++-
 lxd/storage_zfs.go    | 29 ++++++++----------
 9 files changed, 133 insertions(+), 139 deletions(-)
 delete mode 100644 lxd/storage_core.go

diff --git a/lxd/api_1.0.go b/lxd/api_1.0.go
index 77bbc3e..559b601 100644
--- a/lxd/api_1.0.go
+++ b/lxd/api_1.0.go
@@ -194,7 +194,7 @@ func api10Get(d *Daemon, r *http.Request) Response {
 	drivers := readStoragePoolDriversCache()
 	for _, driver := range drivers {
 		// Initialize a core storage interface for the given driver.
-		sCore, err := storagePoolCoreInit(driver)
+		sCore, err := storageCoreInit(driver)
 		if err != nil {
 			continue
 		}
diff --git a/lxd/storage.go b/lxd/storage.go
index 3164afe..806231e 100644
--- a/lxd/storage.go
+++ b/lxd/storage.go
@@ -180,7 +180,10 @@ func storageStringToType(sName string) (storageType, error) {
 // Also, minimize the number of functions needed. Both should be straightforward
 // tasks.
 type storage interface {
-	storageCoreInfo
+	StorageCoreInit() error
+	GetStorageType() storageType
+	GetStorageTypeName() string
+	GetStorageTypeVersion() string
 
 	// Functions dealing with storage pool.
 	StoragePoolInit() error
@@ -262,6 +265,48 @@ type storage interface {
 	MigrationSink(live bool, container container, objects []*Snapshot, conn *websocket.Conn, srcIdmap *shared.IdmapSet, op *operation) error
 }
 
+func storageCoreInit(driver string) (storage, error) {
+	sType, err := storageStringToType(driver)
+	if err != nil {
+		return nil, err
+	}
+
+	switch sType {
+	case storageTypeBtrfs:
+		btrfs := storageBtrfs{}
+		err = btrfs.StorageCoreInit()
+		if err == nil {
+			return &btrfs, nil
+		}
+	case storageTypeDir:
+		dir := storageDir{}
+		err = dir.StorageCoreInit()
+		if err == nil {
+			return &dir, nil
+		}
+	case storageTypeLvm:
+		lvm := storageLvm{}
+		err = lvm.StorageCoreInit()
+		if err == nil {
+			return &lvm, nil
+		}
+	case storageTypeMock:
+		mock := storageMock{}
+		err = mock.StorageCoreInit()
+		if err == nil {
+			return &mock, nil
+		}
+	case storageTypeZfs:
+		zfs := storageZfs{}
+		err = zfs.StorageCoreInit()
+		if err == nil {
+			return &zfs, nil
+		}
+	}
+
+	return nil, fmt.Errorf("Invalid storage type.")
+}
+
 func storageInit(d *Daemon, poolName string, volumeName string, volumeType int) (storage, error) {
 	// Load the storage pool.
 	poolID, pool, err := dbStoragePoolGet(d.db, poolName)
@@ -297,52 +342,57 @@ func storageInit(d *Daemon, poolName string, volumeName string, volumeType int)
 		btrfs.pool = pool
 		btrfs.volume = volume
 		btrfs.d = d
-		return &btrfs, nil
+		err = btrfs.StoragePoolInit()
+		if err == nil {
+			return &btrfs, nil
+		}
 	case storageTypeDir:
 		dir := storageDir{}
 		dir.poolID = poolID
 		dir.pool = pool
 		dir.volume = volume
 		dir.d = d
-		return &dir, nil
+		err = dir.StoragePoolInit()
+		if err == nil {
+			return &dir, nil
+		}
 	case storageTypeLvm:
 		lvm := storageLvm{}
 		lvm.poolID = poolID
 		lvm.pool = pool
 		lvm.volume = volume
 		lvm.d = d
-		return &lvm, nil
+		err = lvm.StoragePoolInit()
+		if err == nil {
+			return &lvm, nil
+		}
 	case storageTypeMock:
 		mock := storageMock{}
 		mock.poolID = poolID
 		mock.pool = pool
 		mock.volume = volume
 		mock.d = d
-		return &mock, nil
+		err = mock.StoragePoolInit()
+		if err == nil {
+			return &mock, nil
+		}
 	case storageTypeZfs:
 		zfs := storageZfs{}
 		zfs.poolID = poolID
 		zfs.pool = pool
 		zfs.volume = volume
 		zfs.d = d
-		return &zfs, nil
+		err = zfs.StoragePoolInit()
+		if err == nil {
+			return &zfs, nil
+		}
 	}
 
 	return nil, fmt.Errorf("Invalid storage type.")
 }
 
 func storagePoolInit(d *Daemon, poolName string) (storage, error) {
-	s, err := storageInit(d, poolName, "", -1)
-	if err != nil {
-		return nil, err
-	}
-
-	err = s.StoragePoolInit()
-	if err != nil {
-		return nil, err
-	}
-
-	return s, nil
+	return storageInit(d, poolName, "", -1)
 }
 
 func storagePoolVolumeImageInit(d *Daemon, poolName string, imageFingerprint string) (storage, error) {
diff --git a/lxd/storage_btrfs.go b/lxd/storage_btrfs.go
index ea8e1a2..1578b9d 100644
--- a/lxd/storage_btrfs.go
+++ b/lxd/storage_btrfs.go
@@ -46,38 +46,35 @@ func (s *storageBtrfs) getCustomSubvolumePath(poolName string) string {
 	return shared.VarPath("storage-pools", poolName, "custom")
 }
 
-func (s *storageBtrfs) StorageCoreInit() (*storageCore, error) {
-	sCore := storageCore{}
-	sCore.sType = storageTypeBtrfs
-	typeName, err := storageTypeToString(sCore.sType)
+func (s *storageBtrfs) StorageCoreInit() error {
+	s.sType = storageTypeBtrfs
+	typeName, err := storageTypeToString(s.sType)
 	if err != nil {
-		return nil, err
+		return err
 	}
-	sCore.sTypeName = typeName
+	s.sTypeName = typeName
 
 	out, err := exec.LookPath("btrfs")
 	if err != nil || len(out) == 0 {
-		return nil, fmt.Errorf("The 'btrfs' tool isn't available")
+		return fmt.Errorf("The 'btrfs' tool isn't available")
 	}
 
 	output, err := exec.Command("btrfs", "version").CombinedOutput()
 	if err != nil {
-		return nil, fmt.Errorf("The 'btrfs' tool isn't working properly")
+		return fmt.Errorf("The 'btrfs' tool isn't working properly")
 	}
 
-	count, err := fmt.Sscanf(strings.SplitN(string(output), " ", 2)[1], "v%s\n", &sCore.sTypeVersion)
+	count, err := fmt.Sscanf(strings.SplitN(string(output), " ", 2)[1], "v%s\n", &s.sTypeVersion)
 	if err != nil || count != 1 {
-		return nil, fmt.Errorf("The 'btrfs' tool isn't working properly")
+		return fmt.Errorf("The 'btrfs' tool isn't working properly")
 	}
 
-	s.storageCore = sCore
-
 	shared.LogDebugf("Initializing a BTRFS driver.")
-	return &sCore, nil
+	return nil
 }
 
 func (s *storageBtrfs) StoragePoolInit() error {
-	_, err := s.StorageCoreInit()
+	err := s.StorageCoreInit()
 	if err != nil {
 		return err
 	}
diff --git a/lxd/storage_core.go b/lxd/storage_core.go
deleted file mode 100644
index 79ebe15..0000000
--- a/lxd/storage_core.go
+++ /dev/null
@@ -1,55 +0,0 @@
-package main
-
-import (
-	"fmt"
-)
-
-type storageCoreInfo interface {
-	StorageCoreInit() (*storageCore, error)
-	GetStorageType() storageType
-	GetStorageTypeName() string
-	GetStorageTypeVersion() string
-}
-
-type storageCore struct {
-	sType        storageType
-	sTypeName    string
-	sTypeVersion string
-}
-
-func (sc *storageCore) GetStorageType() storageType {
-	return sc.sType
-}
-
-func (sc *storageCore) GetStorageTypeName() string {
-	return sc.sTypeName
-}
-
-func (sc *storageCore) GetStorageTypeVersion() string {
-	return sc.sTypeVersion
-}
-
-func storagePoolCoreInit(poolDriver string) (*storageCore, error) {
-	sType, err := storageStringToType(poolDriver)
-	if err != nil {
-		return nil, err
-	}
-
-	var s storage
-	switch sType {
-	case storageTypeBtrfs:
-		s = &storageBtrfs{}
-	case storageTypeZfs:
-		s = &storageZfs{}
-	case storageTypeLvm:
-		s = &storageLvm{}
-	case storageTypeDir:
-		s = &storageDir{}
-	case storageTypeMock:
-		s = &storageMock{}
-	default:
-		return nil, fmt.Errorf("Unknown storage pool driver \"%s\".", poolDriver)
-	}
-
-	return s.StorageCoreInit()
-}
diff --git a/lxd/storage_dir.go b/lxd/storage_dir.go
index 51ec27c..27f6cdb 100644
--- a/lxd/storage_dir.go
+++ b/lxd/storage_dir.go
@@ -18,25 +18,22 @@ type storageDir struct {
 }
 
 // Only initialize the minimal information we need about a given storage type.
-func (s *storageDir) StorageCoreInit() (*storageCore, error) {
-	sCore := storageCore{}
-	sCore.sType = storageTypeDir
-	typeName, err := storageTypeToString(sCore.sType)
+func (s *storageDir) StorageCoreInit() error {
+	s.sType = storageTypeDir
+	typeName, err := storageTypeToString(s.sType)
 	if err != nil {
-		return nil, err
+		return err
 	}
-	sCore.sTypeName = typeName
-	sCore.sTypeVersion = "1"
-
-	s.storageCore = sCore
+	s.sTypeName = typeName
+	s.sTypeVersion = "1"
 
 	shared.LogDebugf("Initializing a DIR driver.")
-	return &sCore, nil
+	return nil
 }
 
 // Initialize a full storage interface.
 func (s *storageDir) StoragePoolInit() error {
-	_, err := s.StorageCoreInit()
+	err := s.StorageCoreInit()
 	if err != nil {
 		return err
 	}
diff --git a/lxd/storage_lvm.go b/lxd/storage_lvm.go
index 13f30b9..780a29a 100644
--- a/lxd/storage_lvm.go
+++ b/lxd/storage_lvm.go
@@ -257,41 +257,38 @@ func getTmpSnapshotName(snap string) string {
 }
 
 // Only initialize the minimal information we need about a given storage type.
-func (s *storageLvm) StorageCoreInit() (*storageCore, error) {
-	sCore := storageCore{}
-	sCore.sType = storageTypeLvm
-	typeName, err := storageTypeToString(sCore.sType)
+func (s *storageLvm) StorageCoreInit() error {
+	s.sType = storageTypeLvm
+	typeName, err := storageTypeToString(s.sType)
 	if err != nil {
-		return nil, err
+		return err
 	}
-	sCore.sTypeName = typeName
+	s.sTypeName = typeName
 
 	output, err := exec.Command("lvm", "version").CombinedOutput()
 	if err != nil {
-		return nil, fmt.Errorf("Error getting LVM version: %v\noutput:'%s'", err, string(output))
+		return fmt.Errorf("Error getting LVM version: %v\noutput:'%s'", err, string(output))
 	}
 	lines := strings.Split(string(output), "\n")
 
-	sCore.sTypeVersion = ""
+	s.sTypeVersion = ""
 	for idx, line := range lines {
 		fields := strings.SplitAfterN(line, ":", 2)
 		if len(fields) < 2 {
 			continue
 		}
 		if idx > 0 {
-			sCore.sTypeVersion += " / "
+			s.sTypeVersion += " / "
 		}
-		sCore.sTypeVersion += strings.TrimSpace(fields[1])
+		s.sTypeVersion += strings.TrimSpace(fields[1])
 	}
 
-	s.storageCore = sCore
-
 	shared.LogDebugf("Initializing an LVM driver.")
-	return &sCore, nil
+	return nil
 }
 
 func (s *storageLvm) StoragePoolInit() error {
-	_, err := s.StorageCoreInit()
+	err := s.StorageCoreInit()
 	if err != nil {
 		return err
 	}
diff --git a/lxd/storage_mock.go b/lxd/storage_mock.go
index 8b15486..299e92d 100644
--- a/lxd/storage_mock.go
+++ b/lxd/storage_mock.go
@@ -13,23 +13,20 @@ type storageMock struct {
 	storageShared
 }
 
-func (s *storageMock) StorageCoreInit() (*storageCore, error) {
-	sCore := storageCore{}
-	sCore.sType = storageTypeMock
-	typeName, err := storageTypeToString(sCore.sType)
+func (s *storageMock) StorageCoreInit() error {
+	s.sType = storageTypeMock
+	typeName, err := storageTypeToString(s.sType)
 	if err != nil {
-		return nil, err
+		return err
 	}
-	sCore.sTypeName = typeName
-
-	s.storageCore = sCore
+	s.sTypeName = typeName
 
 	shared.LogDebugf("Initializing a MOCK driver.")
-	return &sCore, nil
+	return nil
 }
 
 func (s *storageMock) StoragePoolInit() error {
-	_, err := s.StorageCoreInit()
+	err := s.StorageCoreInit()
 	if err != nil {
 		return err
 	}
diff --git a/lxd/storage_shared.go b/lxd/storage_shared.go
index b6aa661..8fedce6 100644
--- a/lxd/storage_shared.go
+++ b/lxd/storage_shared.go
@@ -9,7 +9,9 @@ import (
 )
 
 type storageShared struct {
-	storageCore
+	sType        storageType
+	sTypeName    string
+	sTypeVersion string
 
 	d *Daemon
 
@@ -19,6 +21,18 @@ type storageShared struct {
 	volume *api.StorageVolume
 }
 
+func (ss *storageShared) GetStorageType() storageType {
+	return ss.sType
+}
+
+func (ss *storageShared) GetStorageTypeName() string {
+	return ss.sTypeName
+}
+
+func (ss *storageShared) GetStorageTypeVersion() string {
+	return ss.sTypeVersion
+}
+
 func (ss *storageShared) shiftRootfs(c container) error {
 	dpath := c.Path()
 	rpath := c.RootfsPath()
diff --git a/lxd/storage_zfs.go b/lxd/storage_zfs.go
index 239f585..0d4a76b 100644
--- a/lxd/storage_zfs.go
+++ b/lxd/storage_zfs.go
@@ -36,7 +36,7 @@ func (s *storageZfs) getOnDiskPoolName() string {
 	return s.pool.Name
 }
 
-func (s *storageZfs) zfsIsEnabled() bool {
+func zfsIsEnabled() bool {
 	out, err := exec.LookPath("zfs")
 	if err != nil || len(out) == 0 {
 		return false
@@ -45,7 +45,7 @@ func (s *storageZfs) zfsIsEnabled() bool {
 	return true
 }
 
-func (s *storageZfs) zfsModuleVersionGet() (string, error) {
+func zfsModuleVersionGet() (string, error) {
 	zfsVersion, err := ioutil.ReadFile("/sys/module/zfs/version")
 	if err != nil {
 		return "", fmt.Errorf("Could not determine ZFS module version.")
@@ -55,33 +55,30 @@ func (s *storageZfs) zfsModuleVersionGet() (string, error) {
 }
 
 // Only initialize the minimal information we need about a given storage type.
-func (s *storageZfs) StorageCoreInit() (*storageCore, error) {
-	sCore := storageCore{}
-	sCore.sType = storageTypeZfs
-	typeName, err := storageTypeToString(sCore.sType)
+func (s *storageZfs) StorageCoreInit() error {
+	s.sType = storageTypeZfs
+	typeName, err := storageTypeToString(s.sType)
 	if err != nil {
-		return nil, err
+		return err
 	}
-	sCore.sTypeName = typeName
+	s.sTypeName = typeName
 
-	if !s.zfsIsEnabled() {
-		return nil, fmt.Errorf("The \"zfs\" tool is not enabled.")
+	if !zfsIsEnabled() {
+		return fmt.Errorf("The \"zfs\" tool is not enabled.")
 	}
 
-	sCore.sTypeVersion, err = s.zfsModuleVersionGet()
+	s.sTypeVersion, err = zfsModuleVersionGet()
 	if err != nil {
-		return nil, err
+		return err
 	}
 
-	s.storageCore = sCore
-
 	shared.LogDebugf("Initializing a ZFS driver.")
-	return &sCore, nil
+	return nil
 }
 
 // Functions dealing with storage pools.
 func (s *storageZfs) StoragePoolInit() error {
-	_, err := s.StorageCoreInit()
+	err := s.StorageCoreInit()
 	if err != nil {
 		return err
 	}


More information about the lxc-devel mailing list