Synnefo » snf-ganeti

	  echo "XEN_INITRD = '$(XEN_INITRD)'"; \

	  echo "FILE_STORAGE_DIR = '$(FILE_STORAGE_DIR)'"; \

	  echo "ENABLE_FILE_STORAGE = $(ENABLE_FILE_STORAGE)"; \

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

	  echo "KVM_PATH = '$(KVM_PATH)'"; \

	  echo "SOCAT_PATH = '$(SOCAT)'"; \

AC_SUBST(FILE_STORAGE_DIR, $file_storage_dir)

AC_SUBST(ENABLE_FILE_STORAGE, $enable_file_storage)

# --with-kvm-path=...

AC_ARG_WITH([kvm-path],

  [AS_HELP_STRING([--with-kvm-path=PATH],

    _Fail("; ".join(msgs))

  """Checks whether given file_storage_dir is valid.

  @return: the normalized path if valid, None otherwise

  if not constants.ENABLE_FILE_STORAGE:

    _Fail("File storage disabled at configure time")

  cfg = _GetConfig()

    _Fail("File storage directory '%s' is not under base file"

def CreateFileStorageDir(file_storage_dir):

#

#

#

# 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

  constants.LD_DRBD8: DRBD8,

  }

  DEV_MAP[constants.LD_FILE] = FileStorage

    master_netdev=master_netdev,

    cluster_name=clustername.name,

    file_storage_dir=file_storage_dir,

    enabled_hypervisors=enabled_hypervisors,

    beparams={constants.PP_DEFAULT: beparams},

    nicparams={constants.PP_DEFAULT: nicparams},

  "FORCE_VARIANT_OPT",

  "GLOBAL_FILEDIR_OPT",

  "HID_OS_OPT",

  "HVLIST_OPT",

  "HVOPTS_OPT",

  "HYPERVISOR_OPT",

                                metavar="DIR",

                                default=constants.DEFAULT_FILE_STORAGE_DIR)

NOMODIFY_ETCHOSTS_OPT = cli_option("--no-etc-hosts", dest="modify_etc_hosts",

                                   help="Don't modify /etc/hosts",

                                   action="store_false", default=True)

  ToStdout("  - lvm reserved volumes: %s", reserved_lvs)

  ToStdout("  - drbd usermode helper: %s", result["drbd_usermode_helper"])

  ToStdout("  - file storage path: %s", result["file_storage_dir"])

  ToStdout("  - maintenance of node health: %s",

           result["maintain_node_health"])

  ToStdout("  - uid pool: %s",

  # Special case for file storage

  if storage_type == constants.ST_FILE:

    # storage.FileStorage wants a list of storage directories

  return []

      "volume_group_name": cluster.volume_group_name,

      "drbd_usermode_helper": cluster.drbd_usermode_helper,

      "file_storage_dir": cluster.file_storage_dir,

      "maintain_node_health": cluster.maintain_node_health,

      "ctime": cluster.ctime,

      "mtime": cluster.mtime,

    old_name = inst.name

    rename_file_storage = False

        self.op.new_name != inst.name):

      old_file_storage_dir = os.path.dirname(inst.disks[0].logical_id[1])

      rename_file_storage = True

                                                         disk_index)),

                              mode=disk["mode"])

      disks.append(disk_dev)

  else:

    raise errors.ProgrammerError("Invalid disk template '%s'" % template_name)

  return disks

    pnode = target_node

    all_nodes = [pnode]

    file_storage_dir = os.path.dirname(instance.disks[0].logical_id[1])

    result = lu.rpc.call_file_storage_dir_create(pnode, file_storage_dir)

    # 128 MB are added for drbd metadata for each disk

    constants.DT_DRBD8: _compute(disks, 128),

    constants.DT_FILE: {},

  }

  if disk_template not in req_size_dict:

    # 128 MB are added for drbd metadata for each disk

    constants.DT_DRBD8: sum(d["size"] + 128 for d in disks),

    constants.DT_FILE: None,

  }

  if disk_template not in req_size_dict:

    else:

      network_port = None

      # this is needed because os.path.join does not accept None arguments

      if self.op.file_storage_dir is None:

        string_file_storage_dir = ""

        string_file_storage_dir = self.op.file_storage_dir

      # build the full file storage dir path

                                        string_file_storage_dir, instance)

    else:

      file_storage_dir = ""

    self.disk = instance.FindDisk(self.op.disk)

      _CheckNodesFreeDiskPerVG(self, nodenames,

                               self.disk.ComputeGrowth(self.op.amount))

        result.append(("disk/%d" % device_idx, "remove"))

      elif disk_op == constants.DDM_ADD:

        # add a new disk

          file_driver, file_path = instance.disks[0].logical_id

          file_path = os.path.dirname(file_path)

        else:

    return self._config_data.cluster.file_storage_dir

  @locking.ssynchronized(_config_lock, shared=1)

  def GetHypervisorType(self):

    """Get the hypervisor type for this cluster.

      constants.SS_CLUSTER_NAME: cluster.cluster_name,

      constants.SS_CLUSTER_TAGS: cluster_tags,

      constants.SS_FILE_STORAGE_DIR: cluster.file_storage_dir,

      constants.SS_MASTER_CANDIDATES: mc_data,

      constants.SS_MASTER_CANDIDATES_IPS: mc_ips_data,

      constants.SS_MASTER_IP: cluster.master_ip,

KVM_IFUP = _autoconf.PKGLIBDIR + "/kvm-ifup"

ETC_HOSTS = "/etc/hosts"

DEFAULT_FILE_STORAGE_DIR = _autoconf.FILE_STORAGE_DIR

ENABLE_FILE_STORAGE = _autoconf.ENABLE_FILE_STORAGE

SYSCONFDIR = _autoconf.SYSCONFDIR

TOOLSDIR = _autoconf.TOOLSDIR

CONF_DIR = SYSCONFDIR + "/ganeti"

DT_PLAIN = "plain"

DT_DRBD8 = "drbd"

DT_FILE = "file"

# the set of network-mirrored disk templates

DTS_NET_MIRROR = frozenset([DT_DRBD8])

# the set of non-lvm-based disk templates

# the set of disk templates which can be grown

# the set of disk templates that allow adoption

DTS_MAY_ADOPT = frozenset([DT_PLAIN])

#: Give child process up to 5 seconds to exit after sending a signal

CHILD_LINGER_TIMEOUT = 5.0

FILE_DRIVER = frozenset([FD_LOOP, FD_BLKTAP])

SS_CLUSTER_NAME = "cluster_name"

SS_CLUSTER_TAGS = "cluster_tags"

SS_FILE_STORAGE_DIR = "file_storage_dir"

SS_MASTER_CANDIDATES = "master_candidates"

SS_MASTER_CANDIDATES_IPS = "master_candidates_ips"

SS_MASTER_IP = "master_ip"

    actual algorithms from bdev.

    """

      self.size += amount

    elif self.dev_type == constants.LD_DRBD8:

      if self.children:

    "master_netdev",

    "cluster_name",

    "file_storage_dir",

    "enabled_hypervisors",

    "hvparams",

    "os_hvp",

                               errors.ECODE_INVAL)

@ht.WithDesc("CheckFileStorage")

def _CheckFileStorage(value):

  """Ensures file storage is enabled if used.

  """

  if value == constants.DT_FILE:

    RequireFileStorage()

  return True

  def GetFileStorageDir(self):

    return self._config_data["cluster"]["file_storage_dir"]

  def GetNodeList(self):

    return self._config_data["nodes"].keys()

    constants.SS_CLUSTER_NAME,

    constants.SS_CLUSTER_TAGS,

    constants.SS_FILE_STORAGE_DIR,

    constants.SS_MASTER_CANDIDATES,

    constants.SS_MASTER_CANDIDATES_IPS,

    constants.SS_MASTER_IP,

    """

    return self._ReadFile(constants.SS_FILE_STORAGE_DIR)

  def GetMasterCandidates(self):

    """Return the list of master candidates.