Synnefo » snf-ganeti » ganeti-local

    to handle the method; subclasses of Avatar are expected to

    implement methods of this naming convention.

    args = broker.unserialize(args, self)

    kw = broker.unserialize(kw, self)

    method = getattr(self, "perspective_%s" % message)

def createDaemon():

  """Detach a process from the controlling terminal and run it in the

  background as a daemon.

  """

  UMASK = 077

  WORKDIR = "/"

  Methods:

    Restart(): issue a command to restart the represented machine.

  """

  def __init__(self, name, state):

    self.name = name

      - adds the ssh-key

      - sets the node id

      - sets the node status to installed

  f = open("/etc/ssh/ssh_host_rsa_key", 'w')

  f.write(rsa)

  f.close()

    memory_dom0 is the memory allocated for domain0 in MiB

    memory_free is the currently available (free) ram in MiB

    memory_total is the total number of ram in MiB

  outputarray = {}

  vginfo = _GetVGInfo(vgname)

  outputarray['vg_size'] = vginfo['vg_size']

    by ssh-execution of 'hostname', result compared against name in list.

  """

  result = {}

  if 'hypervisor' in what:

    A list of all running instances on the current node

    - instance1.example.com

    - instance2.example.com

  try:

    names = hypervisor.GetHypervisor().ListInstances()

  except errors.HypervisorError, err:

    memory: memory size of instance (int)

    state: xen state of instance (string)

    time: cpu time of instance (float)

  output = {}

  iinfo = hypervisor.GetHypervisor().GetInstanceInfo(instance)

    state: xen state of instance (string)

    time: cpu time of instance (float)

    vcpus: the number of cpus

  output = {}

  iinfo = hypervisor.GetHypervisor().GetAllInstancesInfo()

  Args:

    instance - name of instance to start.

  running_instances = GetInstanceList()

  if instance.name in running_instances:

  Args:

    instance - name of instance to shutdown.

  running_instances = GetInstanceList()

  if instance.name not in running_instances:

  Returns:

    a config entry for the actual lvm device snapshotted.

  if disk.children:

    if len(disk.children) == 1:

      # only one child, let's recurse on it

  Returns:

    True if successful, False otherwise.

  inst_os = OSFromDisk(instance.os)

  export_script = inst_os.export_script

  Returns:

    False in case of error, True otherwise.

  destdir = os.path.join(constants.EXPORT_DIR, instance.name + ".new")

  finaldestdir = os.path.join(constants.EXPORT_DIR, instance.name)

    A serializable config file containing the export info.

  """

  cff = os.path.join(dest, constants.EXPORT_CONF_FILE)

  config = objects.SerializableConfigParser()

    False in case of error, True otherwise.

  """

  inst_os = OSFromDisk(instance.os)

  import_script = inst_os.import_script

def ListExports():

  """Return a list of exports currently available on this machine.

  """

  if os.path.isdir(constants.EXPORT_DIR):

    return os.listdir(constants.EXPORT_DIR)

  Returns:

    False in case of error, True otherwise.

  target = os.path.join(constants.EXPORT_DIR, export)

  shutil.rmtree(target)

  after assembly we'll have our correct major/minor.

  """

  STATUS_UNKNOWN = 0

  STATUS_EXISTING = 1

  STATUS_STANDBY = 2

    Returns:

      list of (free_space, name) with free_space in mebibytes

    """

    command = ["pvs", "--noheadings", "--nosuffix", "--units=m",

               "-opv_name,vg_name,pv_free,pv_attr", "--unbuffered",

    """Create a snapshot copy of an lvm block device.

    """

    snap_name = self._lv_name + ".snap"

    # remove existing snapshot if found

    commands: dictionary with special contents, see the design doc for

    cmdline handling

  """

  if len(argv) == 0:

    binary = "<command>"

    ourselves in the post-run node list.

    """

    env = {"CLUSTER": self.op.cluster_name,

           "MASTER": self.hostname['hostname_full']}

    return env, [], [self.hostname['hostname_full']]

      node: name of the node to check

      file_list: required list of files

      local_cksum: dictionary of local files and their checksums

    """

    # compares ganeti version

    local_version = constants.PROTOCOL_VERSION

  """Check that mirrors are not degraded.

  """

  cfgw.SetDiskID(dev, node)

  result = True

    Any errors are signalled by raising errors.OpPrereqError.

    """

    node = self.cfg.GetNodeInfo(self.cfg.ExpandNodeName(self.op.node_name))

    if node is None:

      logger.Error("Error: Node '%s' is unknown." % self.op.node_name)

    master.

    """

    #TODO: do not rely on gethostname returning the FQDN

    logger.Info("setting master to %s, old master: %s" %

                (self.new_master, self.old_master))

    """Computes the list of nodes and their attributes.

    """

    instance_names = utils.NiceSort(self.cfg.GetInstanceList())

    instance_list = [self.cfg.GetInstanceInfo(iname) for iname

                     in instance_names]

  This always creates all devices.

  """

  if device.children:

    for child in device.children:

      if not _CreateBlockDevOnPrimary(cfg, node, child):

  def Exec(self, feedback_fn):

    """Gather and return data"""

    result = {}

    for instance in self.wanted_instances:

      remote_info = rpc.call_instance_info(instance.primary_node,

    """Compute and return the list of nodes.

    """

    ilist = [self.cfg.GetInstanceInfo(iname) for iname

             in self.cfg.GetInstanceList()]

    result = []

class ConfigWriter:

  def __init__(self, cfg_file=None, offline=False):

    self._config_data = None

    self._config_time = None

    """Mark the status of an instance to down in the configuration.

    """

    self._OpenConfig()

    if instance_name not in self._config_data.instances:

  """

class OpExecError(GenericError):

  """Error during OpCode execution.

  """

class OpCodeUnknown(GenericError):

  """Unknown opcode submitted.

  """

class HooksFailure(GenericError):

  """A generic hook failure.

  """

class HooksAbort(HooksFailure):

  """A required hook has failed.

  """

class UnitParseError(GenericError):

  """Unable to parse size unit.

    """Create a Xen 3.0 config file.

    """

    config = StringIO()

    config.write("# this is autogenerated by Ganeti, please do not edit\n#\n")

    config.write("kernel = '/boot/vmlinuz-2.6-xenU'\n")

  a real virtualisation software installed.

  """

  _ROOT_DIR = "/var/run/ganeti-fake-hypervisor"

  def __init__(self):

      Otherwise, { 'nodename' : ['volume1', 'volume2', ...], ... }

    """

    if node == None:

      node = self.primary_node

from twisted.internet.pollreactor import PollReactor

class ReReactor(PollReactor):

  def run(self, installSignalHandlers=1):

    """Custom run method.

    `utils.RunResult` as for `utils.RunCmd()`

  """

  argv = ["ssh", "-q", "-oEscapeChar=none"]

  if batch:

    argv.append("-oBatchMode=yes")

def Unlock(name):

  lockfile = _GetLockFile(name)

  try:

def LockCleanup():

  for lock in _locksheld:

    Unlock(lock)

    - ip: IP addr

    - hostname_full: hostname fully qualified

    - hostname: hostname fully qualified (historic artifact)

  try:

    (fqdn, dummy, ipaddrs) = socket.gethostbyname_ex(hostname)

    ipaddr = ipaddrs[0]

     True if it does, false otherwise.

  """

  return os.path.isdir("/sys/class/net/%s/bridge" % bridge)

    nothing

  """

  op = opcodes.OpQueryExports(nodes=opts.nodes)

  exports = SubmitOpCode(op)

  for node in exports:

    1 in case of error, 0 otherwise

  """

  instance = args[0]

  op = opcodes.OpCreateInstance(instance_name=instance, mem_size=opts.mem,

                                disk_size=opts.size, swap_size=opts.swap,

                                disk_template=opts.disk_template,

                                ip=opts.ip, bridge=opts.bridge, start=False,

                                src_node=opts.src_node, src_path=opts.src_dir,

                                wait_for_sync=opts.wait_for_sync)

              metavar="<dir>"),

  ]

commands = {

  'list': (PrintExportList, ARGS_NONE,

           [DEBUG_OPT,

  Args:

    opts - class with options as members

  """

  if not opts.yes_do_it:

    print ("Destroying a cluster is irreversibly. If you really want destroy"

    node - node to run new instance on

  """

  instance = args[0]

  op = opcodes.OpCreateInstance(instance_name=instance, mem_size=opts.mem,

  """Compute instance run-time status.

  """

  retcode = 0

  op = opcodes.OpQueryInstanceData(instances=args)

  result = SubmitOpCode(op)

              default=None, metavar="<bridge>")

  ]

commands = {

  'add': (AddInstance, ARGS_ONE, add_opts,

          "[opts...] <name>",