Synnefo » snf-ganeti » ganeti-local

	  echo "ES_SEARCH_PATH = [$(ES_SEARCH_PATH)]"; \

# --with-extstorage-search-path=...

# same black sed magic for quoting of the strings in the list

AC_ARG_WITH([extstorage-search-path],

  [AS_HELP_STRING([--with-extstorage-search-path=LIST],

    [comma separated list of directories to]

    [ search for External Storage Providers]

    [ (default is /srv/ganeti/extstorage)]

  )],

  [es_search_path=`echo -n "$withval" | sed -e "s/\([[^,]]*\)/'\1'/g"`],

  [es_search_path="'/srv/ganeti/extstorage'"])

AC_SUBST(ES_SEARCH_PATH, $es_search_path)

class ExtStorageDevice(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):

    """Attaches to an extstorage block device.

    """

    super(ExtStorageDevice, self).__init__(unique_id, children, size, params)

    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.major = self.minor = None

    self.Attach()

  @classmethod

  def Create(cls, unique_id, children, size, params):

    """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))

    # Call the External Storage's create script,

    # to provision a new Volume inside the External Storage

    _ExtStorageAction(constants.ES_ACTION_CREATE, unique_id, str(size))

    return ExtStorageDevice(unique_id, children, size, params)

  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)

  def Rename(self, new_id):

    """Rename this device.

    """

    pass

  def Attach(self):

    """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

    self.dev_path = _ExtStorageAction(constants.ES_ACTION_ATTACH,

                                      self.unique_id)

    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 = os.minor(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.minor = None

    self.dev_path = None

  def Open(self, force=False):

    """Make the device ready for I/O.

    """

    pass

  def Close(self):

    """Notifies that the device will no longer be used for I/O.

    """

    pass

  def Grow(self, amount, dryrun, backingstore):

    """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():

      _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,

                      str(self.size), grow=str(new_size))

  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,

                      metadata=text)

def _ExtStorageAction(action, unique_id, size=None, grow=None, metadata=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

  @type unique_id: tuple (driver, vol_name)

  @param unique_id: a tuple containing the type of ExtStorage (driver)

                    and the Volume name

  @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

  @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:

    _ThrowError("%s" % inst_es)

  # Create the basic environment for the driver's scripts

  create_env = _ExtStorageEnvironment(unique_id, size, grow, metadata)

  # 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:

    _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)

  # Run the external script

  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[-20:]

    _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 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, we will populate it with the absolute path

  # names; if the value is True, then it is a required file, otherwise

  # an optional one

  es_files = dict.fromkeys(constants.ES_SCRIPTS, True)

  for filename in es_files:

    es_files[filename] = utils.PathJoin(es_dir, filename)

    try:

      st = os.stat(es_files[filename])

    except EnvironmentError, err:

      return False, ("File '%s' under path '%s' is missing (%s)" %

                     (filename, es_dir, utils.ErrnoOrStr(err)))

    if not stat.S_ISREG(stat.S_IFMT(st.st_mode)):

      return False, ("File '%s' under path '%s' is not a regular file" %

                     (filename, es_dir))

    if filename in constants.ES_SCRIPTS:

      if stat.S_IMODE(st.st_mode) & stat.S_IXUSR != stat.S_IXUSR:

        return False, ("File '%s' under path '%s' is not executable" %

                       (filename, es_dir))

  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])

  return True, es_obj

def _ExtStorageEnvironment(unique_id, size=None, grow=None, metadata=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 size: string

  @param size: size of the Volume (in mebibytes)

  @type grow: string

  @param grow: new size of Volume after grow (in mebibytes)

  @type metadata: string

  @param metadata: metadata info of the Volume

  @rtype: dict

  @return: dict of environment variables

  """

  vol_name = unique_id[1]

  result = {}

  result["VOL_NAME"] = vol_name

  if size is not None:

    result["VOL_SIZE"] = size

  if grow is not None:

    result["VOL_NEW_SIZE"] = grow

  if metadata is not None:

    result["VOL_METADATA"] = metadata

  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):

    _ThrowError("Cannot find log directory: %s", pathutils.LOG_ES_DIR)

  # TODO: Use tempfile.mkstemp to create unique filename

  base = ("%s-%s-%s-%s.log" %

          (kind, es_name, volume, utils.TimestampForFilename()))

  return utils.PathJoin(pathutils.LOG_ES_DIR, base)

  constants.LD_EXT: ExtStorageDevice,

  ToStdout("  - ExtStorage Providers search path: %s",

           utils.CommaJoin(pathutils.ES_SEARCH_PATH))

    # If the instance's disk template is `rbd' or `ext' and there was a

    # successful migration, unmap the device from the source node.

    if self.instance.disk_template in (constants.DT_RBD, constants.DT_EXT):

  constants.DT_EXT: ".ext",

  constants.DT_EXT: constants.LD_EXT,

    elif template_name == constants.DT_EXT:

      logical_id_fn = lambda idx, _, disk: ("ext", names[idx])

      elif self.op.disk_template == constants.DT_EXT:

        # FIXME: Function that checks prereqs if needed

        pass

                                      constants.DT_RBD,

                                      constants.DT_EXT):

DT_EXT = "ext"

  DT_EXT,

  DT_EXT,

  DT_EXT,

LD_EXT = "ext"

  LD_EXT,

  LD_EXT,

  DT_EXT

# External Storage (ES) related constants

ES_ACTION_CREATE = "create"

ES_ACTION_REMOVE = "remove"

ES_ACTION_GROW = "grow"

ES_ACTION_ATTACH = "attach"

ES_ACTION_DETACH = "detach"

ES_ACTION_SETINFO = "setinfo"

ES_SCRIPT_CREATE = ES_ACTION_CREATE

ES_SCRIPT_REMOVE = ES_ACTION_REMOVE

ES_SCRIPT_GROW = ES_ACTION_GROW

ES_SCRIPT_ATTACH = ES_ACTION_ATTACH

ES_SCRIPT_DETACH = ES_ACTION_DETACH

ES_SCRIPT_SETINFO = ES_ACTION_SETINFO

ES_SCRIPTS = frozenset([

  ES_SCRIPT_CREATE,

  ES_SCRIPT_REMOVE,

  ES_SCRIPT_GROW,

  ES_SCRIPT_ATTACH,

  ES_SCRIPT_DETACH,

  ES_SCRIPT_SETINFO

  ])

  LD_EXT: {},

  DT_EXT: {},

    constants.DT_EXT: sum(d[constants.IDISK_SIZE] for d in disks),

                         constants.LD_BLOCKDEV, constants.LD_RBD,

                         constants.LD_EXT]:

                         constants.LD_RBD, constants.LD_EXT):

class ExtStorage(ConfigObject):

  """Config object representing an External Storage Provider.

  """

  __slots__ = [

    "name",

    "path",

    "create_script",

    "remove_script",

    "grow_script",

    "attach_script",

    "detach_script",

    "setinfo_script",

    ]

ES_SEARCH_PATH = _autoconf.ES_SEARCH_PATH

LOG_ES_DIR = LOG_DIR + "/extstorage"

                                constants.DT_EXT,