| # |
| # |
| |
| # Copyright (C) 2014 Google Inc. |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions are |
| # met: |
| # |
| # 1. Redistributions of source code must retain the above copyright notice, |
| # this list of conditions and the following disclaimer. |
| # |
| # 2. Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS |
| # IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED |
| # TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
| # PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
| # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, |
| # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
| # PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR |
| # PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF |
| # LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING |
| # NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
| # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| |
| """ExtStorage Interface related functionality |
| |
| """ |
| |
| import re |
| import stat |
| import os |
| import logging |
| |
| from ganeti import utils |
| from ganeti import errors |
| from ganeti import constants |
| from ganeti import objects |
| from ganeti import pathutils |
| from ganeti.storage import base |
| |
| |
| class ExtStorageDevice(base.BlockDev): |
| """A block device provided by an ExtStorage Provider. |
| |
| This class implements the External Storage Interface, which means |
| handling of the externally provided block devices. |
| |
| """ |
| def __init__(self, unique_id, children, size, params, dyn_params, **kwargs): |
| """Attaches to an extstorage block device. |
| |
| """ |
| super(ExtStorageDevice, self).__init__(unique_id, children, size, params, |
| dyn_params, **kwargs) |
| self.name = kwargs["name"] |
| self.uuid = kwargs["uuid"] |
| |
| if not isinstance(unique_id, (tuple, list)) or len(unique_id) != 2: |
| raise ValueError("Invalid configuration data %s" % str(unique_id)) |
| |
| self.driver, self.vol_name = unique_id |
| self.ext_params = params |
| |
| self.major = self.minor = None |
| self.uris = [] |
| self.Attach() |
| |
| @classmethod |
| def Create(cls, unique_id, children, size, spindles, params, excl_stor, |
| dyn_params, **kwargs): |
| """Create a new extstorage device. |
| |
| Provision a new volume using an extstorage provider, which will |
| then be mapped to a block device. |
| |
| """ |
| |
| if not isinstance(unique_id, (tuple, list)) or len(unique_id) != 2: |
| raise errors.ProgrammerError("Invalid configuration data %s" % |
| str(unique_id)) |
| if excl_stor: |
| raise errors.ProgrammerError("extstorage device requested with" |
| " exclusive_storage") |
| |
| # Call the External Storage's create script, |
| # to provision a new Volume inside the External Storage |
| _ExtStorageAction(constants.ES_ACTION_CREATE, unique_id, |
| params, size=size, name=kwargs["name"], |
| uuid=kwargs["uuid"]) |
| |
| return ExtStorageDevice(unique_id, children, size, params, dyn_params, |
| **kwargs) |
| |
| def Remove(self): |
| """Remove the extstorage device. |
| |
| """ |
| if not self.minor and not self.Attach(): |
| # The extstorage device doesn't exist. |
| return |
| |
| # First shutdown the device (remove mappings). |
| self.Shutdown() |
| |
| # Call the External Storage's remove script, |
| # to remove the Volume from the External Storage |
| _ExtStorageAction(constants.ES_ACTION_REMOVE, self.unique_id, |
| self.ext_params, name=self.name, uuid=self.uuid) |
| |
| def Rename(self, new_id): |
| """Rename this device. |
| |
| """ |
| pass |
| |
| def Attach(self, **kwargs): |
| """Attach to an existing extstorage device. |
| |
| This method maps the extstorage volume that matches our name with |
| a corresponding block device and then attaches to this device. |
| |
| """ |
| self.attached = False |
| |
| # Call the External Storage's attach script, |
| # to attach an existing Volume to a block device under /dev |
| result = _ExtStorageAction(constants.ES_ACTION_ATTACH, |
| self.unique_id, self.ext_params, |
| name=self.name, uuid=self.uuid) |
| |
| # Attach script returns the block device path and optionally |
| # the URIs to be used for userspace access (one URI for |
| # each hypervisor supported). |
| # If the provider doesn't support userspace access, then |
| # the 'uris' variable will be an empty list. |
| result = result.split("\n") |
| self.dev_path = result[0] |
| self.uris = result[1:] |
| |
| if not self.dev_path: |
| logging.info("A local block device is not available") |
| self.dev_path = None |
| if not self.uris: |
| logging.error("Neither a block device nor a userspace URI is available") |
| return False |
| |
| self.attached = True |
| return True |
| |
| # Verify that dev_path exists and is a block device |
| try: |
| st = os.stat(self.dev_path) |
| except OSError, err: |
| logging.error("Error stat()'ing %s: %s", self.dev_path, str(err)) |
| return False |
| |
| if not stat.S_ISBLK(st.st_mode): |
| logging.error("%s is not a block device", self.dev_path) |
| return False |
| |
| self.major = os.major(st.st_rdev) |
| self.minor = utils.osminor(st.st_rdev) |
| self.attached = True |
| |
| return True |
| |
| def Assemble(self): |
| """Assemble the device. |
| |
| """ |
| pass |
| |
| def Shutdown(self): |
| """Shutdown the device. |
| |
| """ |
| if not self.minor and not self.Attach(): |
| # The extstorage device doesn't exist. |
| return |
| |
| # Call the External Storage's detach script, |
| # to detach an existing Volume from it's block device under /dev |
| _ExtStorageAction(constants.ES_ACTION_DETACH, self.unique_id, |
| self.ext_params, name=self.name, uuid=self.uuid) |
| |
| self.minor = None |
| self.dev_path = None |
| |
| def Open(self, force=False, exclusive=True): |
| """Make the device ready for I/O. |
| |
| """ |
| _ExtStorageAction(constants.ES_ACTION_OPEN, self.unique_id, |
| self.ext_params, |
| name=self.name, uuid=self.uuid, |
| exclusive=exclusive) |
| |
| def Close(self): |
| """Notifies that the device will no longer be used for I/O. |
| |
| """ |
| _ExtStorageAction(constants.ES_ACTION_CLOSE, self.unique_id, |
| self.ext_params, |
| name=self.name, uuid=self.uuid) |
| |
| def Grow(self, amount, dryrun, backingstore, excl_stor): |
| """Grow the Volume. |
| |
| @type amount: integer |
| @param amount: the amount (in mebibytes) to grow with |
| @type dryrun: boolean |
| @param dryrun: whether to execute the operation in simulation mode |
| only, without actually increasing the size |
| |
| """ |
| if not backingstore: |
| return |
| if not self.Attach(): |
| base.ThrowError("Can't attach to extstorage device during Grow()") |
| |
| if dryrun: |
| # we do not support dry runs of resize operations for now. |
| return |
| |
| new_size = self.size + amount |
| |
| # Call the External Storage's grow script, |
| # to grow an existing Volume inside the External Storage |
| _ExtStorageAction(constants.ES_ACTION_GROW, self.unique_id, |
| self.ext_params, size=self.size, grow=new_size, |
| name=self.name, uuid=self.uuid) |
| |
| def SetInfo(self, text): |
| """Update metadata with info text. |
| |
| """ |
| # Replace invalid characters |
| text = re.sub("^[^A-Za-z0-9_+.]", "_", text) |
| text = re.sub("[^-A-Za-z0-9_+.]", "_", text) |
| |
| # Only up to 128 characters are allowed |
| text = text[:128] |
| |
| # Call the External Storage's setinfo script, |
| # to set metadata for an existing Volume inside the External Storage |
| _ExtStorageAction(constants.ES_ACTION_SETINFO, self.unique_id, |
| self.ext_params, metadata=text, |
| name=self.name, uuid=self.uuid) |
| |
| def GetUserspaceAccessUri(self, hypervisor): |
| """Generate KVM userspace URIs to be used as `-drive file` settings. |
| |
| @see: L{base.BlockDev.GetUserspaceAccessUri} |
| |
| """ |
| if not self.Attach(): |
| base.ThrowError("Can't attach to ExtStorage device") |
| |
| # If the provider supports userspace access, the attach script has |
| # returned a list of URIs prefixed with the corresponding hypervisor. |
| prefix = hypervisor.lower() + ":" |
| for uri in self.uris: |
| if uri[:len(prefix)].lower() == prefix: |
| return uri[len(prefix):] |
| |
| base.ThrowError("Userspace access is not supported by the '%s'" |
| " ExtStorage provider for the '%s' hypervisor" |
| % (self.driver, hypervisor)) |
| |
| def Snapshot(self, snap_name=None, snap_size=None): |
| """Take a snapshot of the block device. |
| |
| """ |
| provider, vol_name = self.unique_id |
| if not snap_name: |
| snap_name = vol_name + ".snap" |
| if not snap_size: |
| snap_size = self.size |
| |
| _ExtStorageAction(constants.ES_ACTION_SNAPSHOT, self.unique_id, |
| self.ext_params, snap_name=snap_name, snap_size=snap_size) |
| |
| return (provider, snap_name) |
| |
| |
| def _ExtStorageAction(action, unique_id, ext_params, |
| size=None, grow=None, metadata=None, |
| name=None, uuid=None, |
| snap_name=None, snap_size=None, |
| exclusive=None): |
| """Take an External Storage action. |
| |
| Take an External Storage action concerning or affecting |
| a specific Volume inside the External Storage. |
| |
| @type action: string |
| @param action: which action to perform. One of: |
| create / remove / grow / attach / detach / snapshot |
| @type unique_id: tuple (driver, vol_name) |
| @param unique_id: a tuple containing the type of ExtStorage (driver) |
| and the Volume name |
| @type ext_params: dict |
| @param ext_params: ExtStorage parameters |
| @type size: integer |
| @param size: the size of the Volume in mebibytes |
| @type grow: integer |
| @param grow: the new size in mebibytes (after grow) |
| @type metadata: string |
| @param metadata: metadata info of the Volume, for use by the provider |
| @type name: string |
| @param name: name of the Volume (objects.Disk.name) |
| @type uuid: string |
| @type snap_size: integer |
| @param snap_size: the size of the snapshot |
| @type snap_name: string |
| @param snap_name: the name of the snapshot |
| @type exclusive: boolean |
| @param exclusive: Whether the Volume will be opened exclusively or not |
| @param uuid: uuid of the Volume (objects.Disk.uuid) |
| @rtype: None or a block device path (during attach) |
| |
| """ |
| driver, vol_name = unique_id |
| |
| # Create an External Storage instance of type `driver' |
| status, inst_es = ExtStorageFromDisk(driver) |
| if not status: |
| base.ThrowError("%s" % inst_es) |
| |
| # Create the basic environment for the driver's scripts |
| create_env = _ExtStorageEnvironment(unique_id, ext_params, size, |
| grow, metadata, name, uuid, |
| snap_name, snap_size, |
| exclusive) |
| |
| # Do not use log file for action `attach' as we need |
| # to get the output from RunResult |
| # TODO: find a way to have a log file for attach too |
| logfile = None |
| if action is not constants.ES_ACTION_ATTACH: |
| logfile = _VolumeLogName(action, driver, vol_name) |
| |
| # Make sure the given action results in a valid script |
| if action not in constants.ES_SCRIPTS: |
| base.ThrowError("Action '%s' doesn't result in a valid ExtStorage script" % |
| action) |
| |
| # Find out which external script to run according the given action |
| script_name = action + "_script" |
| script = getattr(inst_es, script_name) |
| |
| # Here script is either a valid file path or None if the script is optional |
| if not script: |
| logging.info("Optional action '%s' is not supported by provider '%s'," |
| " skipping", action, driver) |
| return |
| |
| # Run the external script |
| # pylint: disable=E1103 |
| result = utils.RunCmd([script], env=create_env, |
| cwd=inst_es.path, output=logfile,) |
| if result.failed: |
| logging.error("External storage's %s command '%s' returned" |
| " error: %s, logfile: %s, output: %s", |
| action, result.cmd, result.fail_reason, |
| logfile, result.output) |
| |
| # If logfile is 'None' (during attach), it breaks TailFile |
| # TODO: have a log file for attach too |
| if action is not constants.ES_ACTION_ATTACH: |
| lines = [utils.SafeEncode(val) |
| for val in utils.TailFile(logfile, lines=20)] |
| else: |
| lines = result.output.splitlines()[-20:] |
| |
| base.ThrowError("External storage's %s script failed (%s), last" |
| " lines of output:\n%s", |
| action, result.fail_reason, "\n".join(lines)) |
| |
| if action == constants.ES_ACTION_ATTACH: |
| return result.stdout |
| |
| |
| def _CheckExtStorageFile(base_dir, filename, required): |
| """Check prereqs for an ExtStorage file. |
| |
| Check if file exists, if it is a regular file and in case it is |
| one of extstorage scripts if it is executable. |
| |
| @type base_dir: string |
| @param base_dir: Base directory containing ExtStorage installations. |
| @type filename: string |
| @param filename: The basename of the ExtStorage file. |
| @type required: bool |
| @param required: Whether the file is required or not. |
| |
| @rtype: String |
| @return: The file path if the file is found and is valid, |
| None if the file is not found and not required. |
| |
| @raises BlockDeviceError: In case prereqs are not met |
| (found and not valid/executable, not found and required) |
| |
| """ |
| |
| file_path = utils.PathJoin(base_dir, filename) |
| try: |
| st = os.stat(file_path) |
| except EnvironmentError, err: |
| if not required: |
| logging.info("Optional file '%s' under path '%s' is missing", |
| filename, base_dir) |
| return None |
| |
| base.ThrowError("File '%s' under path '%s' is missing (%s)" % |
| (filename, base_dir, utils.ErrnoOrStr(err))) |
| |
| if not stat.S_ISREG(stat.S_IFMT(st.st_mode)): |
| base.ThrowError("File '%s' under path '%s' is not a regular file" % |
| (filename, base_dir)) |
| |
| if filename in constants.ES_SCRIPTS: |
| if stat.S_IMODE(st.st_mode) & stat.S_IXUSR != stat.S_IXUSR: |
| base.ThrowError("File '%s' under path '%s' is not executable" % |
| (filename, base_dir)) |
| |
| return file_path |
| |
| |
| def ExtStorageFromDisk(name, base_dir=None): |
| """Create an ExtStorage instance from disk. |
| |
| This function will return an ExtStorage instance |
| if the given name is a valid ExtStorage name. |
| |
| @type base_dir: string |
| @keyword base_dir: Base directory containing ExtStorage installations. |
| Defaults to a search in all the ES_SEARCH_PATH dirs. |
| @rtype: tuple |
| @return: True and the ExtStorage instance if we find a valid one, or |
| False and the diagnose message on error |
| |
| """ |
| if base_dir is None: |
| es_base_dir = pathutils.ES_SEARCH_PATH |
| else: |
| es_base_dir = [base_dir] |
| |
| es_dir = utils.FindFile(name, es_base_dir, os.path.isdir) |
| |
| if es_dir is None: |
| return False, ("Directory for External Storage Provider %s not" |
| " found in search path" % name) |
| |
| # ES Files dictionary: this will be populated later with the absolute path |
| # names for each script; currently we denote for each script if it is |
| # required (True) or optional (False) |
| es_files = dict.fromkeys(constants.ES_SCRIPTS, True) |
| |
| # Let the snapshot, open, and close scripts be optional |
| # for backwards compatibility |
| es_files[constants.ES_SCRIPT_SNAPSHOT] = False |
| es_files[constants.ES_SCRIPT_OPEN] = False |
| es_files[constants.ES_SCRIPT_CLOSE] = False |
| |
| es_files[constants.ES_PARAMETERS_FILE] = True |
| |
| for (filename, required) in es_files.items(): |
| try: |
| # Here we actually fill the dict with the ablsolute path name for each |
| # script or None, depending on the corresponding checks. See the |
| # function's docstrings for more on these checks. |
| es_files[filename] = _CheckExtStorageFile(es_dir, filename, required) |
| except errors.BlockDeviceError, err: |
| return False, str(err) |
| |
| parameters = [] |
| if constants.ES_PARAMETERS_FILE in es_files: |
| parameters_file = es_files[constants.ES_PARAMETERS_FILE] |
| try: |
| parameters = utils.ReadFile(parameters_file).splitlines() |
| except EnvironmentError, err: |
| return False, ("Error while reading the EXT parameters file at %s: %s" % |
| (parameters_file, utils.ErrnoOrStr(err))) |
| parameters = [v.split(None, 1) for v in parameters] |
| |
| es_obj = \ |
| objects.ExtStorage(name=name, path=es_dir, |
| create_script=es_files[constants.ES_SCRIPT_CREATE], |
| remove_script=es_files[constants.ES_SCRIPT_REMOVE], |
| grow_script=es_files[constants.ES_SCRIPT_GROW], |
| attach_script=es_files[constants.ES_SCRIPT_ATTACH], |
| detach_script=es_files[constants.ES_SCRIPT_DETACH], |
| setinfo_script=es_files[constants.ES_SCRIPT_SETINFO], |
| verify_script=es_files[constants.ES_SCRIPT_VERIFY], |
| snapshot_script=es_files[constants.ES_SCRIPT_SNAPSHOT], |
| open_script=es_files[constants.ES_SCRIPT_OPEN], |
| close_script=es_files[constants.ES_SCRIPT_CLOSE], |
| supported_parameters=parameters) |
| return True, es_obj |
| |
| |
| def _ExtStorageEnvironment(unique_id, ext_params, |
| size=None, grow=None, metadata=None, |
| name=None, uuid=None, |
| snap_name=None, snap_size=None, |
| exclusive=None): |
| """Calculate the environment for an External Storage script. |
| |
| @type unique_id: tuple (driver, vol_name) |
| @param unique_id: ExtStorage pool and name of the Volume |
| @type ext_params: dict |
| @param ext_params: the EXT parameters |
| @type size: integer |
| @param size: size of the Volume (in mebibytes) |
| @type grow: integer |
| @param grow: new size of Volume after grow (in mebibytes) |
| @type metadata: string |
| @param metadata: metadata info of the Volume |
| @type name: string |
| @param name: name of the Volume (objects.Disk.name) |
| @type uuid: string |
| @param uuid: uuid of the Volume (objects.Disk.uuid) |
| @type snap_size: integer |
| @param snap_size: the size of the snapshot |
| @type snap_name: string |
| @param snap_name: the name of the snapshot |
| @type exclusive: boolean |
| @param exclusive: Whether the Volume will be opened exclusively or not |
| @rtype: dict |
| @return: dict of environment variables |
| |
| """ |
| vol_name = unique_id[1] |
| |
| result = {} |
| result["VOL_NAME"] = vol_name |
| |
| # EXT params |
| for pname, pvalue in ext_params.items(): |
| result["EXTP_%s" % pname.upper()] = str(pvalue) |
| |
| if size is not None: |
| result["VOL_SIZE"] = str(size) |
| |
| if grow is not None: |
| result["VOL_NEW_SIZE"] = str(grow) |
| |
| if metadata is not None: |
| result["VOL_METADATA"] = metadata |
| |
| if name is not None: |
| result["VOL_CNAME"] = name |
| |
| if uuid is not None: |
| result["VOL_UUID"] = uuid |
| |
| if snap_name is not None: |
| result["VOL_SNAPSHOT_NAME"] = snap_name |
| |
| if snap_size is not None: |
| result["VOL_SNAPSHOT_SIZE"] = str(snap_size) |
| |
| if exclusive is not None: |
| result["VOL_OPEN_EXCLUSIVE"] = str(exclusive) |
| |
| return result |
| |
| |
| def _VolumeLogName(kind, es_name, volume): |
| """Compute the ExtStorage log filename for a given Volume and operation. |
| |
| @type kind: string |
| @param kind: the operation type (e.g. create, remove etc.) |
| @type es_name: string |
| @param es_name: the ExtStorage name |
| @type volume: string |
| @param volume: the name of the Volume inside the External Storage |
| |
| """ |
| # Check if the extstorage log dir is a valid dir |
| if not os.path.isdir(pathutils.LOG_ES_DIR): |
| base.ThrowError("Cannot find log directory: %s", pathutils.LOG_ES_DIR) |
| |
| # TODO: Use tempfile.mkstemp to create unique filename |
| basename = ("%s-%s-%s-%s.log" % |
| (kind, es_name, volume, utils.TimestampForFilename())) |
| return utils.PathJoin(pathutils.LOG_ES_DIR, basename) |
