Synnefo » snf-ganeti » ganeti-local

import os

import os.path

import time

import re

import platform

import logging

import copy

from ganeti import ssh

from ganeti import utils

from ganeti import locking

from ganeti import constants

from ganeti import objects

from ganeti import serializer

from ganeti import ssconf

def _BuildInstanceHookEnv(name, primary_node, secondary_nodes, os_type, status,

                          memory, vcpus, nics, disk_template, disks,

  """Builds instance related env variables for hooks

  This builds the hook environment from individual variables.

  @param bep: the backend parameters for the instance

  @type hvp: dict

  @param hvp: the hypervisor parameters for the instance

  @rtype: dict

  @return: the hook environment for this instance

    "INSTANCE_MEMORY": memory,

    "INSTANCE_VCPUS": vcpus,

    "INSTANCE_DISK_TEMPLATE": disk_template,

  }

  if nics:

    node_lvs = self.rpc.call_volume_list(nodes, vg_name)

    for node in nodes:

      # node_volume

      lvs = node_lvs[node]

      "master": cluster.master_node,

      "default_hypervisor": cluster.default_hypervisor,

      "enabled_hypervisors": cluster.enabled_hypervisors,

      "beparams": cluster.beparams,

      "candidate_pool_size": cluster.candidate_pool_size,

      "default_bridge": cluster.default_bridge,

  """Start the disks of an instance.

  """

                                           ignore_secondaries=force)

  if not disks_ok:

    _ShutdownInstanceDisks(lu, instance)

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

                   instance.name, target_node)

                                               ignore_secondaries=True)

      if not disks_ok:

        _ShutdownInstanceDisks(self, instance)

    logging.debug("Allocated minors %s" % (minors,))

    self.proc.LogStep(4, steps_total, "changing drbd configuration")

    for idx, (dev, new_minor) in enumerate(zip(instance.disks, minors)):

      info("activating a new drbd on %s for disk/%d" % (new_node, idx))

      # create new devices on new_node; note that we create two IDs:

      # one without port, so the drbd will be activated without

    This only checks the instance list against the existing names.

    """

    # checking the new params on the primary/secondary nodes

    """

    if call_fn is None:

      call_fn = self.lu.rpc.call_iallocator_runner

    result = call_fn(self.lu.cfg.GetMasterNode(), name, self.in_text)

    result.Raise()