Synnefo » snf-ganeti » ganeti-local

        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