ceph-volume batch: rename block_devs to data_devs for consistency

Signed-off-by: Jan Fajerski <jfajerski@suse.com>
(cherry picked from commit 6dbf43e53ccd3ff06e3cdfc8e6de97475cc0c510)

diff --git a/src/ceph-volume/ceph_volume/devices/lvm/strategies/bluestore.py b/src/ceph-volume/ceph_volume/devices/lvm/strategies/bluestore.py
index f10ffd6e0fbec867f2cfeea8aba4c2bb92f94cab..ff7c36f5b41f09e869be6a441a316df5e7ae5da0 100644 (file)
--- a/src/ceph-volume/ceph_volume/devices/lvm/strategies/bluestore.py
+++ b/src/ceph-volume/ceph_volume/devices/lvm/strategies/bluestore.py
@@ -15,8 +15,8 @@ class SingleType(Strategy):
     Support for all SSDs, or all HDDS
     """
 
-    def __init__(self, block_devs, args):
-        super(SingleType, self).__init__(block_devs, [], [], args)
+    def __init__(self, data_devs, args):
+        super(SingleType, self).__init__(data_devs, [], [], args)
         self.validate_compute()
 
     @classmethod
@@ -55,11 +55,11 @@ class SingleType(Strategy):
         """
         # validate minimum size for all devices
         validators.minimum_device_size(
-            self.block_devs, osds_per_device=self.osds_per_device
+            self.data_devs, osds_per_device=self.osds_per_device
         )
 
         # make sure that data devices do not have any LVs
-        validators.no_lvm_membership(self.block_devs)
+        validators.no_lvm_membership(self.data_devs)
 
     def compute(self):
         """
@@ -67,7 +67,7 @@ class SingleType(Strategy):
         a dictionary with the result
         """
         osds = self.computed['osds']
-        for device in self.block_devs:
+        for device in self.data_devs:
             extents = lvm.sizing(device.lvm_size.b, parts=self.osds_per_device)
             for _i in range(self.osds_per_device):
                 osd = {'data': {}, 'block.db': {}}
@@ -117,18 +117,18 @@ class SingleType(Strategy):
 
 class MixedType(MixedStrategy):
 
-    def __init__(self, block_devs, db_devs, wal_devs, args):
-        super(MixedType, self).__init__(block_devs, db_devs, wal_devs, args)
+    def __init__(self, data_devs, db_devs, wal_devs, args):
+        super(MixedType, self).__init__(data_devs, db_devs, wal_devs, args)
         self.block_db_size = self.get_block_size()
         self.system_vgs = lvm.VolumeGroups()
-        self.dbs_needed = len(self.block_devs) * self.osds_per_device
+        self.dbs_needed = len(self.data_devs) * self.osds_per_device
         self.use_large_block_db = False
         self.validate_compute()
 
     @classmethod
     def with_auto_devices(cls, devices, args):
-        block_devs, db_devs = cls.split_devices_rotational(devices)
-        return cls(block_devs, db_devs, [], args)
+        data_devs, db_devs = cls.split_devices_rotational(devices)
+        return cls(data_devs, db_devs, [], args)
 
     @staticmethod
     def type():
@@ -148,7 +148,7 @@ class MixedType(MixedStrategy):
         if filtered_devices:
             string += templates.filtered_devices(filtered_devices)
         string += templates.total_osds.format(
-            total_osds=len(self.block_devs) * self.osds_per_device
+            total_osds=len(self.data_devs) * self.osds_per_device
         )
 
         string += templates.ssd_volume_group.format(
@@ -158,7 +158,7 @@ class MixedType(MixedStrategy):
             block_lv_size=db_size,
             block_db_devices=', '.join([ssd.abspath for ssd in self.db_devs]),
             lv_size=self.block_db_size or str(disk.Size(b=(vg_extents['sizes']))),
-            total_osds=len(self.block_devs)
+            total_osds=len(self.data_devs)
         )
 
         string += templates.osd_component_titles
@@ -197,7 +197,7 @@ class MixedType(MixedStrategy):
         else:
             vg_name = self.common_vg.name
 
-        for device in self.block_devs:
+        for device in self.data_devs:
             for hdd in range(self.osds_per_device):
                 osd = {'data': {}, 'block.db': {}}
                 osd['data']['path'] = device.abspath
@@ -292,7 +292,7 @@ class MixedType(MixedStrategy):
         validators.minimum_device_size(self.devices, osds_per_device=self.osds_per_device)
 
         # make sure that data devices do not have any LVs
-        validators.no_lvm_membership(self.block_devs)
+        validators.no_lvm_membership(self.data_devs)
 
         # do not allow non-common VG to continue
         validators.has_common_vg(self.db_devs)

diff --git a/src/ceph-volume/ceph_volume/devices/lvm/strategies/filestore.py b/src/ceph-volume/ceph_volume/devices/lvm/strategies/filestore.py
index 681f55d2cdd482f9a0b999298b374b45ce159429..29a9ebd4d53afc20d53c90bdfec8abc8a1a36703 100644 (file)
--- a/src/ceph-volume/ceph_volume/devices/lvm/strategies/filestore.py
+++ b/src/ceph-volume/ceph_volume/devices/lvm/strategies/filestore.py
@@ -28,8 +28,8 @@ class SingleType(Strategy):
     """
 
 
-    def __init__(self, block_devs, args):
-        super(SingleType, self).__init__(block_devs, [], [], args)
+    def __init__(self, data_devs, args):
+        super(SingleType, self).__init__(data_devs, [], [], args)
         self.journal_size = get_journal_size(args)
         self.validate_compute()
 
@@ -73,15 +73,15 @@ class SingleType(Strategy):
         met, raise an error if the provided devices would not work
         """
         # validate minimum size for all devices
-        validators.minimum_device_size(self.block_devs, osds_per_device=self.osds_per_device)
+        validators.minimum_device_size(self.data_devs, osds_per_device=self.osds_per_device)
 
         # validate collocation
         validators.minimum_device_collocated_size(
-            self.block_devs, self.journal_size, osds_per_device=self.osds_per_device
+            self.data_devs, self.journal_size, osds_per_device=self.osds_per_device
         )
 
         # make sure that data devices do not have any LVs
-        validators.no_lvm_membership(self.block_devs)
+        validators.no_lvm_membership(self.data_devs)
 
     def compute(self):
         """
@@ -90,7 +90,7 @@ class SingleType(Strategy):
         """
         # chose whichever is the one group we have to compute against
         osds = self.computed['osds']
-        for device in self.block_devs:
+        for device in self.data_devs:
             for osd in range(self.osds_per_device):
                 device_size = disk.Size(b=device.lvm_size.b)
                 osd_size = device_size / self.osds_per_device
@@ -167,18 +167,18 @@ class MixedType(MixedStrategy):
     """
 
 
-    def __init__(self, block_devs, journal_devs, args):
-        super(MixedType, self).__init__(block_devs, journal_devs, [], args)
+    def __init__(self, data_devs, journal_devs, args):
+        super(MixedType, self).__init__(data_devs, journal_devs, [], args)
         self.blank_ssds = []
-        self.journals_needed = len(self.block_devs) * self.osds_per_device
+        self.journals_needed = len(self.data_devs) * self.osds_per_device
         self.journal_size = get_journal_size(args)
         self.system_vgs = lvm.VolumeGroups()
         self.validate_compute()
 
     @classmethod
     def with_auto_devices(cls, devices, args):
-        block_devs, journal_devs = cls.split_devices_rotational(devices)
-        return cls(block_devs, journal_devs, args)
+        data_devs, journal_devs = cls.split_devices_rotational(devices)
+        return cls(data_devs, journal_devs, args)
 
     @staticmethod
     def type():
@@ -229,7 +229,7 @@ class MixedType(MixedStrategy):
         validators.minimum_device_size(self.devices, osds_per_device=self.osds_per_device)
 
         # make sure that data devices do not have any LVs
-        validators.no_lvm_membership(self.block_devs)
+        validators.no_lvm_membership(self.data_devs)
 
         # do not allow non-common VG to continue
         validators.has_common_vg(self.db_devs)
@@ -295,7 +295,7 @@ class MixedType(MixedStrategy):
         else:
             vg_name = self.common_vg.name
 
-        for device in self.block_devs:
+        for device in self.data_devs:
             for osd in range(self.osds_per_device):
                 device_size = disk.Size(b=device.lvm_size.b)
                 data_size = device_size / self.osds_per_device

diff --git a/src/ceph-volume/ceph_volume/devices/lvm/strategies/strategies.py b/src/ceph-volume/ceph_volume/devices/lvm/strategies/strategies.py
index 272eb107d7e9d9ba578846abc4e6d198d8325f3d..eddf623a3eb0f346b9c310b06416e5eb085ed40e 100644 (file)
--- a/src/ceph-volume/ceph_volume/devices/lvm/strategies/strategies.py
+++ b/src/ceph-volume/ceph_volume/devices/lvm/strategies/strategies.py
@@ -2,20 +2,20 @@ import json
 
 class Strategy(object):
 
-    def __init__(self, block_devs, db_devs, wal_devs, args):
+    def __init__(self, data_devs, db_devs, wal_devs, args):
         self.args = args
         self.osds_per_device = args.osds_per_device
-        self.devices = block_devs + wal_devs + db_devs
-        self.block_devs = block_devs
+        self.devices = data_devs + wal_devs + db_devs
+        self.data_devs = data_devs
         self.db_devs = db_devs
         self.wal_devs = wal_devs
         self.computed = {'osds': [], 'vgs': []}
 
     @staticmethod
     def split_devices_rotational(devices):
-        block_devs = [device for device in devices if device.sys_api['rotational'] == '1']
+        data_devs = [device for device in devices if device.sys_api['rotational'] == '1']
         db_devs = [device for device in devices if device.sys_api['rotational'] == '0']
-        return block_devs, db_devs
+        return data_devs, db_devs
 
 
     def validate_compute(self):
@@ -33,7 +33,7 @@ class Strategy(object):
 
     @property
     def total_osds(self):
-        return len(self.block_devs) * self.osds_per_device
+        return len(self.data_devs) * self.osds_per_device
 
     # protect against base class instantiation and incomplete implementations.
     # We could also use the abc module and implement this as an