Synnefo » snf-ganeti

  InitConfig(constants.CONFIG_VERSION, cluster_config, master_node_config)

  cfg = config.ConfigWriter()

  ssh.WriteKnownHostsFile(cfg, constants.SSH_KNOWN_HOSTS_FILE)

  # start the master ip

  # TODO: Review rpc call from bootstrap

  cluster_info.master_node = new_master

  # this will also regenerate the ssconf files, since we updated the

  # cluster info

  result = rpc.RpcRunner.call_node_start_master(new_master, True, no_voting)

  msg = result.fail_msg

                       " correcting: recorded %d, actual %d", idx,

                       instance.name, disk.size, size)

          disk.size = size

          changed.append((instance.name, idx, size))

        if self._EnsureChildSizes(disk):

          changed.append((instance.name, idx, disk.size))

    return changed

      cluster = self.cfg.GetClusterInfo()

      cluster.cluster_name = clustername

      cluster.master_ip = ip

      # update the known hosts file

      ssh.WriteKnownHostsFile(self.cfg, constants.SSH_KNOWN_HOSTS_FILE)

      # we need to update the pool size here, otherwise the save will fail

      _AdjustCandidatePool(self, [])

def _RedistributeAncillaryFiles(lu, additional_nodes=None):

    dist_nodes.extend(additional_nodes)

  if myself.name in dist_nodes:

    dist_nodes.remove(myself.name)

  # 2. Gather files to distribute

  dist_files = set([constants.ETC_HOSTS,

                    constants.SSH_KNOWN_HOSTS_FILE,

    """Redistribute the configuration.

    """

    _RedistributeAncillaryFiles(self)

      _RedistributeAncillaryFiles(self)

      self.context.ReaddNode(new_node)

      # make sure we redistribute the config

      # and make sure the new node will not have old files around

      if not new_node.master_candidate:

        result = self.rpc.call_node_demote_from_mc(new_node.name)

          result.append(("offline", "clear offline status due to drain"))

    # this will trigger configuration file update, if needed

    # this will trigger job queue propagation or cleanup

    if changed_mc:

      self.context.ReaddNode(node)

    if self.op.os_type is not None:

      feedback_fn("Changing OS to '%s'..." % self.op.os_type)

      inst.os = self.op.os_type

    _StartInstanceDisks(self, inst, None)

    try:

    instance.primary_node = target_node

    # distribute new instance config to the other nodes

    # Only start the instance if it's marked as up

    if instance.admin_up:

                                 (",".join(errs),))

    instance.primary_node = target_node

    self.LogInfo("Removing the disks on the original node")

    _RemoveDisks(self, instance, target_node=source_node)

      self.feedback_fn("* instance running on secondary node (%s),"

                       " updating config" % target_node)

      instance.primary_node = target_node

      demoted_node = source_node

    else:

      self.feedback_fn("* instance confirmed to be running on its"

    instance.primary_node = target_node

    # distribute new instance config to the other nodes

    result = self.rpc.call_finalize_migration(target_node,

                                              instance,

    if self.op.start:

      iobj.admin_up = True

      logging.info("Starting instance %s on node %s", instance, pnode_name)

      feedback_fn("* starting instance...")

      result = self.rpc.call_instance_start(pnode_name, iobj, None, None)

    try:

      # Should we replace the secondary node?

      if self.new_node is not None:

      else:

    finally:

      # Deactivate the instance disks if we're replacing them on a down instance

          self.lu.LogWarning("Can't remove old LV: %s" % msg,

                             hint="remove unused LVs manually")

    """Replace a disk on the primary or secondary for DRBD 8.

    The algorithm for replace is quite complicated:

      dev.children = new_lvs

    # Wait for sync

    # This can fail as the old devices are degraded and _WaitForSync

    self.lu.LogStep(6, steps_total, "Removing old storage")

    self._RemoveOldStorage(self.target_node, iv_names)

    """Replace the secondary node for DRBD 8.

    The algorithm for replace is quite complicated:

      dev.logical_id = new_logical_id

      self.cfg.SetDiskID(dev, self.instance.primary_node)

    # and now perform the drbd attach

    self.lu.LogInfo("Attaching primary drbds to new secondary"

      result = self.rpc.call_blockdev_grow(node, disk, self.op.amount)

      result.Raise("Grow request failed to node %s" % node)

    disk.RecordGrow(self.op.amount)

    if self.op.wait_for_sync:

      disk_abort = not _WaitForSync(self, instance)

      if disk_abort:

      for key, val in self.op.beparams.iteritems():

        result.append(("be/%s" % key, val))

    return result

    except errors.TagError, err:

      raise errors.OpExecError("Error while setting tag: %s" % str(err))

    try:

    except errors.ConfigurationError:

      raise errors.OpRetryError("There has been a modification to the"

                                " config file and the operation has been"

    for tag in self.op.tags:

      self.target.RemoveTag(tag)

    try:

    except errors.ConfigurationError:

      raise errors.OpRetryError("There has been a modification to the"

                                " config file and the operation has been"

    if modified:

      self._WriteConfig()

    """Distribute the configuration to the other nodes.

    Currently, this only copies the configuration file. In the future,

    """

    if self._offline:

      return True

    bad = False

    node_list = []

        msg = ("Copy of file %s to node %s failed: %s" %

               (self._cfg_file, to_node, msg))

        logging.error(msg)

        bad = True

    return not bad

    """Write the configuration data to persistent storage.

    """

    # first, cleanup the _temporary_ids set, if an ID is now in the

    # other objects it should be discarded to prevent unbounded growth

    # of that structure

    self.write_count += 1

    # and redistribute the config file to master candidates

    # Write ssconf files on all nodes (including locally)

    if self._last_cluster_serial < self._config_data.cluster.serial_no:

        result = rpc.RpcRunner.call_write_ssconf_files(

          self._UnlockedGetNodeList(),

          self._UnlockedGetSsconfValues())

        for nname, nresu in result.items():

          msg = nresu.fail_msg

          if msg:

      self._last_cluster_serial = self._config_data.cluster.serial_no

  def _UnlockedGetSsconfValues(self):

    return self._config_data.cluster

  @locking.ssynchronized(_config_lock)

    """Notify function to be called after updates.

    This function must be called when an object (as returned by

    @param target: an instance of either L{objects.Cluster},

        L{objects.Node} or L{objects.Instance} which is existing in

        the cluster

    """

    if self._config_data is None:

      for nic in target.nics:

        self._temporary_macs.discard(nic.mac)

    # construct a fake cluster object

    fake_cl = objects.Cluster()

    # fail if we didn't read the config

    cl = cfg.GetClusterInfo()

    # first pass, must not fail

    # second pass, also must not fail (after the config has been written)

    # but the fake_cl update should still fail

  def testUpdateNode(self):

    """Test updates on one node object"""

    # construct a fake node

    fake_node = objects.Node()

    # fail if we didn't read the config

    node = cfg.GetNodeInfo(cfg.GetNodeList()[0])

    # first pass, must not fail

    # second pass, also must not fail (after the config has been written)

    # but the fake_node update should still fail

  def testUpdateInstance(self):

    """Test updates on one instance object"""

    inst = self._create_instance()

    fake_instance = objects.Instance()

    # fail if we didn't read the config

    cfg.AddInstance(inst)

    instance = cfg.GetInstanceInfo(cfg.GetInstanceList()[0])

    # first pass, must not fail

    # second pass, also must not fail (after the config has been written)

    # but the fake_instance update should still fail

  def testNICParameterSyntaxCheck(self):

    """Test the NIC's CheckParameterSyntax function"""