520 lines
17 KiB
Python
520 lines
17 KiB
Python
# Copyright (c) 2012 OpenStack Foundation
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
# not use this file except in compliance with the License. You may obtain
|
|
# a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
# License for the specific language governing permissions and limitations
|
|
# under the License.
|
|
|
|
# NOTE: XenServer still only supports Python 2.4 in it's dom0 userspace
|
|
# which means the Nova xenapi plugins must use only Python 2.4 features
|
|
|
|
"""Various utilities used by XenServer plugins."""
|
|
|
|
try:
|
|
import cPickle as pickle
|
|
except ImportError:
|
|
import pickle
|
|
|
|
import errno
|
|
import logging
|
|
import os
|
|
import shutil
|
|
import signal
|
|
import subprocess
|
|
import tempfile
|
|
|
|
import XenAPIPlugin
|
|
|
|
LOG = logging.getLogger(__name__)
|
|
CHUNK_SIZE = 8192
|
|
|
|
|
|
class CommandNotFound(Exception):
|
|
pass
|
|
|
|
|
|
def delete_if_exists(path):
|
|
try:
|
|
os.unlink(path)
|
|
except OSError, e: # noqa
|
|
if e.errno == errno.ENOENT:
|
|
LOG.warning("'%s' was already deleted, skipping delete", path)
|
|
else:
|
|
raise
|
|
|
|
|
|
def _link(src, dst):
|
|
LOG.info("Hard-linking file '%s' -> '%s'", src, dst)
|
|
os.link(src, dst)
|
|
|
|
|
|
def _rename(src, dst):
|
|
LOG.info("Renaming file '%s' -> '%s'", src, dst)
|
|
try:
|
|
os.rename(src, dst)
|
|
except OSError, e: # noqa
|
|
if e.errno == errno.EXDEV:
|
|
LOG.error("Invalid cross-device link. Perhaps %s and %s should "
|
|
"be symlinked on the same filesystem?", src, dst)
|
|
raise
|
|
|
|
|
|
def make_subprocess(cmdline, stdout=False, stderr=False, stdin=False,
|
|
universal_newlines=False, close_fds=True, env=None):
|
|
"""Make a subprocess according to the given command-line string
|
|
"""
|
|
LOG.info("Running cmd '%s'", " ".join(cmdline))
|
|
kwargs = {}
|
|
kwargs['stdout'] = stdout and subprocess.PIPE or None
|
|
kwargs['stderr'] = stderr and subprocess.PIPE or None
|
|
kwargs['stdin'] = stdin and subprocess.PIPE or None
|
|
kwargs['universal_newlines'] = universal_newlines
|
|
kwargs['close_fds'] = close_fds
|
|
kwargs['env'] = env
|
|
try:
|
|
proc = subprocess.Popen(cmdline, **kwargs)
|
|
except OSError, e: # noqa
|
|
if e.errno == errno.ENOENT:
|
|
raise CommandNotFound
|
|
else:
|
|
raise
|
|
return proc
|
|
|
|
|
|
class SubprocessException(Exception):
|
|
def __init__(self, cmdline, ret, out, err):
|
|
Exception.__init__(self, "'%s' returned non-zero exit code: "
|
|
"retcode=%i, out='%s', stderr='%s'"
|
|
% (cmdline, ret, out, err))
|
|
self.cmdline = cmdline
|
|
self.ret = ret
|
|
self.out = out
|
|
self.err = err
|
|
|
|
|
|
def finish_subprocess(proc, cmdline, cmd_input=None, ok_exit_codes=None):
|
|
"""Ensure that the process returned a zero exit code indicating success
|
|
"""
|
|
if ok_exit_codes is None:
|
|
ok_exit_codes = [0]
|
|
out, err = proc.communicate(cmd_input)
|
|
|
|
ret = proc.returncode
|
|
if ret not in ok_exit_codes:
|
|
LOG.error("Command '%(cmdline)s' with process id '%(pid)s' expected "
|
|
"return code in '%(ok)s' but got '%(rc)s': %(err)s",
|
|
{'cmdline': cmdline, 'pid': proc.pid, 'ok': ok_exit_codes,
|
|
'rc': ret, 'err': err})
|
|
raise SubprocessException(' '.join(cmdline), ret, out, err)
|
|
return out
|
|
|
|
|
|
def run_command(cmd, cmd_input=None, ok_exit_codes=None):
|
|
"""Abstracts out the basics of issuing system commands. If the command
|
|
returns anything in stderr, an exception is raised with that information.
|
|
Otherwise, the output from stdout is returned.
|
|
|
|
cmd_input is passed to the process on standard input.
|
|
"""
|
|
proc = make_subprocess(cmd, stdout=True, stderr=True, stdin=True,
|
|
close_fds=True)
|
|
return finish_subprocess(proc, cmd, cmd_input=cmd_input,
|
|
ok_exit_codes=ok_exit_codes)
|
|
|
|
|
|
def try_kill_process(proc):
|
|
"""Sends the given process the SIGKILL signal."""
|
|
pid = proc.pid
|
|
LOG.info("Killing process %s", pid)
|
|
try:
|
|
os.kill(pid, signal.SIGKILL)
|
|
except Exception:
|
|
LOG.exception("Failed to kill %s", pid)
|
|
|
|
|
|
def make_staging_area(sr_path):
|
|
"""The staging area is a place where we can temporarily store and
|
|
manipulate VHDs. The use of the staging area is different for upload and
|
|
download:
|
|
|
|
Download
|
|
========
|
|
|
|
When we download the tarball, the VHDs contained within will have names
|
|
like "snap.vhd" and "image.vhd". We need to assign UUIDs to them before
|
|
moving them into the SR. However, since 'image.vhd' may be a base_copy, we
|
|
need to link it to 'snap.vhd' (using vhd-util modify) before moving both
|
|
into the SR (otherwise the SR.scan will cause 'image.vhd' to be deleted).
|
|
The staging area gives us a place to perform these operations before they
|
|
are moved to the SR, scanned, and then registered with XenServer.
|
|
|
|
Upload
|
|
======
|
|
|
|
On upload, we want to rename the VHDs to reflect what they are, 'snap.vhd'
|
|
in the case of the snapshot VHD, and 'image.vhd' in the case of the
|
|
base_copy. The staging area provides a directory in which we can create
|
|
hard-links to rename the VHDs without affecting what's in the SR.
|
|
|
|
|
|
NOTE
|
|
====
|
|
|
|
The staging area is created as a subdirectory within the SR in order to
|
|
guarantee that it resides within the same filesystem and therefore permit
|
|
hard-linking and cheap file moves.
|
|
"""
|
|
staging_path = tempfile.mkdtemp(dir=sr_path)
|
|
return staging_path
|
|
|
|
|
|
def cleanup_staging_area(staging_path):
|
|
"""Remove staging area directory
|
|
|
|
On upload, the staging area contains hard-links to the VHDs in the SR;
|
|
it's safe to remove the staging-area because the SR will keep the link
|
|
count > 0 (so the VHDs in the SR will not be deleted).
|
|
"""
|
|
if os.path.exists(staging_path):
|
|
shutil.rmtree(staging_path)
|
|
|
|
|
|
def _handle_old_style_images(staging_path):
|
|
"""Rename files to conform to new image format, if needed.
|
|
|
|
Old-Style:
|
|
|
|
snap.vhd -> image.vhd -> base.vhd
|
|
|
|
New-Style:
|
|
|
|
0.vhd -> 1.vhd -> ... (n-1).vhd
|
|
|
|
The New-Style format has the benefit of being able to support a VDI chain
|
|
of arbitrary length.
|
|
"""
|
|
file_num = 0
|
|
for filename in ('snap.vhd', 'image.vhd', 'base.vhd'):
|
|
path = os.path.join(staging_path, filename)
|
|
if os.path.exists(path):
|
|
_rename(path, os.path.join(staging_path, "%d.vhd" % file_num))
|
|
file_num += 1
|
|
|
|
# Rename any format of name to 0.vhd when there is only single one
|
|
contents = os.listdir(staging_path)
|
|
if len(contents) == 1:
|
|
filename = contents[0]
|
|
if filename != '0.vhd' and filename.endswith('.vhd'):
|
|
_rename(
|
|
os.path.join(staging_path, filename),
|
|
os.path.join(staging_path, '0.vhd'))
|
|
|
|
|
|
def _assert_vhd_not_hidden(path):
|
|
"""Sanity check to ensure that only appropriate VHDs are marked as hidden.
|
|
|
|
If this flag is incorrectly set, then when we move the VHD into the SR, it
|
|
will be deleted out from under us.
|
|
"""
|
|
query_cmd = ["vhd-util", "query", "-n", path, "-f"]
|
|
out = run_command(query_cmd)
|
|
|
|
for line in out.splitlines():
|
|
if line.lower().startswith('hidden'):
|
|
value = line.split(':')[1].strip()
|
|
if value == "1":
|
|
raise Exception(
|
|
"VHD %s is marked as hidden without child" % path)
|
|
|
|
|
|
def _vhd_util_check(vdi_path):
|
|
check_cmd = ["vhd-util", "check", "-n", vdi_path, "-p"]
|
|
out = run_command(check_cmd, ok_exit_codes=[0, 22])
|
|
first_line = out.splitlines()[0].strip()
|
|
return out, first_line
|
|
|
|
|
|
def _validate_vhd(vdi_path):
|
|
"""This checks for several errors in the VHD structure.
|
|
|
|
Most notably, it checks that the timestamp in the footer is correct, but
|
|
may pick up other errors also.
|
|
|
|
This check ensures that the timestamps listed in the VHD footer aren't in
|
|
the future. This can occur during a migration if the clocks on the two
|
|
Dom0's are out-of-sync. This would corrupt the SR if it were imported, so
|
|
generate an exception to bail.
|
|
"""
|
|
out, first_line = _vhd_util_check(vdi_path)
|
|
|
|
if 'invalid' in first_line:
|
|
LOG.warning("VHD invalid, attempting repair.")
|
|
repair_cmd = ["vhd-util", "repair", "-n", vdi_path]
|
|
run_command(repair_cmd)
|
|
out, first_line = _vhd_util_check(vdi_path)
|
|
|
|
if 'invalid' in first_line:
|
|
if 'footer' in first_line:
|
|
part = 'footer'
|
|
elif 'header' in first_line:
|
|
part = 'header'
|
|
else:
|
|
part = 'setting'
|
|
|
|
details = first_line.split(':', 1)
|
|
if len(details) == 2:
|
|
details = details[1]
|
|
else:
|
|
details = first_line
|
|
|
|
extra = ''
|
|
if 'timestamp' in first_line:
|
|
extra = (" ensure source and destination host machines have "
|
|
"time set correctly")
|
|
|
|
LOG.info("VDI Error details: %s", out)
|
|
|
|
raise Exception(
|
|
"VDI '%(vdi_path)s' has an invalid %(part)s: '%(details)s'"
|
|
"%(extra)s" % {'vdi_path': vdi_path, 'part': part,
|
|
'details': details, 'extra': extra})
|
|
|
|
LOG.info("VDI is valid: %s", vdi_path)
|
|
|
|
|
|
def _validate_vdi_chain(vdi_path):
|
|
"""This check ensures that the parent pointers on the VHDs are valid
|
|
before we move the VDI chain to the SR. This is *very* important
|
|
because a bad parent pointer will corrupt the SR causing a cascade of
|
|
failures.
|
|
"""
|
|
def get_parent_path(path):
|
|
query_cmd = ["vhd-util", "query", "-n", path, "-p"]
|
|
out = run_command(query_cmd, ok_exit_codes=[0, 22])
|
|
first_line = out.splitlines()[0].strip()
|
|
|
|
if first_line.endswith(".vhd"):
|
|
return first_line
|
|
elif 'has no parent' in first_line:
|
|
return None
|
|
elif 'query failed' in first_line:
|
|
raise Exception("VDI '%s' not present which breaks"
|
|
" the VDI chain, bailing out" % path)
|
|
else:
|
|
raise Exception("Unexpected output '%s' from vhd-util" % out)
|
|
|
|
cur_path = vdi_path
|
|
while cur_path:
|
|
_validate_vhd(cur_path)
|
|
cur_path = get_parent_path(cur_path)
|
|
|
|
|
|
def _validate_sequenced_vhds(staging_path):
|
|
"""This check ensures that the VHDs in the staging area are sequenced
|
|
properly from 0 to n-1 with no gaps.
|
|
"""
|
|
seq_num = 0
|
|
filenames = os.listdir(staging_path)
|
|
for filename in filenames:
|
|
if not filename.endswith('.vhd'):
|
|
continue
|
|
|
|
# Ignore legacy swap embedded in the image, generated on-the-fly now
|
|
if filename == "swap.vhd":
|
|
continue
|
|
|
|
vhd_path = os.path.join(staging_path, "%d.vhd" % seq_num)
|
|
if not os.path.exists(vhd_path):
|
|
raise Exception("Corrupt image. Expected seq number: %d. Files: %s"
|
|
% (seq_num, filenames))
|
|
|
|
seq_num += 1
|
|
|
|
|
|
def import_vhds(sr_path, staging_path, uuid_stack):
|
|
"""Move VHDs from staging area into the SR.
|
|
|
|
The staging area is necessary because we need to perform some fixups
|
|
(assigning UUIDs, relinking the VHD chain) before moving into the SR,
|
|
otherwise the SR manager process could potentially delete the VHDs out from
|
|
under us.
|
|
|
|
Returns: A dict of imported VHDs:
|
|
|
|
{'root': {'uuid': 'ffff-aaaa'}}
|
|
"""
|
|
_handle_old_style_images(staging_path)
|
|
_validate_sequenced_vhds(staging_path)
|
|
|
|
files_to_move = []
|
|
|
|
# Collect sequenced VHDs and assign UUIDs to them
|
|
seq_num = 0
|
|
while True:
|
|
orig_vhd_path = os.path.join(staging_path, "%d.vhd" % seq_num)
|
|
if not os.path.exists(orig_vhd_path):
|
|
break
|
|
|
|
# Rename (0, 1 .. N).vhd -> aaaa-bbbb-cccc-dddd.vhd
|
|
vhd_uuid = uuid_stack.pop()
|
|
vhd_path = os.path.join(staging_path, "%s.vhd" % vhd_uuid)
|
|
_rename(orig_vhd_path, vhd_path)
|
|
|
|
if seq_num == 0:
|
|
leaf_vhd_path = vhd_path
|
|
leaf_vhd_uuid = vhd_uuid
|
|
|
|
files_to_move.append(vhd_path)
|
|
seq_num += 1
|
|
|
|
# Re-link VHDs, in reverse order, from base-copy -> leaf
|
|
parent_path = None
|
|
for vhd_path in reversed(files_to_move):
|
|
if parent_path:
|
|
# Link to parent
|
|
modify_cmd = ["vhd-util", "modify", "-n", vhd_path,
|
|
"-p", parent_path]
|
|
run_command(modify_cmd)
|
|
|
|
parent_path = vhd_path
|
|
|
|
# Sanity check the leaf VHD
|
|
_assert_vhd_not_hidden(leaf_vhd_path)
|
|
_validate_vdi_chain(leaf_vhd_path)
|
|
|
|
# Move files into SR
|
|
for orig_path in files_to_move:
|
|
new_path = os.path.join(sr_path, os.path.basename(orig_path))
|
|
_rename(orig_path, new_path)
|
|
|
|
imported_vhds = dict(root=dict(uuid=leaf_vhd_uuid))
|
|
return imported_vhds
|
|
|
|
|
|
def prepare_staging_area(sr_path, staging_path, vdi_uuids, seq_num=0):
|
|
"""Hard-link VHDs into staging area."""
|
|
for vdi_uuid in vdi_uuids:
|
|
source = os.path.join(sr_path, "%s.vhd" % vdi_uuid)
|
|
link_name = os.path.join(staging_path, "%d.vhd" % seq_num)
|
|
_link(source, link_name)
|
|
seq_num += 1
|
|
|
|
|
|
def create_tarball(fileobj, path, callback=None, compression_level=None):
|
|
"""Create a tarball from a given path.
|
|
|
|
:param fileobj: a file-like object holding the tarball byte-stream.
|
|
If None, then only the callback will be used.
|
|
:param path: path to create tarball from
|
|
:param callback: optional callback to call on each chunk written
|
|
:param compression_level: compression level, e.g., 9 for gzip -9.
|
|
"""
|
|
tar_cmd = ["tar", "-zc", "--directory=%s" % path, "."]
|
|
env = os.environ.copy()
|
|
if compression_level and 1 <= compression_level <= 9:
|
|
env["GZIP"] = "-%d" % compression_level
|
|
tar_proc = make_subprocess(tar_cmd, stdout=True, stderr=True, env=env)
|
|
|
|
try:
|
|
while True:
|
|
chunk = tar_proc.stdout.read(CHUNK_SIZE)
|
|
if chunk == '':
|
|
break
|
|
|
|
if callback:
|
|
callback(chunk)
|
|
|
|
if fileobj:
|
|
fileobj.write(chunk)
|
|
except Exception:
|
|
try_kill_process(tar_proc)
|
|
raise
|
|
|
|
finish_subprocess(tar_proc, tar_cmd)
|
|
|
|
|
|
def extract_tarball(fileobj, path, callback=None):
|
|
"""Extract a tarball to a given path.
|
|
|
|
:param fileobj: a file-like object holding the tarball byte-stream
|
|
:param path: path to extract tarball into
|
|
:param callback: optional callback to call on each chunk read
|
|
"""
|
|
tar_cmd = ["tar", "-zx", "--directory=%s" % path]
|
|
tar_proc = make_subprocess(tar_cmd, stderr=True, stdin=True)
|
|
|
|
try:
|
|
while True:
|
|
chunk = fileobj.read(CHUNK_SIZE)
|
|
if chunk == '':
|
|
break
|
|
|
|
if callback:
|
|
callback(chunk)
|
|
|
|
tar_proc.stdin.write(chunk)
|
|
|
|
# NOTE(tpownall): If we do not poll for the tar process exit
|
|
# code when tar has exited pre maturely there is the chance
|
|
# that tar will become a defunct zombie child under glance plugin
|
|
# and re parented under init forever waiting on the stdin pipe to
|
|
# close. Polling for the exit code allows us to break the pipe.
|
|
returncode = tar_proc.poll()
|
|
tar_pid = tar_proc.pid
|
|
if returncode is not None:
|
|
LOG.error("tar extract with process id '%(pid)s' "
|
|
"exited early with '%(rc)s'",
|
|
{'pid': tar_pid, 'rc': returncode})
|
|
raise SubprocessException(
|
|
' '.join(tar_cmd), returncode, "", "")
|
|
|
|
except SubprocessException:
|
|
# no need to kill already dead process
|
|
raise
|
|
except Exception:
|
|
LOG.exception("Failed while sending data to tar pid: %s", tar_pid)
|
|
try_kill_process(tar_proc)
|
|
raise
|
|
|
|
finish_subprocess(tar_proc, tar_cmd)
|
|
|
|
|
|
def make_dev_path(dev, partition=None, base='/dev'):
|
|
"""Return a path to a particular device.
|
|
|
|
>>> make_dev_path('xvdc')
|
|
/dev/xvdc
|
|
|
|
>>> make_dev_path('xvdc', 1)
|
|
/dev/xvdc1
|
|
"""
|
|
path = os.path.join(base, dev)
|
|
if partition:
|
|
path += str(partition)
|
|
return path
|
|
|
|
|
|
def _handle_serialization(func):
|
|
def wrapped(session, params):
|
|
params = pickle.loads(params['params'])
|
|
rv = func(session, *params['args'], **params['kwargs'])
|
|
return pickle.dumps(rv)
|
|
return wrapped
|
|
|
|
|
|
def register_plugin_calls(*funcs):
|
|
"""Wrapper around XenAPIPlugin.dispatch which handles pickle
|
|
serialization.
|
|
"""
|
|
wrapped_dict = {}
|
|
for func in funcs:
|
|
wrapped_dict[func.__name__] = _handle_serialization(func)
|
|
XenAPIPlugin.dispatch(wrapped_dict)
|