# # Copyright 2008, 2013 Red Hat, Inc. # Cole Robinson # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, # MA 02110-1301 USA. """ Classes for building and installing libvirt storage xml General workflow for the different storage objects: 1. Storage Pool: Pool type options can be exposed to a user via the static function L{StoragePool.get_pool_types}. Any selection can be fed back into L{StoragePool.get_pool_class} to get the particular volume class to instantiate. From here, values can be set at init time or via properties post init. Different pool types have different options and requirements, so using getattr() is probably the best way to check for parameter availability. 2) Storage Volume: There are a few options for determining what pool volume class to use: - Pass the pools type for L{StoragePool.get_volume_for_pool} - Pass the pool object or name to L{StorageVolume.get_volume_for_pool} These will give back the appropriate class to instantiate. For most cases, all that's needed is a name and capacity, the rest will be filled in. @see: U{http://libvirt.org/storage.html} """ import os import threading import time import logging import libvirt import urlgrabber from virtinst.util import xml_escape as escape from virtinst import util DEFAULT_DEV_TARGET = "/dev" DEFAULT_LVM_TARGET_BASE = "/dev/" DEFAULT_DIR_TARGET_BASE = "/var/lib/libvirt/images/" DEFAULT_SCSI_TARGET = "/dev/disk/by-path" DEFAULT_MPATH_TARGET = "/dev/mapper" # Pulled from libvirt, used for building on older versions VIR_STORAGE_VOL_FILE = 0 VIR_STORAGE_VOL_BLOCK = 1 def _parse_pool_source_list(source_xml): def source_parser(node): ret_list = [] child = node.children while child: if child.name == "source": val_dict = {} source = child.children while source: if source.name == "name": val_dict["source_name"] = source.content elif source.name == "host": val_dict["host"] = source.prop("name") elif source.name == "format": val_dict["format"] = source.prop("type") elif source.name in ["device", "dir"]: val_dict["source_path"] = source.prop("path") source = source.next ret_list.append(val_dict) child = child.next for val_dict in ret_list: if (val_dict.get("format") == "lvm2" and val_dict.get("source_name") and not val_dict.get("target_path")): val_dict["target_path"] = (DEFAULT_LVM_TARGET_BASE + val_dict["source_name"]) return ret_list return util.parse_node_helper(source_xml, "sources", source_parser) class StorageObject(object): """ Base class for building any libvirt storage object. Mostly meaningless to directly instantiate. """ TYPE_POOL = "pool" TYPE_VOLUME = "volume" def __init__(self, conn, object_type, name): """ Initialize storage object parameters """ if object_type not in [self.TYPE_POOL, self.TYPE_VOLUME]: raise ValueError(_("Unknown storage object type: %s") % type) self._object_type = object_type self._conn = conn self._name = None self.name = name # Initialize all optional properties self._perms = None ## Properties def get_object_type(self): # 'pool' or 'volume' return self._object_type object_type = property(get_object_type) def _get_conn(self): return self._conn conn = property(_get_conn) def get_name(self): return self._name def set_name(self, val): util.validate_name(_("Storage object"), val) # Check that name doesn't collide with other storage objects self._check_name_collision(val) self._name = val name = property(get_name, set_name, doc=_("Name for the storage object.")) # Get/Set methods for use by some objects. Will register where applicable def get_perms(self): return self._perms def set_perms(self, val): if type(val) is not dict: raise ValueError(_("Permissions must be passed as a dict object")) for key in ["mode", "owner", "group"]: if not key in val: raise ValueError(_("Permissions must contain 'mode', 'owner' and 'group' keys.")) self._perms = val # Validation helper functions def _validate_path(self, path): if not isinstance(path, str) or not path.startswith("/"): raise ValueError(_("'%s' is not an absolute path." % path)) def _check_name_collision(self, name): ignore = name raise NotImplementedError() # XML Building def _get_storage_xml(self): """ Returns the pool/volume specific xml blob """ raise NotImplementedError() def _get_perms_xml(self): perms = self.get_perms() if not perms: return "" xml = " \n" + \ " 0%o\n" % perms["mode"] + \ " %d\n" % perms["owner"] + \ " %d\n" % perms["group"] if "label" in perms: xml += " \n" % perms["label"] xml += " \n" return xml def get_xml_config(self): """ Construct the xml description of the storage object @returns: xml description @rtype: C{str} """ if not hasattr(self, "type"): root_xml = "<%s>\n" % self.object_type else: _type = getattr(self, "type") root_xml = "<%s type='%s'>\n" % (self.object_type, _type) xml = "%s" % (root_xml) + \ """ %s\n""" % (self.name) + \ """%(stor_xml)s""" % {"stor_xml" : self._get_storage_xml()} + \ """\n""" % (self.object_type) return xml class StoragePool(StorageObject): """ Base class for building and installing libvirt storage pool xml """ # @group Types: TYPE_* TYPE_DIR = "dir" TYPE_FS = "fs" TYPE_NETFS = "netfs" TYPE_LOGICAL = "logical" TYPE_DISK = "disk" TYPE_ISCSI = "iscsi" TYPE_SCSI = "scsi" TYPE_MPATH = "mpath" # Pool type descriptions for use in higher level programs _types = {} _types[TYPE_DIR] = _("Filesystem Directory") _types[TYPE_FS] = _("Pre-Formatted Block Device") _types[TYPE_NETFS] = _("Network Exported Directory") _types[TYPE_LOGICAL] = _("LVM Volume Group") _types[TYPE_DISK] = _("Physical Disk Device") _types[TYPE_ISCSI] = _("iSCSI Target") _types[TYPE_SCSI] = _("SCSI Host Adapter") _types[TYPE_MPATH] = _("Multipath Device Enumerator") def get_pool_class(ptype): """ Return class associated with passed pool type. @param ptype: Pool type @type ptype: member of I{Types} """ if ptype not in StoragePool._types: raise ValueError(_("Unknown storage pool type: %s" % ptype)) if ptype == StoragePool.TYPE_DIR: return DirectoryPool if ptype == StoragePool.TYPE_FS: return FilesystemPool if ptype == StoragePool.TYPE_NETFS: return NetworkFilesystemPool if ptype == StoragePool.TYPE_LOGICAL: return LogicalPool if ptype == StoragePool.TYPE_DISK: return DiskPool if ptype == StoragePool.TYPE_ISCSI: return iSCSIPool if ptype == StoragePool.TYPE_SCSI: return SCSIPool if ptype == StoragePool.TYPE_MPATH: return MultipathPool get_pool_class = staticmethod(get_pool_class) def get_volume_for_pool(pool_type): """Convenience method, returns volume class associated with pool_type""" pool_class = StoragePool.get_pool_class(pool_type) return pool_class.get_volume_class() get_volume_for_pool = staticmethod(get_volume_for_pool) def get_pool_types(): """Return list of appropriate pool types""" return StoragePool._types.keys() get_pool_types = staticmethod(get_pool_types) def get_pool_type_desc(pool_type): """Return human readable description for passed pool type""" if pool_type in StoragePool._types: return StoragePool._types[pool_type] else: return "%s pool" % pool_type get_pool_type_desc = staticmethod(get_pool_type_desc) def pool_list_from_sources(conn, name, pool_type, host=None): """ Return a list of StoragePool instances built from libvirt's pool source enumeration (if supported). @param conn: Libvirt connection @param name: Name for the new pool @param pool_type: Pool type string from I{Types} @param host: Option host string to poll for sources """ if not conn.check_conn_support(conn.SUPPORT_CONN_FINDPOOLSOURCES): return [] pool_class = StoragePool.get_pool_class(pool_type) pool_inst = pool_class(conn=conn, name=name) if host: source_xml = "" % host else: source_xml = "" try: xml = conn.findStoragePoolSources(pool_type, source_xml, 0) except libvirt.libvirtError, e: if util.is_error_nosupport(e): return [] raise retlist = [] source_list = _parse_pool_source_list(xml) for source in source_list: pool_inst = pool_class(conn=conn, name=name) for key, val in source.items(): if not hasattr(pool_inst, key): continue setattr(pool_inst, key, val) retlist.append(pool_inst) return retlist pool_list_from_sources = staticmethod(pool_list_from_sources) def __init__(self, conn, name, type, target_path=None, uuid=None): # pylint: disable=W0622 # Redefining built-in 'type', but it matches the XML so keep it StorageObject.__init__(self, object_type=StorageObject.TYPE_POOL, name=name, conn=conn) if type not in self.get_pool_types(): raise ValueError(_("Unknown storage pool type: %s" % type)) self._type = type self._target_path = None self._host = None self._format = None self._source_path = None self._uuid = None if target_path is None: target_path = self._get_default_target_path() self.target_path = target_path if uuid: self.uuid = uuid # Initialize all optional properties self._host = None self._source_path = None self._random_uuid = util.generate_uuid(self.conn) # Properties used by all pools def get_type(self): return self._type type = property(get_type, doc=_("Storage device type the pool will represent.")) def get_target_path(self): return self._target_path def set_target_path(self, val): self._validate_path(val) self._target_path = os.path.abspath(val) # Get/Set methods for use by some pools. Will be registered when applicable def get_source_path(self): return self._source_path def set_source_path(self, val): self._validate_path(val) self._source_path = os.path.abspath(val) def get_host(self): return self._host def set_host(self, val): if not isinstance(val, str): raise ValueError(_("Host name must be a string")) self._host = val # uuid: uuid of the storage object. optional: generated if not set def get_uuid(self): return self._uuid def set_uuid(self, val): val = util.validate_uuid(val) self._uuid = val uuid = property(get_uuid, set_uuid) # Validation functions def _check_name_collision(self, name): pool = None try: pool = self.conn.storagePoolLookupByName(name) except libvirt.libvirtError: pass if pool: raise ValueError(_("Name '%s' already in use by another pool." % name)) def _get_default_target_path(self): raise NotImplementedError() # XML Building def _get_target_xml(self): raise NotImplementedError() def _get_source_xml(self): raise NotImplementedError() def _get_storage_xml(self): src_xml = "" if self._get_source_xml() != "": src_xml = " \n" + \ "%s" % (self._get_source_xml()) + \ " \n" tar_xml = " \n" + \ "%s" % (self._get_target_xml()) + \ " \n" return " %s\n" % (self.uuid or self._random_uuid) + \ "%s" % src_xml + \ "%s" % tar_xml def install(self, meter=None, create=False, build=False, autostart=False): """ Install storage pool xml. """ xml = self.get_xml_config() logging.debug("Creating storage pool '%s' with xml:\n%s", self.name, xml) if not meter: meter = urlgrabber.progress.BaseMeter() try: pool = self.conn.storagePoolDefineXML(xml, 0) except Exception, e: raise RuntimeError(_("Could not define storage pool: %s" % str(e))) errmsg = None if build: try: pool.build(libvirt.VIR_STORAGE_POOL_BUILD_NEW) except Exception, e: errmsg = _("Could not build storage pool: %s" % str(e)) if create and not errmsg: try: pool.create(0) except Exception, e: errmsg = _("Could not start storage pool: %s" % str(e)) if autostart and not errmsg: try: pool.setAutostart(True) except Exception, e: errmsg = _("Could not set pool autostart flag: %s" % str(e)) if errmsg: # Try and clean up the leftover pool try: pool.undefine() except Exception, e: logging.debug("Error cleaning up pool after failure: " + "%s" % str(e)) raise RuntimeError(errmsg) return pool class DirectoryPool(StoragePool): """ Create a directory based storage pool """ def get_volume_class(): return FileVolume get_volume_class = staticmethod(get_volume_class) # Register applicable property methods from parent class perms = property(StorageObject.get_perms, StorageObject.set_perms) target_path = property(StoragePool.get_target_path, StoragePool.set_target_path, doc=_("Directory to use for the storage pool.")) def __init__(self, conn, name, target_path=None, uuid=None, perms=None): StoragePool.__init__(self, name=name, type=StoragePool.TYPE_DIR, target_path=target_path, uuid=uuid, conn=conn) if perms: self.perms = perms def _get_default_target_path(self): path = (DEFAULT_DIR_TARGET_BASE + self.name) return path def _get_target_xml(self): xml = " %s\n" % escape(self.target_path) + \ "%s" % self._get_perms_xml() return xml def _get_source_xml(self): return "" class FilesystemPool(StoragePool): """ Create a formatted partition based storage pool """ def get_volume_class(): return FileVolume get_volume_class = staticmethod(get_volume_class) formats = ["auto", "ext2", "ext3", "ext4", "ufs", "iso9660", "udf", "gfs", "gfs2", "vfat", "hfs+", "xfs"] # Register applicable property methods from parent class perms = property(StorageObject.get_perms, StorageObject.set_perms) source_path = property(StoragePool.get_source_path, StoragePool.set_source_path, doc=_("The existing device to mount for the pool.")) target_path = property(StoragePool.get_target_path, StoragePool.set_target_path, doc=_("Location to mount the source device.")) def __init__(self, conn, name, source_path=None, target_path=None, format="auto", uuid=None, perms=None): # pylint: disable=W0622 # Redefining built-in 'format', but it matches the XML so keep it StoragePool.__init__(self, name=name, type=StoragePool.TYPE_FS, target_path=target_path, uuid=uuid, conn=conn) self.format = format if source_path: self.source_path = source_path if perms: self.perms = perms def get_format(self): return self._format def set_format(self, val): if not val in self.formats: raise ValueError(_("Unknown Filesystem format: %s" % val)) self._format = val format = property(get_format, set_format, doc=_("Filesystem type of the source device.")) def _get_default_target_path(self): path = (DEFAULT_DIR_TARGET_BASE + self.name) return path def _get_target_xml(self): xml = " %s\n" % escape(self.target_path) + \ "%s" % self._get_perms_xml() return xml def _get_source_xml(self): if not self.source_path: raise RuntimeError(_("Device path is required")) xml = " \n" % self.format + \ " \n" % escape(self.source_path) return xml class NetworkFilesystemPool(StoragePool): """ Create a network mounted filesystem storage pool """ def get_volume_class(): return FileVolume get_volume_class = staticmethod(get_volume_class) formats = ["auto", "nfs", "glusterfs"] # Register applicable property methods from parent class source_path = property(StoragePool.get_source_path, StoragePool.set_source_path, doc=_("Path on the host that is being shared.")) host = property(StoragePool.get_host, StoragePool.set_host, doc=_("Name of the host sharing the storage.")) target_path = property(StoragePool.get_target_path, StoragePool.set_target_path, doc=_("Location to mount the source device.")) def __init__(self, conn, name, source_path=None, host=None, target_path=None, format="auto", uuid=None): # pylint: disable=W0622 # Redefining built-in 'format', but it matches the XML so keep it StoragePool.__init__(self, name=name, type=StoragePool.TYPE_NETFS, uuid=uuid, target_path=target_path, conn=conn) self.format = format if source_path: self.source_path = source_path if host: self.host = host def get_format(self): return self._format def set_format(self, val): if not val in self.formats: raise ValueError(_("Unknown Network Filesystem format: %s" % val)) self._format = val format = property(get_format, set_format, doc=_("Type of network filesystem.")) def _get_default_target_path(self): path = (DEFAULT_DIR_TARGET_BASE + self.name) return path def _get_target_xml(self): xml = " %s\n" % escape(self.target_path) return xml def _get_source_xml(self): if not self.host: raise RuntimeError(_("Hostname is required")) if not self.source_path: raise RuntimeError(_("Host path is required")) xml = """ \n""" % self.format + \ """ \n""" % self.host + \ """ \n""" % escape(self.source_path) return xml class LogicalPool(StoragePool): """ Create a logical (lvm volume group) storage pool """ def get_volume_class(): return LogicalVolume get_volume_class = staticmethod(get_volume_class) # Register applicable property methods from parent class perms = property(StorageObject.get_perms, StorageObject.set_perms) target_path = property(StoragePool.get_target_path, StoragePool.set_target_path, doc=_("Location of the existing LVM volume group.")) def __init__(self, conn, name, target_path=None, uuid=None, perms=None, source_path=None, source_name=None): StoragePool.__init__(self, name=name, type=StoragePool.TYPE_LOGICAL, target_path=target_path, uuid=uuid, conn=conn) self._source_name = None if perms: self.perms = perms if source_path: self.source_path = source_path if source_name: self.source_name = source_name # Need to overwrite storage path checks, since this optionally be a list # of devices def get_source_path(self): return self._source_path def set_source_path(self, val): if not val: self._source_path = None return if type(val) != list: StoragePool.set_source_path(self, val) else: self._source_path = val source_path = property(get_source_path, set_source_path, doc=_("Optional device(s) to build new LVM volume " "on.")) def get_source_name(self): if self._source_name: return self._source_name # If a source name isn't explictly set, try to determine it from # existing parameters srcname = self.name if (self.target_path and self.target_path.startswith(DEFAULT_LVM_TARGET_BASE)): # If there is a target path, parse it for an expected VG # location, and pull the name from there vg = self.target_path[len(DEFAULT_LVM_TARGET_BASE):] srcname = vg.split("/", 1)[0] return srcname def set_source_name(self, val): self._source_name = val source_name = property(get_source_name, set_source_name, doc=_("Name of the Volume Group")) def _make_source_name(self): srcname = self.name if self.source_path: # Building a pool, so just use pool name return srcname def _get_default_target_path(self): return DEFAULT_LVM_TARGET_BASE + self.name def _get_target_xml(self): xml = " %s\n" % escape(self.target_path) + \ "%s" % self._get_perms_xml() return xml def _get_source_xml(self): sources = self.source_path if type(sources) != list: sources = sources and [sources] or [] xml = "" for s in sources: xml += " \n" % s if self.source_name: xml += " %s\n" % self.source_name return xml def install(self, meter=None, create=False, build=False, autostart=False): if build and not self.source_path: raise ValueError(_("Must explicitly specify source path if " "building pool")) return StoragePool.install(self, meter=meter, create=create, build=build, autostart=autostart) class DiskPool(StoragePool): """ Create a storage pool from a physical disk """ def get_volume_class(): return DiskVolume get_volume_class = staticmethod(get_volume_class) # Register applicable property methods from parent class source_path = property(StoragePool.get_source_path, StoragePool.set_source_path, doc=_("Path to the existing disk device.")) target_path = property(StoragePool.get_target_path, StoragePool.set_target_path, doc=_("Root location for identifying new storage" " volumes.")) formats = ["auto", "bsd", "dos", "dvh", "gpt", "mac", "pc98", "sun"] def __init__(self, conn, name, source_path=None, target_path=None, format="auto", uuid=None): # pylint: disable=W0622 # Redefining built-in 'format', but it matches the XML so keep it StoragePool.__init__(self, name=name, type=StoragePool.TYPE_DISK, uuid=uuid, target_path=target_path, conn=conn) self.format = format if source_path: self.source_path = source_path def get_format(self): return self._format def set_format(self, val): if not val in self.formats: raise ValueError(_("Unknown Disk format: %s" % val)) self._format = val format = property(get_format, set_format, doc=_("Format of the source device's partition table.")) def _get_default_target_path(self): return DEFAULT_DEV_TARGET def _get_target_xml(self): xml = " %s\n" % escape(self.target_path) return xml def _get_source_xml(self): if not self.source_path: raise RuntimeError(_("Host path is required")) xml = "" # There is no explicit "auto" type for disk pools, but leaving out # the format type seems to do the job for existing formatted disks if self.format != "auto": xml = """ \n""" % self.format xml += """ \n""" % escape(self.source_path) return xml def install(self, meter=None, create=False, build=False, autostart=False): if self.format == "auto" and build: raise ValueError(_("Must explicitly specify disk format if " "formatting disk device.")) return StoragePool.install(self, meter=meter, create=create, build=build, autostart=autostart) class iSCSIPool(StoragePool): """ Create an iSCSI based storage pool """ host = property(StoragePool.get_host, StoragePool.set_host, doc=_("Name of the host sharing the storage.")) target_path = property(StoragePool.get_target_path, StoragePool.set_target_path, doc=_("Root location for identifying new storage" " volumes.")) def get_volume_class(): raise NotImplementedError(_("iSCSI volume creation is not supported.")) get_volume_class = staticmethod(get_volume_class) def __init__(self, conn, name, source_path=None, host=None, target_path=None, uuid=None): StoragePool.__init__(self, name=name, type=StoragePool.TYPE_ISCSI, uuid=uuid, target_path=target_path, conn=conn) if source_path: self.source_path = source_path if host: self.host = host self._iqn = None # Need to overwrite pool *_source_path since iscsi device isn't # a fully qualified path def get_source_path(self): return self._source_path def set_source_path(self, val): self._source_path = val source_path = property(get_source_path, set_source_path, doc=_("Path on the host that is being shared.")) def _get_iqn(self): return self._iqn def _set_iqn(self, val): self._iqn = val iqn = property(_get_iqn, _set_iqn, doc=_("iSCSI initiator qualified name")) def _get_default_target_path(self): return DEFAULT_SCSI_TARGET def _get_target_xml(self): xml = " %s\n" % escape(self.target_path) return xml def _get_source_xml(self): if not self.host: raise RuntimeError(_("Hostname is required")) if not self.source_path: raise RuntimeError(_("Host path is required")) iqn_xml = "" if self.iqn: iqn_xml += """ \n""" iqn_xml += """ \n""" % escape(self.iqn) iqn_xml += """ \n""" xml = """ \n""" % self.host xml += """ \n""" % escape(self.source_path) xml += iqn_xml return xml class SCSIPool(StoragePool): """ Create a SCSI based storage pool """ target_path = property(StoragePool.get_target_path, StoragePool.set_target_path, doc=_("Root location for identifying new storage" " volumes.")) def get_volume_class(): raise NotImplementedError(_("SCSI volume creation is not supported.")) get_volume_class = staticmethod(get_volume_class) def __init__(self, conn, name, source_path=None, target_path=None, uuid=None): StoragePool.__init__(self, name=name, type=StoragePool.TYPE_SCSI, uuid=uuid, target_path=target_path, conn=conn) if source_path: self.source_path = source_path # Need to overwrite pool *_source_path since iscsi device isn't # a fully qualified path def get_source_path(self): return self._source_path def set_source_path(self, val): self._source_path = val source_path = property(get_source_path, set_source_path, doc=_("Name of the scsi adapter (ex. host2)")) def _get_default_target_path(self): return DEFAULT_SCSI_TARGET def _get_target_xml(self): xml = " %s\n" % escape(self.target_path) return xml def _get_source_xml(self): if not self.source_path: raise RuntimeError(_("Adapter name is required")) xml = """ \n""" % escape(self.source_path) return xml class MultipathPool(StoragePool): """ Create a Multipath based storage pool """ target_path = property(StoragePool.get_target_path, StoragePool.set_target_path, doc=_("Root location for identifying new storage" " volumes.")) def get_volume_class(): raise NotImplementedError(_("Multipath volume creation is not " "supported.")) get_volume_class = staticmethod(get_volume_class) def __init__(self, conn, name, target_path=None, uuid=None): StoragePool.__init__(self, name=name, type=StoragePool.TYPE_MPATH, uuid=uuid, target_path=target_path, conn=conn) def _get_default_target_path(self): return DEFAULT_MPATH_TARGET def _get_target_xml(self): xml = " %s\n" % escape(self.target_path) return xml def _get_source_xml(self): return "" ########################## # Storage Volume classes # ########################## class StorageVolume(StorageObject): """ Base class for building and installing libvirt storage volume xml """ formats = [] # File vs. Block for the Volume class _file_type = None def __init__(self, conn, name, capacity, pool_name=None, pool=None, allocation=0): """ @param name: Name for the new storage volume @param capacity: Total size of the new volume (in bytes) @param conn: optional connection instance to lookup pool_name on @param pool_name: optional pool_name to install on @param pool: virStoragePool object to install on @param allocation: amount of storage to actually allocate (default 0) """ if pool is None: if pool_name is None: raise ValueError(_("One of pool or pool_name must be " "specified.")) pool = StorageVolume.lookup_pool_by_name(pool_name=pool_name, conn=conn) self._pool = None self.pool = pool StorageObject.__init__(self, conn, object_type=StorageObject.TYPE_VOLUME, name=name) self._allocation = None self._capacity = None self._format = None self._input_vol = None self.allocation = allocation self.capacity = capacity # Indicate that the volume installation has finished. Used to # definitively tell the storage progress thread to stop polling. self._install_finished = True def get_volume_for_pool(pool_object=None, pool_name=None, conn=None): """ Returns volume class associated with passed pool_object/name """ pool_object = StorageVolume.lookup_pool_by_name(pool_object=pool_object, pool_name=pool_name, conn=conn) return StoragePool.get_volume_for_pool(util.xpath( pool_object.XMLDesc(0), "/pool/@type")) get_volume_for_pool = staticmethod(get_volume_for_pool) def find_free_name(name, pool_object=None, pool_name=None, conn=None, suffix="", collidelist=None, start_num=0): """ Finds a name similar (or equal) to passed 'name' that is not in use by another pool This function scans the list of existing Volumes on the passed or looked up pool object for a collision with the passed name. If the name is in use, it append "-1" to the name and tries again, then "-2", continuing to 100000 (which will hopefully never be reached.") If suffix is specified, attach it to the (potentially incremented) name before checking for collision. Ex name="test", suffix=".img" -> name-3.img @param collidelist: An extra list of names to check for collision @type collidelist: C{list} @returns: A free name @rtype: C{str} """ collidelist = collidelist or [] pool_object = StorageVolume.lookup_pool_by_name( pool_object=pool_object, pool_name=pool_name, conn=conn) pool_object.refresh(0) return util.generate_name(name, pool_object.storageVolLookupByName, suffix, collidelist=collidelist, start_num=start_num) find_free_name = staticmethod(find_free_name) def lookup_pool_by_name(pool_object=None, pool_name=None, conn=None): """ Returns pool object determined from passed parameters. Largely a convenience function for the other static functions. """ if pool_object is None and pool_name is None: raise ValueError(_("Must specify pool_object or pool_name")) if pool_name is not None and pool_object is None: if conn is None: raise ValueError(_("'conn' must be specified with 'pool_name'")) if not conn.check_conn_support(conn.SUPPORT_CONN_STORAGE): raise ValueError(_("Connection does not support storage " "management.")) try: pool_object = conn.storagePoolLookupByName(pool_name) except Exception, e: raise ValueError(_("Couldn't find storage pool '%s': %s" % (pool_name, str(e)))) if not isinstance(pool_object, libvirt.virStoragePool): raise ValueError(_("pool_object must be a virStoragePool")) return pool_object lookup_pool_by_name = staticmethod(lookup_pool_by_name) # Properties used by all volumes def get_file_type(self): return self._file_type file_type = property(get_file_type) def get_capacity(self): return self._capacity def set_capacity(self, val): if type(val) not in (int, float, long) or val < 0: raise ValueError(_("Capacity must be a positive number")) newcap = int(val) origcap = self.capacity origall = self.allocation self._capacity = newcap if self.allocation is not None and (newcap < self.allocation): self._allocation = newcap ret = self.is_size_conflict() if ret[0]: self._capacity = origcap self._allocation = origall raise ValueError(ret[1]) elif ret[1]: logging.warn(ret[1]) capacity = property(get_capacity, set_capacity) def get_allocation(self): return self._allocation def set_allocation(self, val): if type(val) not in (int, float, long) or val < 0: raise ValueError(_("Allocation must be a non-negative number")) newall = int(val) if self.capacity is not None and newall > self.capacity: logging.debug("Capping allocation at capacity.") newall = self.capacity origall = self._allocation self._allocation = newall ret = self.is_size_conflict() if ret[0]: self._allocation = origall raise ValueError(ret[1]) elif ret[1]: logging.warn(ret[1]) allocation = property(get_allocation, set_allocation) def get_pool(self): return self._pool def set_pool(self, newpool): if not isinstance(newpool, libvirt.virStoragePool): raise ValueError(_("'pool' must be a virStoragePool instance.")) if newpool.info()[0] != libvirt.VIR_STORAGE_POOL_RUNNING: raise ValueError(_("pool '%s' must be active." % newpool.name())) self._pool = newpool pool = property(get_pool, set_pool) def get_input_vol(self): return self._input_vol def set_input_vol(self, vol): if vol is None: self._input_vol = None return if not isinstance(vol, libvirt.virStorageVol): raise ValueError(_("input_vol must be a virStorageVol")) if not self.conn.check_pool_support(self.conn, self.conn.SUPPORT_STORAGE_CREATEVOLFROM): raise ValueError(_("Creating storage from an existing volume is" " not supported by this libvirt version.")) self._input_vol = vol input_vol = property(get_input_vol, set_input_vol, doc=_("virStorageVolume pointer to clone/use as " "input.")) # Property functions used by more than one child class def get_format(self): return self._format def set_format(self, val): if val not in self.formats: raise ValueError(_("'%s' is not a valid format.") % val) self._format = val def _check_name_collision(self, name): vol = None try: vol = self.pool.storageVolLookupByName(name) except libvirt.libvirtError: pass if vol: raise ValueError(_("Name '%s' already in use by another volume." % name)) def _check_target_collision(self, path): col = None try: col = self.conn.storageVolLookupByPath(path) except libvirt.libvirtError: pass if col: return True return False # xml building functions def _get_target_xml(self): raise NotImplementedError() def _get_source_xml(self): raise NotImplementedError() def _get_storage_xml(self): src_xml = "" if self._get_source_xml() != "": src_xml = " \n" + \ "%s" % (self._get_source_xml()) + \ " \n" tar_xml = " \n" + \ "%s" % (self._get_target_xml()) + \ " \n" return " %d\n" % self.capacity + \ " %d\n" % self.allocation + \ "%s" % src_xml + \ "%s" % tar_xml def install(self, meter=None): """ Build and install storage volume from xml """ xml = self.get_xml_config() logging.debug("Creating storage volume '%s' with xml:\n%s", self.name, xml) t = threading.Thread(target=self._progress_thread, name="Checking storage allocation", args=(meter,)) t.setDaemon(True) if not meter: meter = urlgrabber.progress.BaseMeter() try: self._install_finished = False t.start() meter.start(size=self.capacity, text=_("Allocating '%s'") % self.name) if self.input_vol: vol = self.pool.createXMLFrom(xml, self.input_vol, 0) else: vol = self.pool.createXML(xml, 0) self._install_finished = True t.join() meter.end(self.capacity) logging.debug("Storage volume '%s' install complete.", self.name) return vol except libvirt.libvirtError, e: if util.is_error_nosupport(e): raise RuntimeError("Libvirt version does not support " "storage cloning.") raise except Exception, e: raise RuntimeError("Couldn't create storage volume " "'%s': '%s'" % (self.name, str(e))) def _progress_thread(self, meter): lookup_attempts = 10 vol = None if not meter: return while lookup_attempts > 0: try: vol = self.pool.storageVolLookupByName(self.name) break except: lookup_attempts -= 1 time.sleep(.2) if self._install_finished: break else: continue break if vol is None: logging.debug("Couldn't lookup storage volume in prog thread.") return while not self._install_finished: ignore, ignore, alloc = vol.info() meter.update(alloc) time.sleep(1) def is_size_conflict(self): """ Report if requested size exceeds its pool's available amount @returns: 2 element tuple: 1. True if collision is fatal, false otherwise 2. String message if some collision was encountered. @rtype: 2 element C{tuple}: (C{bool}, C{str}) """ # pool info is [pool state, capacity, allocation, available] avail = self.pool.info()[3] if self.allocation > avail: return (True, _("There is not enough free space on the storage " "pool to create the volume. " "(%d M requested allocation > %d M available)" % ((self.allocation / (1024 * 1024)), (avail / (1024 * 1024))))) elif self.capacity > avail: return (False, _("The requested volume capacity will exceed the " "available pool space when the volume is fully " "allocated. " "(%d M requested capacity > %d M available)" % ((self.capacity / (1024 * 1024)), (avail / (1024 * 1024))))) return (False, "") class FileVolume(StorageVolume): """ Build and install xml for use on pools which use file based storage """ _file_type = VIR_STORAGE_VOL_FILE formats = ["raw", "bochs", "cloop", "cow", "dmg", "iso", "qcow", "qcow2", "qed", "vmdk", "vpc"] create_formats = ["raw", "cow", "qcow", "qcow2", "qed", "vmdk", "vpc"] # Register applicable property methods from parent class perms = property(StorageObject.get_perms, StorageObject.set_perms) format = property(StorageVolume.get_format, StorageVolume.set_format) def __init__(self, conn, name, capacity, pool=None, pool_name=None, format="raw", allocation=None, perms=None): # pylint: disable=W0622 # Redefining built-in 'format', but it matches the XML so keep it StorageVolume.__init__(self, conn, name=name, pool=pool, pool_name=pool_name, allocation=allocation, capacity=capacity) self.format = format if perms: self.perms = perms def _get_target_xml(self): return " \n" % self.format + \ "%s" % self._get_perms_xml() def _get_source_xml(self): return "" class DiskVolume(StorageVolume): """ Build and install xml volumes for use on physical disk pools """ _file_type = VIR_STORAGE_VOL_BLOCK # Register applicable property methods from parent class perms = property(StorageObject.get_perms, StorageObject.set_perms) def __init__(self, conn, name, capacity, pool=None, pool_name=None, allocation=None, perms=None): StorageVolume.__init__(self, conn, name=name, pool=pool, pool_name=pool_name, allocation=allocation, capacity=capacity) if perms: self.perms = perms def _get_target_xml(self): return "%s" % self._get_perms_xml() def _get_source_xml(self): return "" class LogicalVolume(StorageVolume): """ Build and install logical volumes for lvm pools """ _file_type = VIR_STORAGE_VOL_BLOCK # Register applicable property methods from parent class perms = property(StorageObject.get_perms, StorageObject.set_perms) def __init__(self, conn, name, capacity, pool=None, pool_name=None, allocation=None, perms=None): if allocation and allocation != capacity: logging.warn(_("Sparse logical volumes are not supported, " "setting allocation equal to capacity")) StorageVolume.__init__(self, conn, name=name, pool=pool, pool_name=pool_name, allocation=capacity, capacity=capacity) if perms: self.perms = perms def set_capacity(self, capacity): super(LogicalVolume, self).set_capacity(capacity) self.allocation = capacity capacity = property(StorageVolume.get_capacity, set_capacity) def set_allocation(self, allocation): if allocation != self.capacity: logging.warn(_("Sparse logical volumes are not supported, " "setting allocation equal to capacity")) super(LogicalVolume, self).set_allocation(self.capacity) capacity = property(StorageVolume.get_allocation, set_allocation) def _get_target_xml(self): return "%s" % self._get_perms_xml() def _get_source_xml(self): return "" class CloneVolume(StorageVolume): """ Build and install a volume that is a clone of an existing volume """ format = property(StorageVolume.get_format, StorageVolume.set_format) def __init__(self, conn, name, input_vol): if not isinstance(input_vol, libvirt.virStorageVol): raise ValueError(_("input_vol must be a virStorageVol")) pool = input_vol.storagePoolLookupByVolume() # Populate some basic info xml = input_vol.XMLDesc(0) typ = input_vol.info()[0] cap = int(util.xpath(xml, "/volume/capacity")) alc = int(util.xpath(xml, "/volume/allocation")) fmt = util.xpath(xml, "/volume/target/format/@type") StorageVolume.__init__(self, conn, name=name, pool=pool, pool_name=pool.name(), allocation=alc, capacity=cap) self.input_vol = input_vol self._file_type = typ self._format = fmt def _get_target_xml(self): return "" def _get_source_xml(self): return "" def get_xml_config(self): xml = self.input_vol.XMLDesc(0) newxml = util.set_xml_path(xml, "/volume/name", self.name) return newxml # class iSCSIVolume(StorageVolume): # """ # Build and install xml for use on iSCSI device pools # """ # _file_type = VIR_STORAGE_VOL_BLOCK # # def __init__(self, *args, **kwargs): # raise NotImplementedError