Synnefo » snf-ganeti » ganeti-local

    except Exception, msg:

      # Ignore errors while loading the file and treat it as empty

      self.data = {}

    if "instance" not in self.data:

      self.data["instance"] = {}

      # secondary node.

      for instance in GetInstanceList(with_secondaries=check_nodes):

        try:

          instance.ActivateDisks()

        except Error, x:

          self.messages.append(Message(ERROR, str(x)))

                                       (instance.name, MAXTRIES)))

          continue

        try:

          instance.Restart()

        except Error, x:

          self.messages.append(Message(ERROR, str(x)))

      else:

        if notepad.NumberOfRestartAttempts(instance):

          notepad.RemoveInstance(instance)

          self.messages.append(msg)

  def WriteReport(self, logfile):

      return None

  else:

    raise errors.ProgrammerError("Cannot snapshot non-lvm block device"

                                 (disk.unique_id, disk.dev_type))

        secondary_ip != hostname.ip and

        (not utils.TcpPing(constants.LOCALHOST_IP_ADDRESS, secondary_ip,

                           constants.DEFAULT_NODED_PORT))):

                                 secondary_ip)

    self.secondary_ip = secondary_ip

    if not (os.path.isfile(constants.NODE_INITD_SCRIPT) and

            os.access(constants.NODE_INITD_SCRIPT, os.X_OK)):

  def Exec(self, feedback_fn):

    """Initialize the cluster.

                         (fname, to_node))

    finally:

      if not rpc.call_node_start_master(master):

def _WaitForSync(cfgw, instance, proc, oneshot=False, unlock=False):

      if not utils.TcpPing(myself.secondary_ip,

                           secondary_ip,

                           constants.DEFAULT_NODED_PORT):

    self.new_node = objects.Node(name=node,

                                 primary_ip=primary_ip,

                                    new_node.secondary_ip,

                                    constants.DEFAULT_NODED_PORT,

                                    10, False):

    success, msg = ssh.VerifyNodeHostname(node)

    if not success:

      raise errors.OpExecError("Node '%s' claims it has a different hostname"

                               (node, msg))

    # Distribute updated /etc/hosts and known_hosts to all nodes,

    if self.old_master == self.new_master:

      raise errors.OpPrereqError("This commands must be run on the node"

                                 self.old_master)

  def Exec(self, feedback_fn):

    if not rpc.call_node_start_master(self.new_master):

      logger.Error("could not start the master role on the new master"

                   " %s, please check" % self.new_master)

      result = rpc.call_blockdev_assemble(node, node_disk,

                                          instance.name, is_primary)

      if not result:

        if is_primary or not ignore_secondaries:

          disks_ok = False

      if is_primary:

    try:

      feedback_fn("Running the instance OS create scripts...")

      if not rpc.call_instance_os_add(inst.primary_node, inst, "sda", "sdb"):

                                 (inst.name, inst.primary_node))

    finally:

      _ShutdownInstanceDisks(inst, self.cfg)

    try:

      if not rpc.call_instance_run_rename(inst.primary_node, inst, old_name,

                                          "sda", "sdb"):

               (inst.name, inst.primary_node))

        logger.Error(msg)

    finally:

      raise errors.OpPrereqError("Can't find this device ('%s') in the"

                                 " instance." % self.op.disk_name)

    if len(disk.children) > 1:

    self.disk = disk

  def Exec(self, feedback_fn):

      if not _CreateBlockDevOnSecondary(cfg, remote_node, instance,

                                        new_drbd, False,

                                        _GetInstanceInfoText(instance)):

                                 remote_node)

      logger.Info("adding new mirror component on primary")

        # remove secondary dev

        cfg.SetDiskID(new_drbd, remote_node)

        rpc.call_blockdev_remove(remote_node, new_drbd)

      # the device exists now

      # call the primary node to add the mirror to md

  """Main program.

  """

  parser.add_option('--dry-run', dest='dry_run',

      action="store_true",

      help="Show what would be done")

  """Shows a warning about the cron job.

  """

  print

  print qa_utils.FormatWarning(msg)

        node2disk[node_name].append(name)

  if [node2_full, node_full][int(onmaster)] not in node2disk:

  # Check whether nodes have ability to stop disks

  for node_name, disks in node2disk.iteritems():

def TestInstanceMasterDiskFailure(instance, node, node2):

  """Testing disk failure on master node."""

  # The following can cause crashes, thus it's disabled until fixed

  #return _TestInstanceDiskFailure(instance, node, node2, True)

  master = qa_config.GetMasterNode()

  if qa_utils.GetNodeInstances(node2, secondaries=False):

  # Fail over to secondary node

  cmd = ['gnt-node', 'failover', '-f', node['primary']]

  node3 = qa_config.AcquireNode(exclude=[node, node2])

  try:

    if qa_utils.GetNodeInstances(node3, secondaries=True):

    # Evacuate all secondary instances

    cmd = ['gnt-node', 'evacuate', '-f', node2['primary'], node3['primary']]

# this is an option common to more than one command, so we declare

# it here and reuse it

node_option = make_option("-n", "--node", action="append", dest="nodes",

commands = {

  'init': (InitCluster, ARGS_ONE,

  instance_name = args[0]

  if not opts.force:

    if not AskUser(usertext):

      return 1

  parser = optparse.OptionParser()

  parser.add_option('--dry-run', dest='dry_run',

                    action="store_true",

  parser.add_option(FORCE_OPT)

  parser.add_option('--verbose', dest='verbose',

                    action="store_true",

    raise Error("Configuration file not specified")

  if not options.force:

    if not AskUser(usertext):

      sys.exit(1)

  osname, nodename, release, version, arch = os.uname()

  if osname != 'Linux':

  if not release.startswith("2.6."):

  if not os.path.ismount("/sys"):

  if not os.path.isdir("/sys/block"):

  if not os.path.ismount("/proc"):

  if not os.path.exists("/proc/mounts"):

    raise SysconfigError("Can't find /proc/mounts")

      vg_free: The available space in the volume group

  """

  if not result.failed:

    try:

      lv_count, vg_size, vg_free = result.stdout.strip().split()

      break

    time.sleep(0.250)

  else:

  rdev = os.stat(path).st_rdev

  if devnum != rdev:

                         (path, rdev, devnum))

  """

  if not CheckReread(name):

  fd = os.open("/dev/%s" % name, os.O_RDWR | os.O_SYNC)

  olddata = os.read(fd, 512)

  if len(olddata) != 512:

                           (name, len(olddata)))

  newdata = "\0" * 512

  os.lseek(fd, 0, 0)

  os.close(fd)

  if bytes_written != 512:

    raise OperationalError("CRITICAL: Can't write partition table information"

                           (name, bytes_written))

  if not CheckReread(name):

    fd = os.open("/dev/%s" % name, os.O_RDWR | os.O_SYNC)

    os.write(fd, olddata)

    os.close(fd)

                           name)

  result = ExecCommand(

    'echo ,,8e, | sfdisk /dev/%s' % name)

  if result.failed:

                           (name, result.output))

  """

  result = ExecCommand("pvcreate -yff /dev/%s1 " % name)

  if result.failed:

                           (name, result.output))

  pnames = ["'/dev/%s1'" % disk for disk in disks]

  result = ExecCommand("vgcreate -s 64MB '%s' %s" % (vgname, " ".join(pnames)))

  if result.failed:

                           (vgname, " ".join(disks), result.output))

  sysdisks = GetDiskList()

  if not sysdisks:

  sysd_free = []

  sysd_used = []

  for name, size, dev, part, used in sysdisks:

  return disklist

def BootStrap():

  """Actual main routine."""

  status, lv_count, size, free = CheckVGExists(vgname)

  if status:

    print "Done! %s: size %s GiB, disks: %s" % (vgname, size,

  else:

def main():

    BootStrap()

  except PrereqError, err:

    print >> sys.stderr, "The prerequisites for running this tool are not met."

    print >> sys.stderr, "Description: %s" % str(err)

    sys.exit(1)

  except SysconfigError, err:

    print >> sys.stderr, "Description: %s" % str(err)

    sys.exit(1)

  except ParameterError, err:

    print >> sys.stderr, "Description: %s" % str(err)

    Usage()

  except OperationalError, err:

    print >> sys.stderr, str(err)

    sys.exit(1)

  except ProgrammingError, err:

    print >> sys.stderr, "Error description: %s" % str(err)

    sys.exit(1)

  except Error, err: