7ad72b0922
Add a new filesytem mounting helper in privsep, and then start moving things across to it. This currently implements mount and unmount. We get to cleanup some rmdir calls while we're at it which is nice as well. I've added an upgrade note mentioning that we no longer ignore the value of stderr from mount calls, as requesed in code review. Change-Id: Ib5e585fa4bfb99617cd3ca983674114d323a3cce blueprint: hurrah-for-privsep
331 lines
13 KiB
Python
331 lines
13 KiB
Python
# Copyright 2014 Cloudbase Solutions Srl
|
|
# All Rights Reserved.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
# not use this file except in compliance with the License. You may obtain
|
|
# a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
# License for the specific language governing permissions and limitations
|
|
# under the License.
|
|
|
|
import abc
|
|
import functools
|
|
import os
|
|
import tempfile
|
|
|
|
from oslo_concurrency import processutils
|
|
from oslo_log import log as logging
|
|
from oslo_utils import fileutils
|
|
from oslo_utils import importutils
|
|
import six
|
|
|
|
import nova.conf
|
|
from nova.i18n import _
|
|
import nova.privsep.fs
|
|
from nova import utils
|
|
|
|
LOG = logging.getLogger(__name__)
|
|
|
|
CONF = nova.conf.CONF
|
|
|
|
|
|
def mount_share(mount_path, export_path,
|
|
export_type, options=None):
|
|
"""Mount a remote export to mount_path.
|
|
|
|
:param mount_path: place where the remote export will be mounted
|
|
:param export_path: path of the export to be mounted
|
|
:export_type: remote export type (e.g. cifs, nfs, etc.)
|
|
:options: A list containing mount options
|
|
"""
|
|
fileutils.ensure_tree(mount_path)
|
|
|
|
try:
|
|
nova.privsep.fs.mount(export_type, export_path, mount_path, options)
|
|
except processutils.ProcessExecutionError as exc:
|
|
if 'Device or resource busy' in six.text_type(exc):
|
|
LOG.warning("%s is already mounted", export_path)
|
|
else:
|
|
raise
|
|
|
|
|
|
def unmount_share(mount_path, export_path):
|
|
"""Unmount a remote share.
|
|
|
|
:param mount_path: remote export mount point
|
|
:param export_path: path of the remote export to be unmounted
|
|
"""
|
|
try:
|
|
nova.privsep.fs.umount(mount_path)
|
|
except processutils.ProcessExecutionError as exc:
|
|
if 'target is busy' in six.text_type(exc):
|
|
LOG.debug("The share %s is still in use.", export_path)
|
|
else:
|
|
LOG.exception(_("Couldn't unmount the share %s"), export_path)
|
|
|
|
|
|
class RemoteFilesystem(object):
|
|
"""Represents actions that can be taken on a remote host's filesystem."""
|
|
|
|
def __init__(self):
|
|
transport = CONF.libvirt.remote_filesystem_transport
|
|
cls_name = '.'.join([__name__, transport.capitalize()])
|
|
cls_name += 'Driver'
|
|
self.driver = importutils.import_object(cls_name)
|
|
|
|
def create_file(self, host, dst_path, on_execute=None,
|
|
on_completion=None):
|
|
LOG.debug("Creating file %s on remote host %s", dst_path, host)
|
|
self.driver.create_file(host, dst_path, on_execute=on_execute,
|
|
on_completion=on_completion)
|
|
|
|
def remove_file(self, host, dst_path, on_execute=None,
|
|
on_completion=None):
|
|
LOG.debug("Removing file %s on remote host %s", dst_path, host)
|
|
self.driver.remove_file(host, dst_path, on_execute=on_execute,
|
|
on_completion=on_completion)
|
|
|
|
def create_dir(self, host, dst_path, on_execute=None,
|
|
on_completion=None):
|
|
LOG.debug("Creating directory %s on remote host %s", dst_path, host)
|
|
self.driver.create_dir(host, dst_path, on_execute=on_execute,
|
|
on_completion=on_completion)
|
|
|
|
def remove_dir(self, host, dst_path, on_execute=None,
|
|
on_completion=None):
|
|
LOG.debug("Removing directory %s on remote host %s", dst_path, host)
|
|
self.driver.remove_dir(host, dst_path, on_execute=on_execute,
|
|
on_completion=on_completion)
|
|
|
|
def copy_file(self, src, dst, on_execute=None,
|
|
on_completion=None, compression=True):
|
|
LOG.debug("Copying file %s to %s", src, dst)
|
|
self.driver.copy_file(src, dst, on_execute=on_execute,
|
|
on_completion=on_completion,
|
|
compression=compression)
|
|
|
|
|
|
@six.add_metaclass(abc.ABCMeta)
|
|
class RemoteFilesystemDriver(object):
|
|
@abc.abstractmethod
|
|
def create_file(self, host, dst_path, on_execute, on_completion):
|
|
"""Create file on the remote system.
|
|
|
|
:param host: Remote host
|
|
:param dst_path: Destination path
|
|
:param on_execute: Callback method to store pid of process in cache
|
|
:param on_completion: Callback method to remove pid of process from
|
|
cache
|
|
"""
|
|
|
|
@abc.abstractmethod
|
|
def remove_file(self, host, dst_path, on_execute, on_completion):
|
|
"""Removes a file on a remote host.
|
|
|
|
:param host: Remote host
|
|
:param dst_path: Destination path
|
|
:param on_execute: Callback method to store pid of process in cache
|
|
:param on_completion: Callback method to remove pid of process from
|
|
cache
|
|
"""
|
|
|
|
@abc.abstractmethod
|
|
def create_dir(self, host, dst_path, on_execute, on_completion):
|
|
"""Create directory on the remote system.
|
|
|
|
:param host: Remote host
|
|
:param dst_path: Destination path
|
|
:param on_execute: Callback method to store pid of process in cache
|
|
:param on_completion: Callback method to remove pid of process from
|
|
cache
|
|
"""
|
|
|
|
@abc.abstractmethod
|
|
def remove_dir(self, host, dst_path, on_execute, on_completion):
|
|
"""Removes a directory on a remote host.
|
|
|
|
:param host: Remote host
|
|
:param dst_path: Destination path
|
|
:param on_execute: Callback method to store pid of process in cache
|
|
:param on_completion: Callback method to remove pid of process from
|
|
cache
|
|
"""
|
|
|
|
@abc.abstractmethod
|
|
def copy_file(self, src, dst, on_execute, on_completion):
|
|
"""Copy file to/from remote host.
|
|
|
|
Remote address must be specified in format:
|
|
REM_HOST_IP_ADDRESS:REM_HOST_PATH
|
|
For example:
|
|
192.168.1.10:/home/file
|
|
|
|
:param src: Source address
|
|
:param dst: Destination path
|
|
:param on_execute: Callback method to store pid of process in cache
|
|
:param on_completion: Callback method to remove pid of process from
|
|
"""
|
|
|
|
|
|
class SshDriver(RemoteFilesystemDriver):
|
|
|
|
def create_file(self, host, dst_path, on_execute, on_completion):
|
|
utils.ssh_execute(host, 'touch', dst_path,
|
|
on_execute=on_execute, on_completion=on_completion)
|
|
|
|
def remove_file(self, host, dst, on_execute, on_completion):
|
|
utils.ssh_execute(host, 'rm', dst,
|
|
on_execute=on_execute, on_completion=on_completion)
|
|
|
|
def create_dir(self, host, dst_path, on_execute, on_completion):
|
|
utils.ssh_execute(host, 'mkdir', '-p', dst_path,
|
|
on_execute=on_execute, on_completion=on_completion)
|
|
|
|
def remove_dir(self, host, dst, on_execute, on_completion):
|
|
utils.ssh_execute(host, 'rm', '-rf', dst,
|
|
on_execute=on_execute, on_completion=on_completion)
|
|
|
|
def copy_file(self, src, dst, on_execute, on_completion, compression):
|
|
# As far as ploop disks are in fact directories we add '-r' argument
|
|
utils.execute('scp', '-r', src, dst,
|
|
on_execute=on_execute, on_completion=on_completion)
|
|
|
|
|
|
def create_tmp_dir(function):
|
|
"""Creates temporary directory for rsync purposes.
|
|
Removes created directory in the end.
|
|
"""
|
|
|
|
@functools.wraps(function)
|
|
def decorated_function(*args, **kwargs):
|
|
# Create directory
|
|
tmp_dir_path = tempfile.mkdtemp()
|
|
kwargs['tmp_dir_path'] = tmp_dir_path
|
|
|
|
try:
|
|
return function(*args, **kwargs)
|
|
finally:
|
|
# Remove directory
|
|
utils.execute('rm', '-rf', tmp_dir_path)
|
|
|
|
return decorated_function
|
|
|
|
|
|
class RsyncDriver(RemoteFilesystemDriver):
|
|
|
|
@create_tmp_dir
|
|
def create_file(self, host, dst_path, on_execute, on_completion, **kwargs):
|
|
dir_path = os.path.dirname(os.path.normpath(dst_path))
|
|
|
|
# Create target dir inside temporary directory
|
|
local_tmp_dir = os.path.join(kwargs['tmp_dir_path'],
|
|
dir_path.strip(os.path.sep))
|
|
utils.execute('mkdir', '-p', local_tmp_dir,
|
|
on_execute=on_execute, on_completion=on_completion)
|
|
|
|
# Create file in directory
|
|
file_name = os.path.basename(os.path.normpath(dst_path))
|
|
local_tmp_file = os.path.join(local_tmp_dir, file_name)
|
|
utils.execute('touch', local_tmp_file,
|
|
on_execute=on_execute, on_completion=on_completion)
|
|
RsyncDriver._synchronize_object(kwargs['tmp_dir_path'],
|
|
host, dst_path,
|
|
on_execute=on_execute,
|
|
on_completion=on_completion)
|
|
|
|
@create_tmp_dir
|
|
def remove_file(self, host, dst, on_execute, on_completion, **kwargs):
|
|
# Delete file
|
|
RsyncDriver._remove_object(kwargs['tmp_dir_path'], host, dst,
|
|
on_execute=on_execute,
|
|
on_completion=on_completion)
|
|
|
|
@create_tmp_dir
|
|
def create_dir(self, host, dst_path, on_execute, on_completion, **kwargs):
|
|
dir_path = os.path.normpath(dst_path)
|
|
|
|
# Create target dir inside temporary directory
|
|
local_tmp_dir = os.path.join(kwargs['tmp_dir_path'],
|
|
dir_path.strip(os.path.sep))
|
|
utils.execute('mkdir', '-p', local_tmp_dir,
|
|
on_execute=on_execute, on_completion=on_completion)
|
|
RsyncDriver._synchronize_object(kwargs['tmp_dir_path'],
|
|
host, dst_path,
|
|
on_execute=on_execute,
|
|
on_completion=on_completion)
|
|
|
|
@create_tmp_dir
|
|
def remove_dir(self, host, dst, on_execute, on_completion, **kwargs):
|
|
# Remove remote directory's content
|
|
utils.execute('rsync', '--archive', '--delete-excluded',
|
|
kwargs['tmp_dir_path'] + os.path.sep,
|
|
utils.format_remote_path(host, dst),
|
|
on_execute=on_execute, on_completion=on_completion)
|
|
|
|
# Delete empty directory
|
|
RsyncDriver._remove_object(kwargs['tmp_dir_path'], host, dst,
|
|
on_execute=on_execute,
|
|
on_completion=on_completion)
|
|
|
|
@staticmethod
|
|
def _remove_object(src, host, dst, on_execute, on_completion):
|
|
"""Removes a file or empty directory on a remote host.
|
|
|
|
:param src: Empty directory used for rsync purposes
|
|
:param host: Remote host
|
|
:param dst: Destination path
|
|
:param on_execute: Callback method to store pid of process in cache
|
|
:param on_completion: Callback method to remove pid of process from
|
|
cache
|
|
"""
|
|
utils.execute('rsync', '--archive', '--delete',
|
|
'--include', os.path.basename(os.path.normpath(dst)),
|
|
'--exclude', '*',
|
|
os.path.normpath(src) + os.path.sep,
|
|
utils.format_remote_path(host,
|
|
os.path.dirname(os.path.normpath(dst))),
|
|
on_execute=on_execute, on_completion=on_completion)
|
|
|
|
@staticmethod
|
|
def _synchronize_object(src, host, dst, on_execute, on_completion):
|
|
"""Creates a file or empty directory on a remote host.
|
|
|
|
:param src: Empty directory used for rsync purposes
|
|
:param host: Remote host
|
|
:param dst: Destination path
|
|
:param on_execute: Callback method to store pid of process in cache
|
|
:param on_completion: Callback method to remove pid of process from
|
|
cache
|
|
"""
|
|
|
|
# For creating path on the remote host rsync --relative path must
|
|
# be used. With a modern rsync on the sending side (beginning with
|
|
# 2.6.7), you can insert a dot and a slash into the source path,
|
|
# like this:
|
|
# rsync -avR /foo/./bar/baz.c remote:/tmp/
|
|
# That would create /tmp/bar/baz.c on the remote machine.
|
|
# (Note that the dot must be followed by a slash, so "/foo/."
|
|
# would not be abbreviated.)
|
|
relative_tmp_file_path = os.path.join(
|
|
src, './',
|
|
os.path.normpath(dst).strip(os.path.sep))
|
|
|
|
# Do relative rsync local directory with remote root directory
|
|
utils.execute('rsync', '--archive', '--relative', '--no-implied-dirs',
|
|
relative_tmp_file_path,
|
|
utils.format_remote_path(host, os.path.sep),
|
|
on_execute=on_execute, on_completion=on_completion)
|
|
|
|
def copy_file(self, src, dst, on_execute, on_completion, compression):
|
|
# As far as ploop disks are in fact directories we add '-r' argument
|
|
args = ['rsync', '-r', '--sparse', src, dst]
|
|
if compression:
|
|
args.append('--compress')
|
|
utils.execute(*args,
|
|
on_execute=on_execute, on_completion=on_completion)
|