360 lines
12 KiB
Python
360 lines
12 KiB
Python
# Copyright 2014 Mirantis, Inc.
|
|
#
|
|
# 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.
|
|
|
|
import os
|
|
|
|
from fuel_agent import errors
|
|
from fuel_agent.openstack.common import log as logging
|
|
|
|
LOG = logging.getLogger(__name__)
|
|
|
|
|
|
class Parted(object):
|
|
def __init__(self, name, label):
|
|
self.name = name
|
|
self.label = label
|
|
self.partitions = []
|
|
self.install_bootloader = False
|
|
|
|
def add_partition(self, **kwargs):
|
|
# TODO(kozhukalov): validate before appending
|
|
# calculating partition name based on device name and partition count
|
|
kwargs['name'] = self.next_name()
|
|
kwargs['count'] = self.next_count()
|
|
kwargs['device'] = self.name
|
|
# if begin is given use its value else use end of last partition
|
|
kwargs['begin'] = kwargs.get('begin', self.next_begin())
|
|
# if end is given use its value else
|
|
# try to calculate it based on size kwarg or
|
|
# raise KeyError
|
|
# (kwargs.pop['size'] will raise error if size is not set)
|
|
kwargs['end'] = kwargs.get('end') or \
|
|
kwargs['begin'] + kwargs.pop('size')
|
|
# if partition_type is given use its value else
|
|
# try to calculate it automatically
|
|
kwargs['partition_type'] = \
|
|
kwargs.get('partition_type', self.next_type())
|
|
partition = Partition(**kwargs)
|
|
self.partitions.append(partition)
|
|
return partition
|
|
|
|
@property
|
|
def logical(self):
|
|
return filter(lambda x: x.type == 'logical', self.partitions)
|
|
|
|
@property
|
|
def primary(self):
|
|
return filter(lambda x: x.type == 'primary', self.partitions)
|
|
|
|
@property
|
|
def extended(self):
|
|
found = filter(lambda x: x.type == 'extended', self.partitions)
|
|
if found:
|
|
return found[0]
|
|
|
|
def next_type(self):
|
|
if self.label == 'gpt':
|
|
return 'primary'
|
|
elif self.label == 'msdos':
|
|
if self.extended:
|
|
return 'logical'
|
|
elif len(self.partitions) < 3 and not self.extended:
|
|
return 'primary'
|
|
elif len(self.partitions) == 3 and not self.extended:
|
|
return 'extended'
|
|
# NOTE(agordeev): how to reach that condition?
|
|
else:
|
|
return 'logical'
|
|
|
|
def next_count(self, next_type=None):
|
|
next_type = next_type or self.next_type()
|
|
if next_type == 'logical':
|
|
return len(self.logical) + 5
|
|
return len(self.partitions) + 1
|
|
|
|
def next_begin(self):
|
|
if not self.partitions:
|
|
return 1
|
|
if self.partitions[-1] == self.extended:
|
|
return self.partitions[-1].begin
|
|
return self.partitions[-1].end
|
|
|
|
def next_name(self):
|
|
if self.next_type() == 'extended':
|
|
return None
|
|
separator = ''
|
|
special_devices = ('cciss', 'nvme', 'loop')
|
|
if any(n in self.name for n in special_devices):
|
|
separator = 'p'
|
|
return '%s%s%s' % (self.name, separator, self.next_count())
|
|
|
|
|
|
class Partition(object):
|
|
def __init__(self, name, count, device, begin, end, partition_type,
|
|
flags=None, guid=None, configdrive=False):
|
|
self.name = name
|
|
self.count = count
|
|
self.device = device
|
|
self.name = name
|
|
self.begin = begin
|
|
self.end = end
|
|
self.type = partition_type
|
|
self.flags = flags or []
|
|
self.guid = guid
|
|
self.configdrive = configdrive
|
|
|
|
def set_flag(self, flag):
|
|
if flag not in self.flags:
|
|
self.flags.append(flag)
|
|
|
|
def set_guid(self, guid):
|
|
self.guid = guid
|
|
|
|
|
|
class Pv(object):
|
|
def __init__(self, name, metadatasize=16, metadatacopies=2):
|
|
self.name = name
|
|
self.metadatasize = metadatasize
|
|
self.metadatacopies = metadatacopies
|
|
|
|
|
|
class Vg(object):
|
|
def __init__(self, name, pvnames=None):
|
|
self.name = name
|
|
self.pvnames = pvnames or []
|
|
|
|
def add_pv(self, pvname):
|
|
if pvname not in self.pvnames:
|
|
self.pvnames.append(pvname)
|
|
|
|
|
|
class Lv(object):
|
|
def __init__(self, name, vgname, size):
|
|
self.name = name
|
|
self.vgname = vgname
|
|
self.size = size
|
|
|
|
@property
|
|
def device_name(self):
|
|
return '/dev/mapper/%s-%s' % (self.vgname.replace('-', '--'),
|
|
self.name.replace('-', '--'))
|
|
|
|
|
|
class Md(object):
|
|
def __init__(self, name, level,
|
|
devices=None, spares=None):
|
|
self.name = name
|
|
self.level = level
|
|
self.devices = devices or []
|
|
self.spares = spares or []
|
|
|
|
def add_device(self, device):
|
|
if device in self.devices or device in self.spares:
|
|
raise errors.MDDeviceDuplicationError(
|
|
'Error while attaching device to md: '
|
|
'device %s is already attached' % device)
|
|
self.devices.append(device)
|
|
|
|
def add_spare(self, device):
|
|
if device in self.devices or device in self.spares:
|
|
raise errors.MDDeviceDuplicationError(
|
|
'Error while attaching device to md: '
|
|
'device %s is already attached' % device)
|
|
self.spares.append(device)
|
|
|
|
|
|
class Fs(object):
|
|
def __init__(self, device, mount=None,
|
|
fs_type=None, fs_options=None, fs_label=None):
|
|
self.device = device
|
|
self.mount = mount
|
|
self.type = fs_type or 'xfs'
|
|
self.options = fs_options or ''
|
|
self.label = fs_label or ''
|
|
|
|
|
|
class PartitionScheme(object):
|
|
def __init__(self):
|
|
self.parteds = []
|
|
self.mds = []
|
|
self.pvs = []
|
|
self.vgs = []
|
|
self.lvs = []
|
|
self.fss = []
|
|
|
|
def add_parted(self, **kwargs):
|
|
parted = Parted(**kwargs)
|
|
self.parteds.append(parted)
|
|
return parted
|
|
|
|
def add_pv(self, **kwargs):
|
|
pv = Pv(**kwargs)
|
|
self.pvs.append(pv)
|
|
return pv
|
|
|
|
def add_vg(self, **kwargs):
|
|
vg = Vg(**kwargs)
|
|
self.vgs.append(vg)
|
|
return vg
|
|
|
|
def add_lv(self, **kwargs):
|
|
lv = Lv(**kwargs)
|
|
self.lvs.append(lv)
|
|
return lv
|
|
|
|
def add_fs(self, **kwargs):
|
|
fs = Fs(**kwargs)
|
|
self.fss.append(fs)
|
|
return fs
|
|
|
|
def add_md(self, **kwargs):
|
|
mdkwargs = {}
|
|
mdkwargs['name'] = kwargs.get('name') or self.md_next_name()
|
|
mdkwargs['level'] = kwargs.get('level') or 'mirror'
|
|
md = Md(**mdkwargs)
|
|
self.mds.append(md)
|
|
return md
|
|
|
|
def md_by_name(self, name):
|
|
found = filter(lambda x: x.name == name, self.mds)
|
|
if found:
|
|
return found[0]
|
|
|
|
def md_by_mount(self, mount):
|
|
fs = self.fs_by_mount(mount)
|
|
if fs:
|
|
return self.md_by_name(fs.device)
|
|
|
|
def md_attach_by_mount(self, device, mount, spare=False, **kwargs):
|
|
md = self.md_by_mount(mount)
|
|
if not md:
|
|
md = self.add_md(**kwargs)
|
|
fskwargs = {}
|
|
fskwargs['device'] = md.name
|
|
fskwargs['mount'] = mount
|
|
fskwargs['fs_type'] = kwargs.pop('fs_type', None)
|
|
fskwargs['fs_options'] = kwargs.pop('fs_options', None)
|
|
fskwargs['fs_label'] = kwargs.pop('fs_label', None)
|
|
self.add_fs(**fskwargs)
|
|
md.add_spare(device) if spare else md.add_device(device)
|
|
return md
|
|
|
|
def md_next_name(self):
|
|
count = 0
|
|
while True:
|
|
name = '/dev/md%s' % count
|
|
if name not in [md.name for md in self.mds]:
|
|
return name
|
|
if count >= 127:
|
|
raise errors.MDAlreadyExistsError(
|
|
'Error while generating md name: '
|
|
'names from /dev/md0 to /dev/md127 seem to be busy, '
|
|
'try to generate md name manually')
|
|
count += 1
|
|
|
|
def vg_by_name(self, vgname):
|
|
found = filter(lambda x: (x.name == vgname), self.vgs)
|
|
if found:
|
|
return found[0]
|
|
|
|
def pv_by_name(self, pvname):
|
|
found = filter(lambda x: (x.name == pvname), self.pvs)
|
|
if found:
|
|
return found[0]
|
|
|
|
def vg_attach_by_name(self, pvname, vgname,
|
|
metadatasize=16, metadatacopies=2):
|
|
vg = self.vg_by_name(vgname) or self.add_vg(name=vgname)
|
|
pv = self.pv_by_name(pvname) or self.add_pv(
|
|
name=pvname, metadatasize=metadatasize,
|
|
metadatacopies=metadatacopies)
|
|
vg.add_pv(pv.name)
|
|
|
|
def fs_by_mount(self, mount):
|
|
found = filter(lambda x: (x.mount and x.mount == mount), self.fss)
|
|
if found:
|
|
return found[0]
|
|
|
|
def fs_by_device(self, device):
|
|
found = filter(lambda x: x.device == device, self.fss)
|
|
if found:
|
|
return found[0]
|
|
|
|
def fs_sorted_by_depth(self, reverse=False):
|
|
"""Getting file systems sorted by path length.
|
|
|
|
Shorter paths earlier.
|
|
['/', '/boot', '/var', '/var/lib/mysql']
|
|
:param reverse: Sort backward (Default: False)
|
|
"""
|
|
def key(x):
|
|
return x.mount.rstrip(os.path.sep).count(os.path.sep)
|
|
return sorted(self.fss, key=key, reverse=reverse)
|
|
|
|
def lv_by_device_name(self, device_name):
|
|
found = filter(lambda x: x.device_name == device_name, self.lvs)
|
|
if found:
|
|
return found[0]
|
|
|
|
def root_device(self):
|
|
fs = self.fs_by_mount('/')
|
|
if not fs:
|
|
raise errors.WrongPartitionSchemeError(
|
|
'Error while trying to find root device: '
|
|
'root file system not found')
|
|
return fs.device
|
|
|
|
def boot_device(self, grub_version=2):
|
|
# We assume /boot is a separate partition. If it is not
|
|
# then we try to use root file system
|
|
boot_fs = self.fs_by_mount('/boot') or self.fs_by_mount('/')
|
|
if not boot_fs:
|
|
raise errors.WrongPartitionSchemeError(
|
|
'Error while trying to find boot device: '
|
|
'boot file system not fount, '
|
|
'it must be a separate mount point')
|
|
|
|
if grub_version == 1:
|
|
# Legacy GRUB has a limitation. It is not able to mount MD devices.
|
|
# If it is MD compatible it is only able to ignore MD metadata
|
|
# and to mount one of those devices which are parts of MD device,
|
|
# but it is possible only if MD device is a MIRROR.
|
|
md = self.md_by_name(boot_fs.device)
|
|
if md:
|
|
try:
|
|
return md.devices[0]
|
|
except IndexError:
|
|
raise errors.WrongPartitionSchemeError(
|
|
'Error while trying to find boot device: '
|
|
'md device %s does not have devices attached' %
|
|
md.name)
|
|
# Legacy GRUB is not able to mount LVM devices.
|
|
if self.lv_by_device_name(boot_fs.device):
|
|
raise errors.WrongPartitionSchemeError(
|
|
'Error while trying to find boot device: '
|
|
'found device is %s but legacy grub is not able to '
|
|
'mount logical volumes' %
|
|
boot_fs.device)
|
|
|
|
return boot_fs.device
|
|
|
|
def configdrive_device(self):
|
|
# Configdrive device must be a small (about 10M) partition
|
|
# on one of node hard drives. This partition is necessary
|
|
# only if one uses cloud-init with configdrive.
|
|
for parted in self.parteds:
|
|
for prt in parted.partitions:
|
|
if prt.configdrive:
|
|
return prt.name
|