mirror of
https://github.com/virt-manager/virt-manager.git
synced 2024-10-26 17:25:22 +03:00
534 lines
16 KiB
Python
534 lines
16 KiB
Python
#
|
|
# Storage lookup/creation helpers
|
|
#
|
|
# Copyright 2013 Red Hat, Inc.
|
|
#
|
|
# 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.
|
|
|
|
import logging
|
|
import os
|
|
import statvfs
|
|
|
|
import libvirt
|
|
|
|
from . import util
|
|
from .storage import StoragePool, StorageVolume
|
|
|
|
|
|
def _lookup_pool_by_dirname(conn, path):
|
|
"""
|
|
Try to find the parent pool for the passed path.
|
|
If found, and the pool isn't running, attempt to start it up.
|
|
|
|
return pool, or None if not found
|
|
"""
|
|
pool = StoragePool.lookup_pool_by_path(conn, os.path.dirname(path))
|
|
if not pool:
|
|
return None
|
|
|
|
# Ensure pool is running
|
|
if pool.info()[0] != libvirt.VIR_STORAGE_POOL_RUNNING:
|
|
pool.create(0)
|
|
return pool
|
|
|
|
|
|
def _lookup_vol_by_path(conn, path):
|
|
"""
|
|
Try to find a volume matching the full passed path. Call info() on
|
|
it to ensure the volume wasn't removed behind libvirt's back
|
|
"""
|
|
try:
|
|
vol = conn.storageVolLookupByPath(path)
|
|
vol.info()
|
|
return vol, None
|
|
except libvirt.libvirtError, e:
|
|
if (hasattr(libvirt, "VIR_ERR_NO_STORAGE_VOL")
|
|
and e.get_error_code() != libvirt.VIR_ERR_NO_STORAGE_VOL):
|
|
raise
|
|
return None, e
|
|
|
|
|
|
def _lookup_vol_by_basename(pool, path):
|
|
"""
|
|
Try to lookup a volume for 'path' in parent 'pool' by it's filename.
|
|
This sometimes works in cases where full volume path lookup doesn't,
|
|
since not all libvirt storage backends implement path lookup.
|
|
"""
|
|
name = os.path.basename(path)
|
|
if name in pool.listVolumes():
|
|
return pool.lookupByName(name)
|
|
|
|
|
|
def check_if_path_managed(conn, path):
|
|
"""
|
|
Try to lookup storage objects for the passed path.
|
|
|
|
Returns (volume, parent pool). Only one is returned at a time.
|
|
"""
|
|
vol, ignore = _lookup_vol_by_path(conn, path)
|
|
if vol:
|
|
return vol, None
|
|
|
|
pool = _lookup_pool_by_dirname(conn, path)
|
|
if not pool:
|
|
return None, None
|
|
|
|
# We have the parent pool, but didn't find a volume on first lookup
|
|
# attempt. Refresh the pool and try again, incase we were just out
|
|
# of date.
|
|
try:
|
|
pool.refresh(0)
|
|
vol, verr = _lookup_vol_by_path(conn, path)
|
|
if verr:
|
|
try:
|
|
vol = _lookup_vol_by_basename(pool, path)
|
|
except:
|
|
pass
|
|
except Exception, e:
|
|
vol = None
|
|
pool = None
|
|
verr = str(e)
|
|
|
|
if not vol and not pool and verr:
|
|
raise ValueError(_("Cannot use storage %(path)s: %(err)s") %
|
|
{'path' : path, 'err' : verr})
|
|
|
|
if vol:
|
|
pool = None
|
|
return vol, pool
|
|
|
|
|
|
def _can_auto_manage(path):
|
|
path = path or ""
|
|
skip_prefixes = ["/dev", "/sys", "/proc"]
|
|
|
|
for prefix in skip_prefixes:
|
|
if path.startswith(prefix + "/") or path == prefix:
|
|
return False
|
|
return True
|
|
|
|
|
|
def manage_path(conn, path):
|
|
"""
|
|
If path is not managed, try to create a storage pool to probe the path
|
|
"""
|
|
vol, pool = check_if_path_managed(conn, path)
|
|
if vol or pool or not _can_auto_manage(path):
|
|
return vol, pool
|
|
|
|
dirname = os.path.dirname(path)
|
|
poolname = os.path.basename(dirname).replace(" ", "_")
|
|
if not poolname:
|
|
poolname = "dirpool"
|
|
poolname = StoragePool.find_free_name(conn, poolname)
|
|
logging.debug("Attempting to build pool=%s target=%s", poolname, dirname)
|
|
|
|
poolxml = StoragePool(conn)
|
|
poolxml.name = poolname
|
|
poolxml.type = poolxml.TYPE_DIR
|
|
poolxml.target_path = dirname
|
|
pool = poolxml.install(build=False, create=True, autostart=True)
|
|
conn.clear_cache(pools=True)
|
|
|
|
vol = _lookup_vol_by_basename(pool, path)
|
|
return vol, pool
|
|
|
|
|
|
def build_vol_install(conn, path, pool, size, sparse):
|
|
# Path wasn't a volume. See if base of path is a managed
|
|
# pool, and if so, setup a StorageVolume object
|
|
if size is None:
|
|
raise ValueError(_("Size must be specified for non "
|
|
"existent volume path '%s'" % path))
|
|
|
|
logging.debug("Path '%s' is target for pool '%s'. "
|
|
"Creating volume '%s'.",
|
|
os.path.dirname(path), pool.name(),
|
|
os.path.basename(path))
|
|
|
|
cap = (size * 1024 * 1024 * 1024)
|
|
if sparse:
|
|
alloc = 0
|
|
else:
|
|
alloc = cap
|
|
|
|
volinst = StorageVolume(conn)
|
|
volinst.pool = pool
|
|
volinst.name = os.path.basename(path)
|
|
volinst.capacity = cap
|
|
volinst.allocation = alloc
|
|
return volinst
|
|
|
|
|
|
|
|
class _StorageBase(object):
|
|
def get_size(self):
|
|
raise NotImplementedError()
|
|
def get_dev_type(self):
|
|
raise NotImplementedError()
|
|
def is_managed(self):
|
|
raise NotImplementedError()
|
|
def get_driver_type(self):
|
|
raise NotImplementedError()
|
|
|
|
|
|
class StorageCreator(_StorageBase):
|
|
def __init__(self, conn, path, pool,
|
|
vol_install, clone_path, backing_store,
|
|
size, sparse, fmt):
|
|
_StorageBase.__init__(self)
|
|
|
|
self._conn = conn
|
|
self._pool = pool
|
|
self._vol_install = vol_install
|
|
self._path = path
|
|
self._size = size
|
|
self._sparse = sparse
|
|
self._clone_path = clone_path
|
|
self.fake = False
|
|
|
|
if not self._vol_install and self._pool:
|
|
self._vol_install = build_vol_install(conn, path, pool,
|
|
size, sparse)
|
|
self._set_format(fmt)
|
|
self._set_backing_store(backing_store)
|
|
|
|
if self._vol_install:
|
|
self._path = None
|
|
self._size = None
|
|
|
|
# Cached bits
|
|
self._dev_type = None
|
|
|
|
|
|
###############
|
|
# Private API #
|
|
###############
|
|
|
|
def _set_format(self, val):
|
|
if val is None:
|
|
return
|
|
|
|
if self._vol_install:
|
|
if not self._vol_install.supports_property("format"):
|
|
raise ValueError(_("Storage type does not support format "
|
|
"parameter."))
|
|
if self._vol_install.format != val:
|
|
self._vol_install.format = val
|
|
|
|
elif val != "raw":
|
|
raise RuntimeError(_("Format cannot be specified for "
|
|
"unmanaged storage."))
|
|
|
|
def _set_backing_store(self, val):
|
|
if val is None:
|
|
return
|
|
if not self._vol_install:
|
|
raise RuntimeError(_("Cannot set backing store for unmanaged "
|
|
"storage."))
|
|
self._vol_install.backing_store = val
|
|
|
|
|
|
##############
|
|
# Public API #
|
|
##############
|
|
|
|
def _get_path(self):
|
|
if self._vol_install and not self._path:
|
|
xmlobj = StoragePool(self._conn,
|
|
parsexml=self._vol_install.pool.XMLDesc(0))
|
|
self._path = (xmlobj.target_path + "/" + self._vol_install.name)
|
|
return self._path
|
|
path = property(_get_path)
|
|
|
|
def get_vol_install(self):
|
|
return self._vol_install
|
|
def get_sparse(self):
|
|
return self._sparse
|
|
|
|
def get_size(self):
|
|
if self._size is None:
|
|
self._size = (float(self._vol_install.capacity) /
|
|
1024.0 / 1024.0 / 1024.0)
|
|
return self._size
|
|
|
|
def get_dev_type(self):
|
|
if not self._dev_type:
|
|
if self._vol_install:
|
|
if self._vol_install.file_type == libvirt.VIR_STORAGE_VOL_FILE:
|
|
self._dev_type = "file"
|
|
else:
|
|
self._dev_type = "block"
|
|
else:
|
|
self._dev_type = "file"
|
|
return self._dev_type
|
|
|
|
def get_driver_type(self):
|
|
if self._vol_install:
|
|
if self._vol_install.supports_property("format"):
|
|
return self._vol_install.format
|
|
return "raw"
|
|
|
|
def is_managed(self):
|
|
return bool(self._vol_install)
|
|
|
|
def validate(self, device, devtype):
|
|
if device in ["floppy", "cdrom"]:
|
|
raise ValueError(_("Cannot create storage for %s device.") %
|
|
device)
|
|
|
|
if self.is_managed():
|
|
return self._vol_install.validate()
|
|
if devtype == "block":
|
|
raise ValueError(_("Local block device path '%s' must "
|
|
"exist.") % self.path)
|
|
if self._size is None:
|
|
raise ValueError(_("size is required for non-existent disk "
|
|
"'%s'" % self.path))
|
|
|
|
def is_size_conflict(self):
|
|
if self._vol_install:
|
|
return self._vol_install.is_size_conflict()
|
|
|
|
ret = False
|
|
msg = None
|
|
vfs = os.statvfs(os.path.dirname(self._path))
|
|
avail = vfs[statvfs.F_FRSIZE] * vfs[statvfs.F_BAVAIL]
|
|
need = long(self._size * 1024L * 1024L * 1024L)
|
|
if need > avail:
|
|
if self._sparse:
|
|
msg = _("The filesystem will not have enough free space"
|
|
" to fully allocate the sparse file when the guest"
|
|
" is running.")
|
|
else:
|
|
ret = True
|
|
msg = _("There is not enough free space to create the disk.")
|
|
|
|
|
|
if msg:
|
|
msg += (_(" %d M requested > %d M available") %
|
|
((need / (1024 * 1024)), (avail / (1024 * 1024))))
|
|
return (ret, msg)
|
|
|
|
|
|
#############################
|
|
# Storage creation routines #
|
|
#############################
|
|
|
|
def create(self, progresscb):
|
|
if self.fake:
|
|
raise RuntimeError("Storage creator is fake but creation "
|
|
"requested.")
|
|
|
|
# If a clone_path is specified, but not vol_install.input_vol,
|
|
# that means we are cloning unmanaged -> managed, so skip this
|
|
if (self._vol_install and
|
|
(not self._clone_path or self._vol_install.input_vol)):
|
|
return self._vol_install.install(meter=progresscb)
|
|
|
|
if not self._clone_path:
|
|
raise RuntimeError("Local storage creation requested, "
|
|
"this shouldn't happen.")
|
|
|
|
text = (_("Cloning %(srcfile)s") %
|
|
{'srcfile' : os.path.basename(self._clone_path)})
|
|
|
|
size_bytes = long(self.get_size() * 1024L * 1024L * 1024L)
|
|
progresscb.start(filename=self._path, size=long(size_bytes),
|
|
text=text)
|
|
|
|
# Plain file clone
|
|
self._clone_local(progresscb, size_bytes)
|
|
|
|
def _clone_local(self, meter, size_bytes):
|
|
if self._clone_path == "/dev/null":
|
|
# Not really sure why this check is here,
|
|
# but keeping for compat
|
|
logging.debug("Source dev was /dev/null. Skipping")
|
|
return
|
|
if self._clone_path == self._path:
|
|
logging.debug("Source and destination are the same. Skipping.")
|
|
return
|
|
|
|
# if a destination file exists and sparse flg is True,
|
|
# this priority takes a existing file.
|
|
|
|
if (not os.path.exists(self._path) and self._sparse):
|
|
clone_block_size = 4096
|
|
sparse = True
|
|
fd = None
|
|
try:
|
|
fd = os.open(self._path, os.O_WRONLY | os.O_CREAT, 0640)
|
|
os.ftruncate(fd, size_bytes)
|
|
finally:
|
|
if fd:
|
|
os.close(fd)
|
|
else:
|
|
clone_block_size = 1024 * 1024 * 10
|
|
sparse = False
|
|
|
|
logging.debug("Local Cloning %s to %s, sparse=%s, block_size=%s",
|
|
self._clone_path, self._path, sparse, clone_block_size)
|
|
|
|
zeros = '\0' * 4096
|
|
|
|
src_fd, dst_fd = None, None
|
|
try:
|
|
try:
|
|
src_fd = os.open(self._clone_path, os.O_RDONLY)
|
|
dst_fd = os.open(self._path, os.O_WRONLY | os.O_CREAT, 0640)
|
|
|
|
i = 0
|
|
while 1:
|
|
l = os.read(src_fd, clone_block_size)
|
|
s = len(l)
|
|
if s == 0:
|
|
meter.end(size_bytes)
|
|
break
|
|
# check sequence of zeros
|
|
if sparse and zeros == l:
|
|
os.lseek(dst_fd, s, 1)
|
|
else:
|
|
b = os.write(dst_fd, l)
|
|
if s != b:
|
|
meter.end(i)
|
|
break
|
|
i += s
|
|
if i < size_bytes:
|
|
meter.update(i)
|
|
except OSError, e:
|
|
raise RuntimeError(_("Error cloning diskimage %s to %s: %s") %
|
|
(self._clone_path, self._path, str(e)))
|
|
finally:
|
|
if src_fd is not None:
|
|
os.close(src_fd)
|
|
if dst_fd is not None:
|
|
os.close(dst_fd)
|
|
|
|
|
|
class StorageBackend(_StorageBase):
|
|
"""
|
|
Class that carries all the info about any existing storage that
|
|
the disk references
|
|
"""
|
|
def __init__(self, conn, path, vol_object):
|
|
_StorageBase.__init__(self)
|
|
|
|
self._conn = conn
|
|
self._vol_object = vol_object
|
|
self._path = path
|
|
|
|
if self._vol_object is not None:
|
|
self._path = None
|
|
|
|
# Cached bits
|
|
self._vol_xml = None
|
|
self._exists = None
|
|
self._size = None
|
|
self._dev_type = None
|
|
|
|
|
|
################
|
|
# Internal API #
|
|
################
|
|
|
|
def _get_vol_xml(self):
|
|
if self._vol_xml is None:
|
|
self._vol_xml = StorageVolume(self._conn,
|
|
parsexml=self._vol_object.XMLDesc(0))
|
|
return self._vol_xml
|
|
|
|
|
|
##############
|
|
# Public API #
|
|
##############
|
|
|
|
def _get_path(self):
|
|
if self._vol_object:
|
|
return self._get_vol_xml().target_path
|
|
return self._path
|
|
path = property(_get_path)
|
|
|
|
def get_vol_object(self):
|
|
return self._vol_object
|
|
|
|
def get_size(self):
|
|
"""
|
|
Return size of existing storage
|
|
"""
|
|
if self._size is None:
|
|
ret = 0
|
|
if self._vol_object:
|
|
ret = self._get_vol_xml().capacity
|
|
elif self._path:
|
|
ignore, ret = util.stat_disk(self.path)
|
|
self._size = (float(ret) / 1024.0 / 1024.0 / 1024.0)
|
|
return self._size
|
|
|
|
def exists(self, auto_check=True):
|
|
if self._exists is None:
|
|
if self.path is None:
|
|
self._exists = True
|
|
elif self._vol_object:
|
|
self._exists = True
|
|
elif not self._conn.is_remote() and os.path.exists(self._path):
|
|
self._exists = True
|
|
elif (auto_check and
|
|
self._conn.is_remote() and
|
|
not _can_auto_manage(self._path)):
|
|
# This allows users to pass /dev/sdX and we don't try to
|
|
# validate it exists on the remote connection, since
|
|
# autopooling /dev is perilous. Libvirt will error if
|
|
# the device doesn't exist.
|
|
self._exists = True
|
|
else:
|
|
self._exists = False
|
|
return self._exists
|
|
|
|
def get_dev_type(self):
|
|
"""
|
|
Return disk 'type' value per storage settings
|
|
"""
|
|
if self._dev_type is None:
|
|
if self._vol_object:
|
|
t = self._vol_object.info()[0]
|
|
if t == libvirt.VIR_STORAGE_VOL_FILE:
|
|
self._dev_type = "file"
|
|
elif t == libvirt.VIR_STORAGE_VOL_BLOCK:
|
|
self._dev_type = "block"
|
|
else:
|
|
self._dev_type = "file"
|
|
|
|
elif self._path and not self._conn.is_remote():
|
|
if os.path.isdir(self._path):
|
|
self._dev_type = "dir"
|
|
elif util.stat_disk(self._path)[0]:
|
|
self._dev_type = "file"
|
|
else:
|
|
self._dev_type = "block"
|
|
|
|
if not self._dev_type:
|
|
self._dev_type = "block"
|
|
return self._dev_type
|
|
|
|
def get_driver_type(self):
|
|
if self._vol_object:
|
|
return self._get_vol_xml().format
|
|
return None
|
|
|
|
def is_managed(self):
|
|
return bool(self._vol_object)
|