Synnefo » snf-ganeti

	test/py/cmdlib \

	test/py/cmdlib/testsupport \

	$(python_test_support) \

	test/py/cmdlib/test_unittest.py \

python_test_support = \

	test/py/__init__.py \

	test/py/lockperf.py \

	test/py/testutils.py \

	test/py/mocks.py \

	test/py/cmdlib/__init__.py \

	test/py/cmdlib/testsupport/__init__.py \

	test/py/cmdlib/testsupport/cmdlib_testcase.py \

	test/py/cmdlib/testsupport/config_mock.py \

	test/py/cmdlib/testsupport/iallocator_mock.py \

	test/py/cmdlib/testsupport/lock_manager_mock.py \

	test/py/cmdlib/testsupport/processor_mock.py \

	test/py/cmdlib/testsupport/rpc_runner_mock.py

	PYTHONPATH=.:./test/py \

all_python_code += $(python_test_support)

      if not utils.TestDelay(self.op.duration)[0]:

class ConfigWriter(object):

class GanetiLockManager(object):

#

#

# Copyright (C) 2013 Google Inc.

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful, but

# WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

# General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

# 02110-1301, USA.

"""This module contains all python test code"""

#

#

# Copyright (C) 2013 Google Inc.

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful, but

# WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

# General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

# 02110-1301, USA.

"""This module contains all cmdlib unit tests"""

#!/usr/bin/python

#

# Copyright (C) 2013 Google Inc.

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful, but

# WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

# General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

# 02110-1301, USA.

"""Tests for LUTest*

"""

from ganeti import constants

from ganeti import errors

from ganeti import opcodes

from testsupport import *

import testutils

DELAY_DURATION = 0.01

class TestLUTestDelay(CmdlibTestCase):

  def testRepeatedInvocation(self):

    op = opcodes.OpTestDelay(duration=DELAY_DURATION,

                             repeat=3)

    self.ExecOpCode(op)

    self.assertLogContainsMessage(" - INFO: Test delay iteration 0/2")

    self.mcpu.assertLogContainsEntry(constants.ELOG_MESSAGE,

                                     " - INFO: Test delay iteration 1/2")

    self.assertLogContainsRegex("2/2$")

  def testInvalidDuration(self):

    op = opcodes.OpTestDelay(duration=-1)

    self.assertRaises(errors.OpExecError, self.ExecOpCode, op)

  def testOnNodeUuid(self):

    node_uuids = [self.cfg.GetMasterNode()]

    op = opcodes.OpTestDelay(duration=DELAY_DURATION,

                             on_node_uuids=node_uuids)

    self.ExecOpCode(op)

    self.rpc.call_test_delay.assert_called_once_with(node_uuids, DELAY_DURATION)

  def testOnNodeName(self):

    op = opcodes.OpTestDelay(duration=DELAY_DURATION,

                             on_nodes=[self.cfg.GetMasterNodeName()])

    self.ExecOpCode(op)

    self.rpc.call_test_delay.assert_called_once_with([self.cfg.GetMasterNode()],

                                                     DELAY_DURATION)

  def testSuccessfulRpc(self):

    op = opcodes.OpTestDelay(duration=DELAY_DURATION,

                             on_nodes=[self.cfg.GetMasterNodeName()])

    self.rpc.call_test_delay.return_value = \

      RpcResultsBuilder(cfg=self.cfg) \

        .AddSuccessfulNode(self.cfg.GetMasterNode()) \

        .Build()

    self.ExecOpCode(op)

    self.rpc.call_test_delay.assert_called_once()

  def testFailingRpc(self):

    op = opcodes.OpTestDelay(duration=DELAY_DURATION,

                             on_nodes=[self.cfg.GetMasterNodeName()])

    self.rpc.call_test_delay.return_value = \

      RpcResultsBuilder(cfg=self.cfg) \

        .AddFailedNode(self.cfg.GetMasterNode()) \

        .Build()

    self.assertRaises(errors.OpExecError, self.ExecOpCode, op)

  def testMultipleNodes(self):

    node1 = self.cfg.AddNewNode()

    node2 = self.cfg.AddNewNode()

    op = opcodes.OpTestDelay(duration=DELAY_DURATION,

                             on_nodes=[node1.name, node2.name])

    self.rpc.call_test_delay.return_value = \

      RpcResultsBuilder(cfg=self.cfg) \

        .AddSuccessfulNode(node1) \

        .AddSuccessfulNode(node2) \

        .Build()

    self.ExecOpCode(op)

    self.rpc.call_test_delay.assert_called_once_with([node1.uuid, node2.uuid],

                                                     DELAY_DURATION)

if __name__ == "__main__":

  testutils.GanetiTestProgram()

#

#

# Copyright (C) 2013 Google Inc.

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful, but

# WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

# General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

# 02110-1301, USA.

"""Support classes and functions for testing the cmdlib module.

"""

from cmdlib_testcase import CmdlibTestCase

from config_mock import ConfigMock

from iallocator_mock import CreateIAllocatorMock

from lock_manager_mock import LockManagerMock

from processor_mock import ProcessorMock

from rpc_runner_mock import CreateRpcRunnerMock, RpcResultsBuilder

__all__ = ["CmdlibTestCase",

           "ConfigMock",

           "CreateIAllocatorMock",

           "CreateRpcRunnerMock",

           "LockManagerMock",

           "ProcessorMock",

           "RpcResultsBuilder",

          ]

#

#

# Copyright (C) 2013 Google Inc.

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful, but

# WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

# General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

# 02110-1301, USA.

from config_mock import *

from iallocator_mock import *

from lock_manager_mock import *

from processor_mock import *

from rpc_runner_mock import *

import testutils

class GanetiContextMock(object):

  def __init__(self, cfg, glm, rpc):

    self.cfg = cfg

    self.glm = glm

    self.rpc = rpc

class CmdlibTestCase(testutils.GanetiTestCase):

  """Base class for cmdlib tests.

  This class sets up a mocked environment for the execution of

  L{ganeti.cmdlib.base.LogicalUnit} subclasses.

  The environment can be customized via the following fields:

    * C{cfg}: @see L{ConfigMock}

    * C{glm}: @see L{LockManagerMock}

    * C{rpc}: @see L{CreateRpcRunnerMock}

    * C{iallocator}: @see L{CreateIAllocatorMock}

    * C{mcpu}: @see L{ProcessorMock}

  """

  def setUp(self):

    super(CmdlibTestCase, self).setUp()

    self.cfg = ConfigMock()

    self.glm = LockManagerMock()

    self.rpc = CreateRpcRunnerMock()

    self.iallocator = CreateIAllocatorMock()

    ctx = GanetiContextMock(self.cfg, self.glm, self.rpc)

    self.mcpu = ProcessorMock(ctx)

  def tearDown(self):

    super(CmdlibTestCase, self).tearDown()

  def ExecOpCode(self, opcode):

    """Executes the given opcode.

    @param opcode: the opcode to execute

    @return: the result of the LU's C{Exec} method

    """

    self.glm.AddLocksFromConfig(self.cfg)

    return self.mcpu.ExecOpCodeAndRecordOutput(opcode)

  def assertLogContainsMessage(self, expected_msg):

    """Shortcut for L{ProcessorMock.assertLogContainsMessage}

    """

    self.mcpu.assertLogContainsMessage(expected_msg)

  def assertLogContainsRegex(self, expected_regex):

    """Shortcut for L{ProcessorMock.assertLogContainsRegex}

    """

    self.mcpu.assertLogContainsRegex(expected_regex)

#

#

# Copyright (C) 2013 Google Inc.

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful, but

# WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

# General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

# 02110-1301, USA.

import uuid

from ganeti import config

from ganeti import constants

from ganeti import objects

import mocks

def _StubGetEntResolver():

  return mocks.FakeGetentResolver()

class ConfigMock(config.ConfigWriter):

  """A mocked cluster configuration with added methods for easy customization.

  """

  def __init__(self):

    self._cur_group_id = 1

    self._cur_node_id = 1

    self._cur_inst_id = 1

    super(ConfigMock, self).__init__(cfg_file="/dev/null",

                                     _getents=_StubGetEntResolver())

  def _GetUuid(self):

    return str(uuid.uuid4())

  def AddNewNodeGroup(self,

                      uuid=None,

                      name=None,

                      ndparams=None,

                      diskparams=None,

                      ipolicy=None,

                      hv_state_static=None,

                      disk_state_static=None,

                      alloc_policy=None,

                      networks=[]):

    """Add a new L{objects.NodeGroup} to the cluster configuration

    See L{objects.NodeGroup} for parameter documentation.

    @rtype: L{objects.NodeGroup}

    @return: the newly added node group

    """

    group_id = self._cur_group_id

    self._cur_group_id += 1

    if uuid is None:

      uuid = self._GetUuid()

    if name is None:

      name = "mock_group_%d" % group_id

    group = objects.NodeGroup(uuid=uuid,

                              name=name,

                              ndparams=ndparams,

                              diskparams=diskparams,

                              ipolicy=ipolicy,

                              hv_state_static=hv_state_static,

                              disk_state_static=disk_state_static,

                              alloc_policy=alloc_policy,

                              networks=networks,

                              members=[])

    self.AddNodeGroup(group, None)

    return group

  def AddNewNode(self,

                 uuid=None,

                 name=None,

                 primary_ip=None,

                 secondary_ip=None,

                 master_candidate=True,

                 offline=False,

                 drained=False,

                 group=None,

                 master_capable=True,

                 vm_capable=True,

                 ndparams=None,

                 powered=True,

                 hv_state=None,

                 hv_state_static=None,

                 disk_state=None,

                 disk_state_static=None):

    """Add a new L{objects.Node} to the cluster configuration

    See L{objects.Node} for parameter documentation.

    @rtype: L{objects.Node}

    @return: the newly added node

    """

    node_id = self._cur_node_id

    self._cur_node_id += 1

    if uuid is None:

      uuid = self._GetUuid()

    if name is None:

      name = "mock_node_%d.example.com" % node_id

    if primary_ip is None:

      primary_ip = "192.168.0.%d" % node_id

    if secondary_ip is None:

      secondary_ip = "192.168.1.%d" % node_id

    if group is None:

      group = self._default_group.uuid

    if isinstance(group, objects.NodeGroup):

      group = group.uuid

    node = objects.Node(uuid=uuid,

                        name=name,

                        primary_ip=primary_ip,

                        secondary_ip=secondary_ip,

                        master_candidate=master_candidate,

                        offline=offline,

                        drained=drained,

                        group=group,

                        master_capable=master_capable,

                        vm_capable=vm_capable,

                        ndparams=ndparams,

                        powered=powered,

                        hv_state=hv_state,

                        hv_state_static=hv_state_static,

                        disk_state=disk_state,

                        disk_state_static=disk_state_static)

    self.AddNode(node, None)

    return node

  def AddNewInstance(self,

                     uuid=None,

                     name=None,

                     primary_node=None,

                     os="mocked_os",

                     hypervisor=constants.HT_FAKE,

                     hvparams={},

                     beparams={},

                     osparams={},

                     admin_state=constants.ADMINST_DOWN,

                     nics=[],

                     disks=[],

                     disk_template=constants.DT_DISKLESS,

                     disks_active=False,

                     network_port=None):

    """Add a new L{objects.Instance} to the cluster configuration

    See L{objects.Instance} for parameter documentation.

    @rtype: L{objects.Instance}

    @return: the newly added instance

    """

    inst_id = self._cur_inst_id

    self._cur_inst_id += 1

    if uuid is None:

      uuid = self._GetUuid()

    if name is None:

      name = "mock_inst_%d.example.com" % inst_id

    if primary_node is None:

      primary_node = self._master_node.uuid

    if isinstance(primary_node, objects.Node):

      primary_node = self._master_node.uuid

    inst = objects.Instance(uuid=uuid,

                            name=name,

                            primary_node=primary_node,

                            os=os,

                            hypervisor=hypervisor,

                            hvparams=hvparams,

                            beparams=beparams,

                            osparams=osparams,

                            admin_state=admin_state,

                            nics=nics,

                            disks=disks,

                            disk_template=disk_template,

                            disks_active=disks_active,

                            network_port=network_port)

    self.AddInstance(inst, None)

    return inst

  def _OpenConfig(self, accept_foreign):

    self._config_data = objects.ConfigData(

      version=constants.CONFIG_VERSION,

      cluster=None,

      nodegroups={},

      nodes={},

      instances={},

      networks={})

    master_node_uuid = self._GetUuid()

    self._cluster = objects.Cluster(

      serial_no=1,

      rsahostkeypub="",

      highest_used_port=(constants.FIRST_DRBD_PORT - 1),

      mac_prefix="aa:00:00",

      volume_group_name="xenvg",

      drbd_usermode_helper="/bin/true",

      nicparams={constants.PP_DEFAULT: constants.NICC_DEFAULTS},

      ndparams=constants.NDC_DEFAULTS,

      tcpudp_port_pool=set(),

      enabled_hypervisors=[constants.HT_FAKE],

      master_node=master_node_uuid,

      master_ip="192.168.0.254",

      master_netdev=constants.DEFAULT_BRIDGE,

      cluster_name="cluster.example.com",

      file_storage_dir="/tmp",

      uid_pool=[],

      )

    self._config_data.cluster = self._cluster

    self._default_group = self.AddNewNodeGroup(name="default")

    self._master_node = self.AddNewNode(uuid=master_node_uuid)

  def _WriteConfig(self, destination=None, feedback_fn=None):

    pass

  def _DistributeConfig(self, feedback_fn):

    pass

  def _GetRpc(self, address_list):

    raise NotImplementedError

#

#

# Copyright (C) 2013 Google Inc.

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful, but

# WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

# General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

# 02110-1301, USA.

import mock

from ganeti.masterd import iallocator

def CreateIAllocatorMock():

  """Creates a new L{mock.MagicMock} tailored for L{iallocator.IAllocator}

  """

  ret = mock.MagicMock(spec=iallocator.IAllocator)

  return ret

#

#

# Copyright (C) 2013 Google Inc.

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful, but

# WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

# General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

# 02110-1301, USA.

from ganeti import locking

class LockManagerMock(locking.GanetiLockManager):

  """Mocked lock manager for tests.

  """

  def __init__(self):

    # reset singleton instance, there is a separate lock manager for every test

    self.__class__._instance = None

    super(LockManagerMock, self).__init__([], [], [], [])

  def AddLocksFromConfig(self, cfg):

    """Create locks for all entities in the given configuration.

    @type cfg: ganeti.config.ConfigWriter

    """

    try:

      self.acquire(locking.LEVEL_CLUSTER, locking.BGL)

      for node_uuid in cfg.GetNodeList():

        self.add(locking.LEVEL_NODE, node_uuid)

        self.add(locking.LEVEL_NODE_RES, node_uuid)

      for group_uuid in cfg.GetNodeGroupList():

        self.add(locking.LEVEL_NODEGROUP, group_uuid)

      for inst in cfg.GetAllInstancesInfo().values():

        self.add(locking.LEVEL_INSTANCE, inst.name)

      for net_uuid in cfg.GetNetworkList():

        self.add(locking.LEVEL_NETWORK, net_uuid)

    finally:

      self.release(locking.LEVEL_CLUSTER, locking.BGL)

#

#

# Copyright (C) 2013 Google Inc.

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful, but

# WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

# General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

# 02110-1301, USA.

import re

from ganeti import constants

from ganeti import mcpu

class LogRecordingCallback(mcpu.OpExecCbBase):

  """Helper class for log output recording.

  """

  def __init__(self, processor):

    self.processor = processor

  def Feedback(self, *args):

    assert len(args) < 3

    if len(args) == 1:

      log_type = constants.ELOG_MESSAGE

      log_msg = args[0]

    else:

      (log_type, log_msg) = args

    self.processor.log_entries.append((log_type, log_msg))

class ProcessorMock(mcpu.Processor):

  """Mocked opcode processor for tests.

  This class actually performs much more than a mock, as it drives the

  execution of LU's. But it also provides access to the log output of the LU

  the result of the execution.

  See L{ExecOpCodeAndRecordOutput} for the main method of this class.

  """

  def __init__(self, context):

    super(ProcessorMock, self).__init__(context, 0, True)

    self.log_entries = []

  def ExecOpCodeAndRecordOutput(self, op):

    """Executes the given opcode and records the output for further inspection.

    @param op: the opcode to execute.

    @return: see L{mcpu.Processor.ExecOpCode}

    """

    return self.ExecOpCode(op, LogRecordingCallback(self))

  def GetLogEntries(self):

    """Return the list of recorded log entries.

    @rtype: list of (string, string) tuples

    @return: the list of recorded log entries

    """

    return self.log_entries

  def GetLogMessages(self):

    """Return the list of recorded log messages.

    @rtype: list of string

    @return: the list of recorded log messages

    """

    return [msg for _, msg in self.log_entries]

  def GetLogEntriesString(self):

    """Return a string with all log entries separated by a newline.

    """

    return "\n".join("%s: %s" % (type, msg)

                     for type, msg in self.GetLogEntries())

  def GetLogMessagesString(self):

    """Return a string with all log messages separated by a newline.

    """

    return "\n".join("%s" % msg for _, msg in self.GetLogEntries())

  def assertLogContainsEntry(self, expected_type, expected_msg):

    """Asserts that the log contains the exact given entry.

    @type expected_type: string

    @param expected_type: the expected type

    @type expected_msg: string

    @param expected_msg: the expected message

    """

    for type, msg in self.log_entries:

      if type == expected_type and msg == expected_msg:

        return

    raise AssertionError(

      "Could not find '%s' (type '%s') in LU log messages. Log is:\n%s" %

      (expected_msg, expected_type, self.GetLogEntriesString()))

  def assertLogContainsMessage(self, expected_msg):

    """Asserts that the log contains the exact given message.

    @type expected_msg: string

    @param expected_msg: the expected message

    """

    for msg in self.GetLogMessages():

      if msg == expected_msg:

        return

    raise AssertionError(

      "Could not find '%s' in LU log messages. Log is:\n%s" %

      (expected_msg, self.GetLogMessagesString()))

  def assertLogContainsRegex(self, expected_regex):

    """Asserts that the log contains a message which matches the regex.

    @type expected_regex: string

    @param expected_regex: regular expression to match messages with.

    """

    for msg in self.GetLogMessages():

      if re.search(expected_regex, msg) is not None:

        return

    raise AssertionError(

      "Could not find '%s' in LU log messages. Log is:\n%s" %

      (expected_regex, self.GetLogMessagesString())

    )

#

#

# Copyright (C) 2013 Google Inc.

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful, but

# WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

# General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

# 02110-1301, USA.

import mock

from ganeti import objects

from ganeti import rpc

def CreateRpcRunnerMock():

  """Creates a new L{mock.MagicMock} tailored for L{rpc.RpcRunner}

  """

  ret = mock.MagicMock(spec=rpc.RpcRunner)

  return ret

class RpcResultsBuilder(object):

  """Helper class which assists in constructing L{rpc.RpcResult} objects.

  This class provides some convenience methods for constructing L{rpc.RpcResult}

  objects. It is possible to create single results with the C{Create*} methods

  or to create multi-node results by repeatedly calling the C{Add*} methods and

  then obtaining the final result with C{Build}.

  The C{node} parameter of all the methods can either be a L{objects.Node}

  object, a node UUID or a node name. You have to provide the cluster config

  in the constructor if you want to use node UUID's/names.

  A typical usage of this class is as follows::

    self.rpc.call_some_rpc.return_value = \

      RpcResultsBuilder(cfg=self.cfg) \

        .AddSuccessfulNode(node1,

                           {

                             "result_key": "result_data",

                             "another_key": "other_data",

                           }) \

        .AddErrorNode(node2) \

        .Build()

  """

  def __init__(self, cfg=None, use_node_names=False):

    """Constructor.

    @type cfg: L{ganeti.config.ConfigWriter}

    @param cfg: used to resolve nodes if not C{None}

    @type use_node_names: bool

    @param use_node_names: if set to C{True}, the node field in the RPC results

          will contain the node name instead of the node UUID.

    """

    self._cfg = cfg

    self._use_node_names = use_node_names

    self._results = []

  def _GetNode(self, node_id):

    if isinstance(node_id, objects.Node):

      return node_id

    node = None

    if self._cfg is not None:

      node = self._cfg.GetNodeInfo(node_id)

      if node is None:

        node = self._cfg.GetNodeInfoByName(node_id)

    assert node is not None, "Failed to find '%s' in configuration" % node_id

    return node

  def _GetNodeId(self, node_id):

    node = self._GetNode(node_id)

    if self._use_node_names:

      return node.name

    else:

      return node.uuid

  def CreateSuccessfulNodeResult(self, node, data={}):

    """@see L{RpcResultsBuilder}

    @param node: @see L{RpcResultsBuilder}.

    @type data: dict

    @param data: the data as returned by the RPC

    @rtype: L{rpc.RpcResult}

    """

    return rpc.RpcResult(data=(True, data), node=self._GetNodeId(node))

  def CreateFailedNodeResult(self, node):

    """@see L{RpcResultsBuilder}

    @param node: @see L{RpcResultsBuilder}.

    @rtype: L{rpc.RpcResult}

    """

    return rpc.RpcResult(failed=True, node=self._GetNodeId(node))

  def CreateOfflineNodeResult(self, node):

    """@see L{RpcResultsBuilder}

    @param node: @see L{RpcResultsBuilder}.

    @rtype: L{rpc.RpcResult}

    """

    return rpc.RpcResult(failed=True, node=self._GetNodeId(node))

  def CreateErrorNodeResult(self, node, error_msg=None):

    """@see L{RpcResultsBuilder}

    @param node: @see L{RpcResultsBuilder}.

    @type error_msg: string

    @param error_msg: the error message as returned by the RPC

    @rtype: L{rpc.RpcResult}

    """

    return rpc.RpcResult(data=(False, error_msg), node=self._GetNodeId(node))

  def AddSuccessfulNode(self, node, data={}):

    """@see L{CreateSuccessfulNode}"""

    self._results.append(self.CreateSuccessfulNodeResult(node, data))

    return self

  def AddFailedNode(self, node):

    """@see L{CreateFailedNode}"""

    self._results.append(self.CreateFailedNodeResult(node))

    return self

  def AddOfflineNode(self, node):

    """@see L{CreateOfflineNode}"""

    self._results.append(self.CreateOfflineNodeResult(node))

  def AddErrorNode(self, node, error_msg=None):

    """@see L{CreateErrorNode}"""

    self._results.append(self.CreateErrorNodeResult(node, error_msg=error_msg))

  def Build(self):

    """Creates a dictionary holding multi-node results

    @rtype: dict

    """

    return dict((result.node, result) for result in self._results)