shaba/virt-manager
1
0
Fork 0
mirror of https://github.com/virt-manager/virt-manager.git synced 2024-12-23 17:34:21 +03:00
Code Issues Projects Releases Wiki Activity
5208c5f321
virt-manager/virtinst/Storage.py
Martin Kletzander 5208c5f321 Fix progress bars in virt-clone once more 
Commit 665375db was meant to fix the progress bar problems, but as
I've found out just made one race (which still persisted) a little
less probable.  The real problem was in the upper code which meant to
finish the progress bar properly, however this was not done thanks to
'finally' statement being not executed when the function returned in
the 'try' part.  This patch makes the upper caller wait for the
updating thread to finish and then properly end()s the progress bar's
output.
2013-07-26 10:08:42 +02:00

1441 lines
49 KiB
Python
Raw Blame History

#
# Copyright 2008, 2013 Red Hat, Inc.
# Cole Robinson <crobinso@redhat.com>
#
# 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 = " <permissions>\n" + \
" <mode>0%o</mode>\n" % perms["mode"] + \
" <owner>%d</owner>\n" % perms["owner"] + \
" <group>%d</group>\n" % perms["group"]
if "label" in perms:
xml += " <label>%s</label>\n" % perms["label"]
xml += " </permissions>\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) + \
""" <name>%s</name>\n""" % (self.name) + \
"""%(stor_xml)s""" % {"stor_xml" : self._get_storage_xml()} + \
"""</%s>\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 = "<source><host name='%s'/></source>" % host
else:
source_xml = "<source/>"
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 = " <source>\n" + \
"%s" % (self._get_source_xml()) + \
" </source>\n"
tar_xml = " <target>\n" + \
"%s" % (self._get_target_xml()) + \
" </target>\n"
return " <uuid>%s</uuid>\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 = " <path>%s</path>\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 = " <path>%s</path>\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 = " <format type='%s'/>\n" % self.format + \
" <device path='%s'/>\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 = " <path>%s</path>\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 = """ <format type="%s"/>\n""" % self.format + \
""" <host name="%s"/>\n""" % self.host + \
""" <dir path="%s"/>\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 = " <path>%s</path>\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 += " <device path='%s'/>\n" % s
if self.source_name:
xml += " <name>%s</name>\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 = " <path>%s</path>\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 = """ <format type="%s"/>\n""" % self.format
xml += """ <device path="%s"/>\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 = " <path>%s</path>\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 += """ <initiator>\n"""
iqn_xml += """ <iqn name="%s"/>\n""" % escape(self.iqn)
iqn_xml += """ </initiator>\n"""
xml = """ <host name="%s"/>\n""" % self.host
xml += """ <device path="%s"/>\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 = " <path>%s</path>\n" % escape(self.target_path)
return xml
def _get_source_xml(self):
if not self.source_path:
raise RuntimeError(_("Adapter name is required"))
xml = """ <adapter name="%s"/>\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 = " <path>%s</path>\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 = " <source>\n" + \
"%s" % (self._get_source_xml()) + \
" </source>\n"
tar_xml = " <target>\n" + \
"%s" % (self._get_target_xml()) + \
" </target>\n"
return " <capacity>%d</capacity>\n" % self.capacity + \
" <allocation>%d</allocation>\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 " <format type='%s'/>\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
Reference in New Issue View Git Blame Copy Permalink