Synnefo » snf-ganeti

  be left

variables. Different operations will have sligthly different

environments, but most of the variables are common.

also a dict having three keys:

success

info

  a string with information from the scripts; if the allocation fails,

def GetNodeInfo(vgname, hypervisor_type):

  @type vgname: C{string}

  @param vgname: the name of the volume group to ask for disk space information

def GetInstanceInfo(instance, hname):

  @type instance: string

  @param instance: the instance name

def _GetVGInfo(vg_name):

  @type vg_name: str

  @param vg_name: the volume group which we query

    msg = "Failed to accept instance"

    logging.exception(msg)

    return (False, '%s: %s' % (msg, err))

def FinalizeMigration(instance, info, success):

    msg = "Failed to migrate instance"

    logging.exception(msg)

    return (False, "%s: %s" % (msg, err))

def BlockdevCreate(disk, size, owner, on_primary, info):

def BlockdevShutdown(disk):

  """Shut down a block device.

  the device is shutdown. Then the children of the device are

  shutdown.

def _RecursiveFindBD(disk):

  """Check if a device is activated.

  @type disk: L{objects.Disk}

  @param disk: the disk object we need to find

def BlockdevFind(disk):

  """Check if a device is activated.

  @type disk: L{objects.Disk}

  @param disk: the disk to find

  @param file_storage_dir: the directory we should cleanup

  @rtype: tuple (success,)

  @return: tuple of one element, C{success}, denoting

  """

  file_storage_dir = _TransformFileStorageDir(file_storage_dir)

    """Remove this device.

    This makes sense only for some of the device types: LV and file

    can't be completed.

    """

  def Assemble(self):

    """Assemble the device.

    use, as there were cases when xenvg was not active after boot

    (also possibly after disk issues).

    If sync_percent is None, it means all is ok

    the time needed, otherwise it's the time left in seconds.

    We set the is_degraded parameter to True on two conditions:

    network not connected or local disk missing.

    disk or not.

    @rtype: tuple

    ever_disconnected = _IgnoreError(self._ShutdownNet, self.minor)

    timeout_limit = time.time() + self._NET_RECONFIG_TIMEOUT

    while time.time() < timeout_limit:

      status = self.GetProcStatus()

      if status.is_standalone:

        break

      # retry the disconnect, it seems possible that due to a

      # well-time disconnect on the peer, my disconnect command might

      ever_disconnected = _IgnoreError(self._ShutdownNet, self.minor) or \

                          ever_disconnected

      time.sleep(sleep_time)

  def Shutdown(self):

    """Shutdown the device.

    the file on shutdown.

    """

  @type node_list: list

  @param node_list: the list of nodes to query for master info; the current

  @rtype: list

  @return: list of (node, votes)

def _ParseArgs(argv, commands, aliases):

  """Parser for the command line arguments.

  must be executed together with its (modified) arguments.

  @param argv: the command line

    choices = [('y', True, 'Perform the operation'),

               ('n', False, 'Do not perform the operation')]

  if not choices or not isinstance(choices, list):

  for entry in choices:

    if not isinstance(entry, tuple) or len(entry) < 3 or entry[0] == '?':

  answer = choices[-1][1]

  new_text = []

  except (errors.GenericError, luxi.ProtocolError,

          JobSubmittedException), err:

    result, err_msg = FormatError(err)

    ToStderr(err_msg)

  return result

  def __init__(self, processor, op, context, rpc):

    """Constructor for LogicalUnit.

    validity.

    """

    CheckPrereq, doing these separate is better because:

      - ExpandNames is left as as purely a lock-related function

        waited for them)

    The function is allowed to change the self.op attribute so that

  @param nics: list of tuples (ip, bridge, mac) representing

      the NICs the instance  has

  @type disk_template: string

  @type disks: list

  @param disks: the list of (size, mode) pairs

  @type bep: dict

def _CheckInstanceBridgesExist(lu, instance):

  """

  brlist = [nic.bridge for nic in instance.nics]

  result = lu.rpc.call_bridges_exist(instance.primary_node, brlist)

  result.Raise()

    This checks whether the cluster is empty.

    """

    master = self.cfg.GetMasterNode()

    Test list:

      - compares ganeti version

      - checks config file checksum

      - checks ssh to other nodes

          if bep[constants.BE_AUTO_BALANCE]:

            needed_mem += bep[constants.BE_MEMORY]

        if nodeinfo['mfree'] < needed_mem:

                      " failovers should node %s fail" % (node, prinode))

          bad = True

    return bad

  def BuildHooksEnv(self):

    """Build hooks env.

    the output be logged in the verify output and the verification to fail.

    """

    return not bad

  def HooksCallBack(self, phase, hooks_results, feedback_fn, lu_result):

    This method analyses the hook result, handles it, and sends some

    nicely-formatted feedback back to the user.

  @type disk: L{objects.Disk}

  @param disk: the disk to check

  @return: boolean indicating whether a LD_LV dev_type was found or not

  """

     - it does not have primary or secondary instances

     - it's not the master

    """

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

     - it is resolvable

     - its parameters (single/dual homed) matches the cluster

    """

    node_name = self.op.node_name

        raise errors.OpPrereqError("The master has a private ip but the"

                                   " new node doesn't have one")

    if not utils.TcpPing(primary_ip, constants.DEFAULT_NODED_PORT):

      raise errors.OpPrereqError("Node not reachable by ping")

    _CheckNodeOnline(self, instance.primary_node)

    bep = self.cfg.GetClusterInfo().FillBE(instance)

    _CheckInstanceBridgesExist(self, instance)

    remote_info = self.rpc.call_instance_info(instance.primary_node,

    _CheckNodeOnline(self, instance.primary_node)

    _CheckInstanceBridgesExist(self, instance)

  def Exec(self, feedback_fn):

      self.LogInfo("Not checking memory on the secondary node as"

                   " instance will not be started")

    brlist = [nic.bridge for nic in instance.nics]

    result = self.rpc.call_bridges_exist(target_node, brlist)

    result.Raise()

                         instance.name, i_be[constants.BE_MEMORY],

                         instance.hypervisor)

    brlist = [nic.bridge for nic in instance.nics]

    result = self.rpc.call_bridges_exist(target_node, brlist)

    if result.failed or not result.data:

    # remove it from its current node. In the future we could fix this by:

    #  - making a tasklet to search (share-lock all), then create the new one,

    #    then one to remove, after

    self.needed_locks[locking.LEVEL_NODE] = locking.ALL_SET

  def DeclareLocks(self, level):

                                    self._config_data.instances.keys())

  def _UnlockedGetInstanceInfo(self, instance_name):

    This function is for internal use, when the config lock is already held.

  @locking.ssynchronized(_config_lock, shared=1)

  def GetInstanceInfo(self, instance_name):

    an instance are taken from the live systems.

    @param instance_name: name of the instance, e.g.

  @locking.ssynchronized(_config_lock, shared=1)

  def GetClusterInfo(self):

    @rtype: L{objects.Cluster}

    @return: the cluster object

  def HasMessageBody(self):

    """Checks whether the HTTP message contains a body.

    """

    return bool(self._msg.body)

  def ParseStartLine(self, start_line):

    """Parses the start line of a message.

    @type start_line: string

    @param start_line: Start line string

  def GetAuthRealm(self, req):

    """Returns the authentication realm for a request.

    different paths. Returning "None" means no authentication is needed for a

    request.

  def Authenticate(self, req, user, password):

    """Checks the password for a user.

    """

    raise NotImplementedError()

  def PreHandleRequest(self, req):

    """Called before handling a request.

    """

  def HandleRequest(self, req):

    """Handles a request.

    """

    raise NotImplementedError()

class _QueuedOpCode(object):

  @ivar log: holds the execution log and consists of tuples

  of the form C{(log_serial, timestamp, level, message)}

    """Selectively returns the log entries.

    @type newer_than: None or int

        otherwise return only the log entries with serial higher

        than this value

    @rtype: list

class JobQueue(object):

  @cvar _RE_JOB_FILE: regex matching the valid job file names

    Since we aim to keep consistency should this node (the current

    master) fail, we will log errors if our rpc fail, and especially

    @param result: the data as returned from the rpc call

    @type nodes: list

    and in the future we might merge them.

    @type drain_flag: boolean

    """

    if drain_flag:

# Whenever we want to acquire a full LockSet we pass None as the value

ALL_SET = None

class GanetiLockManager:

  """The Ganeti Locking Library

  in a central place, while at the same time doing dynamic checks against

  possible deadlocks. It will also make it easier to transition to a different

  lock type should we migrate away from python threads.

    """Acquire a set of resource locks, at the same level.

    @param level: the level at which the locks shall be acquired;

    @param names: the names of the locks which shall be acquired

        (special lock names, or instance/node names)

    @param shared: whether to acquire in shared mode; by default

    mode, before releasing them.

    @param level: the level at which the locks shall be released;

    @param names: the names of the locks which shall be released

        (defaults to all the locks acquired at that level)

    """Add locks at the specified level.

    @param level: the level at which the locks shall be added;

    @param names: names of the locks to acquire

    @param acquired: whether to acquire the newly added locks

    @param shared: whether the acquisition will be shared

      raise TimeoutError("Sending timeout: %s" % str(err))

  def Recv(self):

    In case we already have messages queued, we just return from the

    queue. Otherwise, we try to read data with a _rwtimeout network

          self.context.glm.add(level, add_locks, acquired=1, shared=share)

        except errors.LockError:

          raise errors.OpPrereqError(

            " with another job, who added them first" % add_locks)

      try:

        try:

    @type run_notifier: callable (no arguments) or None

    @param run_notifier:  this function (if callable) will be called when

                          we are about to call the lu's Exec() method, that

    """

    if not isinstance(op, opcodes.OpCode):

  calls we can't raise an exception just because one one out of many

  failed, and therefore we use this class to encapsulate the result.

  @type failed: boolean

  @ivar failed: whether the operation failed at RPC level (not

      application level on the remote node)

  list of nodes, will contact (in parallel) all nodes, and return a

  dict of results (key: node name, value: result).

  'False' result, which is not good. This overloading of values can

  cause bugs.

    @return: List of RPC results

    """

    _http_manager.ExecRequests(self.nc.values())

    @type instance: L{objects.Instance}

    @param instance: an Instance object

    @type hvp: dict or None

    @type bep: dict or None

    @rtype: dict

    @return: the instance dict, with the hvparams filled with the

        cluster defaults

    connected to).

    This is used to detect problems in ssh known_hosts files

    entries and local machine names

    @param node: nodename of a host to check; can be short or

      directory for the command; the default will be /

  @rtype: L{RunResult}

  @return: RunResult instance

  """

  if no_fork:

  @type ip: str

  @param ip: the address to be checked

  @rtype: a regular expression match object

      address is not valid

  """

  This function will check all arguments in the args list so that they

  are valid shell parameters (i.e. they don't contain shell

  template % args.

  @type template: str

  @type args: list

  @param args: list of arguments to be quoted

  @rtype: str

  """

  return ' '.join([ShellQuote(i) for i in args])

  @type port: int

  @param port: the port to connect to

  @type timeout: int

  @type live_port_needed: boolean

  @param live_port_needed: whether a closed port will cause the

      function to return failure, as if there was a timeout

  address.

  @type address: string

  @rtype: bool

  @return: True if we own the address

  @type size: None or int

  @param size: Read at most size bytes

  @rtype: str

  """

  f = open(file_name, "r")

  Element order is preserved.

  @type seq: sequence

  @rtype: list

  @return: list of unique elements from seq

def IsValidMac(mac):

  """Predicate to check if a MAC address is valid.

  accepts colon separated format.

  @type mac: str

  """

  if isinstance(text, unicode):

    text = text.encode('ascii', 'backslashreplace')

  resu = ""

  for char in text:

        discussion in <citerefentry>

        <refentrytitle>gnt-cluster</refentrytitle>

        <manvolnum>8</manvolnum> </citerefentry> for more

      </para>

      <para>

   devnum: the device number, e.g. 0x803 (2051 in decimal) for sda3

  Returns:

      SysconfigError exception

  """

def DevInfo(name, dev, mountinfo):

  Args:

    name: the device name, e.g. sda

def ShowDiskInfo(opts):

  """Shows a nicely formatted block device list for this system.

  by the other functions defined, in order to help the user make a

  choice about which disks should be allocated to our volume group.