Synnefo » snf-ganeti » Ganeti ExtStorage providers

#!/usr/bin/env python

#

# Copyright (C) 2012 Greek Research and Technology Network

#

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

"""Grow an existing Image file

This program grows an existing Image file which resides under a

shared directory.

It takes it's input from environment variables. Specifically the

following variables should be present:

 - VOL_NAME: The name of the Image to grow

 - VOL_SIZE: The current Image's size

 - VOL_NEW_SIZE: The new size of the Image after it's grown

Returns 0 upon successful grow, 1 upon failure

"""

import os

import sys

sys.path.append("/usr/share/ganeti/")

from ganeti import utils

# Default shared directory

SHARED_DIR = "/srv/ganeti/shared-file-storage"

def ReadEnv():

  """Read the mandatory enviromental variables

  """

  name = os.getenv("VOL_NAME")

  if name is None:

    sys.stderr.write('The environment variable VOL_NAME is missing.\n')

    return None

  new_size = os.getenv("VOL_NEW_SIZE")

  if new_size is None:

    sys.stderr.write('The environment variable VOL_NEW_SIZE is missing.\n')

    return None

  shared_dir_param = os.getenv("EXTP_SHARED_DIR")

  if shared_dir_param is not None:

    sys.stderr.write('Found shared dir param, value: %s\n' % shared_dir_param)

  return (name, new_size, shared_dir_param)

def _ParseLosetupOutput(output, filename):

  """Parse the output of `losetup -j <filename>`

  This method parses the output of `losetup -j <filename>` and returns

  the corresponding loop device path for this filename

  (e.g. /dev/loop0)

  @type output: string

  @param output: the whole output of `losetup -j filename`

  @type filename: string

  @param filename: the complete file path to the file we search for

  @rtype: string or None

  @return: loop device path if the file is losetup, else None

  """

  # `losetup -j file1` output looks like this

  #   /dev/loop0: [X]:Y (/path/to/file1)

  # if the file has been losetup. If not there is no output.

  # If the file has been losetup more than once, then there will be

  # multiple lines like the one above.

  #

  # We assume the following format (space is the seperator):

  # field0: field1 (field2)

  field0 = 0

  field_sep = " "

  lines = output.splitlines()

  splitted_lines = map(lambda l: l.split(field_sep), lines)

  # Check empty output. If empty, the file is not losetup

  if not splitted_lines:

    return None

  # Check if we have more than one lines in the output

  if len(splitted_lines) > 1:

    sys.stderr.write("The file %s is losetup more than once" % filename)

    sys.exit(1)

  # The file is losetup only once

  # Take field0, remove the ":" at the end and we have our path

  dev_path = splitted_lines[0][field0].split(":")[0]

  return dev_path

def main():

  sys.stderr.write('Creation started: reading environment...\n')

  # Read environment.

  env = ReadEnv()

  if env is None:

    sys.stderr.write('Wrong environment. Aborting\n')

    return 1

  file_name, new_size, shared_dir_param = env

  if shared_dir_param is None:

    shared_dir_param = SHARED_DIR

  file_path = utils.PathJoin(shared_dir_param, file_name)

  sys.stderr.write('Read environment successfully: file name: %s, '

                   'new size: %sMB\n' % (file_path, new_size))

  # Check if the file exists.

  if not os.path.exists(file_path):

    sys.stderr.write("File %s does not exist. Aborting\n" % file_path)

    return 1

  # Grow file.

  try:

    f = open(file_path, "a+")

    f.truncate(int(new_size) * 1024 * 1024)

    f.close()

  except EnvironmentError, err:

    sys.stderr.write('Error in file growth: %' % str(err))

    return 1

  # Growth successful.

  # Now the loop device needs to reread the size of the associated file.

  # Find out the loop device path first.

  cmd1 = ["losetup", "-j", "%s" % file_path]

  result = utils.RunCmd(cmd1)

  if result.failed:

    sys.stderr.write("losetup -j %s failed (%s): %s" %

                     (dev_path, result.fail_reason, result.output))

    return 1

  else:

    # Parse the result's output.

    dev_path = _ParseLosetupOutput(result.output, file_path)

    if dev_path is None:

      # The file is not attached. We should never get here during growth.

      sys.stderr.write('File %s is not losetup during growth (%s): %s\n'

                       'This should not happen. Aborting\n' %

                        file_path, result.fail_reason, result.output)

      return 1

    else:

      # The file is losetup as expected. Reread size of file.

      cmd2 = ["losetup", "-c", "%s" % dev_path]

      result = utils.RunCmd(cmd2)

      if result.failed:

        sys.stderr.write('losetup -c %s failed (%s): %s' %

                         (dev_path, result.fail_reason, result.output))

        sys.stderr.write('You have to manually reread size of loop device `%s` '

                         'since its associated file `%s` has grown\n' %

                         (dev_path, file_path,

                          result.fail_reason, result.output))

        return 1

      # Growth and reread successful.

      sys.stderr.write('Grow successful for file: %s\n' % file_path)

      return 0

if __name__ == "__main__":

    sys.exit(main())