Synnefo » snf-ganeti

#!/usr/bin/python

#

# Copyright (C) 2010, 2011, 2012, 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.

"""Script for testing ganeti.query"""

import re

import unittest

import random

from ganeti import constants

from ganeti import utils

from ganeti import compat

from ganeti import errors

from ganeti import query

from ganeti import objects

from ganeti import cmdlib

import ganeti.masterd.instance as gmi

from ganeti.hypervisor import hv_base

import testutils

class TestConstants(unittest.TestCase):

  def test(self):

    self.assertEqual(set(query._VERIFY_FN.keys()),

                     constants.QFT_ALL)

class _QueryData:

  def __init__(self, data, **kwargs):

    self.data = data

    for name, value in kwargs.items():

      setattr(self, name, value)

  def __iter__(self):

    return iter(self.data)

def _GetDiskSize(nr, ctx, item):

  disks = item["disks"]

  try:

    return disks[nr]

  except IndexError:

    return query._FS_UNAVAIL

class TestQuery(unittest.TestCase):

  def test(self):

    (STATIC, DISK) = range(10, 12)

    fielddef = query._PrepareFieldList([

      (query._MakeField("name", "Name", constants.QFT_TEXT, "Name"),

       STATIC, 0, lambda ctx, item: item["name"]),

      (query._MakeField("master", "Master", constants.QFT_BOOL, "Master"),

       STATIC, 0, lambda ctx, item: ctx.mastername == item["name"]),

      ] +

      [(query._MakeField("disk%s.size" % i, "DiskSize%s" % i,

                         constants.QFT_UNIT, "Disk size %s" % i),

        DISK, 0, compat.partial(_GetDiskSize, i))

       for i in range(4)], [])

    q = query.Query(fielddef, ["name"])

    self.assertEqual(q.RequestedData(), set([STATIC]))

    self.assertEqual(len(q._fields), 1)

    self.assertEqual(len(q.GetFields()), 1)

    self.assertEqual(q.GetFields()[0].ToDict(),

      objects.QueryFieldDefinition(name="name",

                                   title="Name",

                                   kind=constants.QFT_TEXT,

                                   doc="Name").ToDict())

    # Create data only once query has been prepared

    data = [

      { "name": "node1", "disks": [0, 1, 2], },

      { "name": "node2", "disks": [3, 4], },

      { "name": "node3", "disks": [5, 6, 7], },

      ]

    self.assertEqual(q.Query(_QueryData(data, mastername="node3")),

                     [[(constants.RS_NORMAL, "node1")],

                      [(constants.RS_NORMAL, "node2")],

                      [(constants.RS_NORMAL, "node3")]])

    self.assertEqual(q.OldStyleQuery(_QueryData(data, mastername="node3")),

                     [["node1"], ["node2"], ["node3"]])

    q = query.Query(fielddef, ["name", "master"])

    self.assertEqual(q.RequestedData(), set([STATIC]))

    self.assertEqual(len(q._fields), 2)

    self.assertEqual(q.Query(_QueryData(data, mastername="node3")),

                     [[(constants.RS_NORMAL, "node1"),

                       (constants.RS_NORMAL, False)],

                      [(constants.RS_NORMAL, "node2"),

                       (constants.RS_NORMAL, False)],

                      [(constants.RS_NORMAL, "node3"),

                       (constants.RS_NORMAL, True)],

                     ])

    q = query.Query(fielddef, ["name", "master", "disk0.size"])

    self.assertEqual(q.RequestedData(), set([STATIC, DISK]))

    self.assertEqual(len(q._fields), 3)

    self.assertEqual(q.Query(_QueryData(data, mastername="node2")),

                     [[(constants.RS_NORMAL, "node1"),

                       (constants.RS_NORMAL, False),

                       (constants.RS_NORMAL, 0)],

                      [(constants.RS_NORMAL, "node2"),

                       (constants.RS_NORMAL, True),

                       (constants.RS_NORMAL, 3)],

                      [(constants.RS_NORMAL, "node3"),

                       (constants.RS_NORMAL, False),

                       (constants.RS_NORMAL, 5)],

                     ])

    # With unknown column

    q = query.Query(fielddef, ["disk2.size", "disk1.size", "disk99.size",

                               "disk0.size"])

    self.assertEqual(q.RequestedData(), set([DISK]))

    self.assertEqual(len(q._fields), 4)

    self.assertEqual(q.Query(_QueryData(data, mastername="node2")),

                     [[(constants.RS_NORMAL, 2),

                       (constants.RS_NORMAL, 1),

                       (constants.RS_UNKNOWN, None),

                       (constants.RS_NORMAL, 0)],

                      [(constants.RS_UNAVAIL, None),

                       (constants.RS_NORMAL, 4),

                       (constants.RS_UNKNOWN, None),

                       (constants.RS_NORMAL, 3)],

                      [(constants.RS_NORMAL, 7),

                       (constants.RS_NORMAL, 6),

                       (constants.RS_UNKNOWN, None),

                       (constants.RS_NORMAL, 5)],

                     ])

    self.assertRaises(errors.OpPrereqError, q.OldStyleQuery,

                      _QueryData(data, mastername="node2"))

    self.assertEqual([fdef.ToDict() for fdef in q.GetFields()], [

                     { "name": "disk2.size", "title": "DiskSize2",

                       "kind": constants.QFT_UNIT, "doc": "Disk size 2", },

                     { "name": "disk1.size", "title": "DiskSize1",

                       "kind": constants.QFT_UNIT, "doc": "Disk size 1", },

                     { "name": "disk99.size", "title": "disk99.size",

                       "kind": constants.QFT_UNKNOWN,

                       "doc": "Unknown field 'disk99.size'", },

                     { "name": "disk0.size", "title": "DiskSize0",

                       "kind": constants.QFT_UNIT, "doc": "Disk size 0", },

                     ])

    # Empty query

    q = query.Query(fielddef, [])

    self.assertEqual(q.RequestedData(), set([]))

    self.assertEqual(len(q._fields), 0)

    self.assertEqual(q.Query(_QueryData(data, mastername="node2")),

                     [[], [], []])

    self.assertEqual(q.OldStyleQuery(_QueryData(data, mastername="node2")),

                     [[], [], []])

    self.assertEqual(q.GetFields(), [])

  def testPrepareFieldList(self):

    # Duplicate titles

    for (a, b) in [("name", "name"), ("NAME", "name")]:

      self.assertRaises(AssertionError, query._PrepareFieldList, [

        (query._MakeField("name", b, constants.QFT_TEXT, "Name"), None, 0,

         lambda *args: None),

        (query._MakeField("other", a, constants.QFT_TEXT, "Other"), None, 0,

         lambda *args: None),

        ], [])

    # Non-lowercase names

    self.assertRaises(AssertionError, query._PrepareFieldList, [

      (query._MakeField("NAME", "Name", constants.QFT_TEXT, "Name"), None, 0,

       lambda *args: None),

      ], [])

    self.assertRaises(AssertionError, query._PrepareFieldList, [

      (query._MakeField("Name", "Name", constants.QFT_TEXT, "Name"), None, 0,

       lambda *args: None),

      ], [])

    # Empty name

    self.assertRaises(AssertionError, query._PrepareFieldList, [

      (query._MakeField("", "Name", constants.QFT_TEXT, "Name"), None, 0,

       lambda *args: None),

      ], [])

    # Empty title

    self.assertRaises(AssertionError, query._PrepareFieldList, [

      (query._MakeField("name", "", constants.QFT_TEXT, "Name"), None, 0,

       lambda *args: None),

      ], [])

    # Whitespace in title

    self.assertRaises(AssertionError, query._PrepareFieldList, [

      (query._MakeField("name", "Co lu mn", constants.QFT_TEXT, "Name"),

       None, 0, lambda *args: None),

      ], [])

    # No callable function

    self.assertRaises(AssertionError, query._PrepareFieldList, [

      (query._MakeField("name", "Name", constants.QFT_TEXT, "Name"),

       None, 0, None),

      ], [])

    # Invalid documentation

    for doc in ["", ".", "Hello world\n", "Hello\nWo\nrld", "Hello World!",

                "HelloWorld.", "only lowercase", ",", " x y z .\t", "  "]:

      self.assertRaises(AssertionError, query._PrepareFieldList, [

        (query._MakeField("name", "Name", constants.QFT_TEXT, doc),

        None, 0, lambda *args: None),

        ], [])

    # Duplicate field name

    self.assertRaises(ValueError, query._PrepareFieldList, [

      (query._MakeField("name", "Name", constants.QFT_TEXT, "Name"),

       None, 0, lambda *args: None),

      (query._MakeField("name", "Other", constants.QFT_OTHER, "Other"),

       None, 0, lambda *args: None),

      ], [])

  def testUnknown(self):

    fielddef = query._PrepareFieldList([

      (query._MakeField("name", "Name", constants.QFT_TEXT, "Name"),

       None, 0, lambda _, item: "name%s" % item),

      (query._MakeField("other0", "Other0", constants.QFT_TIMESTAMP, "Other"),

       None, 0, lambda *args: 1234),

      (query._MakeField("nodata", "NoData", constants.QFT_NUMBER, "No data"),

       None, 0, lambda *args: query._FS_NODATA ),

      (query._MakeField("unavail", "Unavail", constants.QFT_BOOL, "Unavail"),

       None, 0, lambda *args: query._FS_UNAVAIL),

      ], [])

    for selected in [["foo"], ["Hello", "World"],

                     ["name1", "other", "foo"]]:

      q = query.Query(fielddef, selected)

      self.assertEqual(len(q._fields), len(selected))

      self.assert_(compat.all(len(row) == len(selected)

                              for row in q.Query(_QueryData(range(1, 10)))))

      self.assertEqual(q.Query(_QueryData(range(1, 10))),

                       [[(constants.RS_UNKNOWN, None)] * len(selected)

                        for i in range(1, 10)])

      self.assertEqual([fdef.ToDict() for fdef in q.GetFields()],

                       [{ "name": name, "title": name,

                          "kind": constants.QFT_UNKNOWN,

                          "doc": "Unknown field '%s'" % name}

                        for name in selected])

    q = query.Query(fielddef, ["name", "other0", "nodata", "unavail"])

    self.assertEqual(len(q._fields), 4)

    self.assertEqual(q.OldStyleQuery(_QueryData(range(1, 10))), [

                     ["name%s" % i, 1234, None, None]

                     for i in range(1, 10)

                     ])

    q = query.Query(fielddef, ["name", "other0", "nodata", "unavail", "unk"])

    self.assertEqual(len(q._fields), 5)

    self.assertEqual(q.Query(_QueryData(range(1, 10))),

                     [[(constants.RS_NORMAL, "name%s" % i),

                       (constants.RS_NORMAL, 1234),

                       (constants.RS_NODATA, None),

                       (constants.RS_UNAVAIL, None),

                       (constants.RS_UNKNOWN, None)]

                      for i in range(1, 10)])

  def testAliases(self):

    fields = [

      (query._MakeField("a", "a-title", constants.QFT_TEXT, "Field A"),

       None, 0, lambda *args: None),

      (query._MakeField("b", "b-title", constants.QFT_TEXT, "Field B"),

       None, 0, lambda *args: None),

      ]

    # duplicate field

    self.assertRaises(AssertionError, query._PrepareFieldList, fields,

                      [("b", "a")])

    self.assertRaises(AssertionError, query._PrepareFieldList, fields,

                      [("c", "b"), ("c", "a")])

    # missing target

    self.assertRaises(AssertionError, query._PrepareFieldList, fields,

                      [("c", "d")])

    fdefs = query._PrepareFieldList(fields, [("c", "b")])

    self.assertEqual(len(fdefs), 3)

    self.assertEqual(fdefs["b"][1:], fdefs["c"][1:])

class TestGetNodeRole(unittest.TestCase):

  def test(self):

    tested_role = set()

    checks = [

      (constants.NR_MASTER, "node1", objects.Node(name="node1")),

      (constants.NR_MCANDIDATE, "master",

       objects.Node(name="node1", master_candidate=True)),

      (constants.NR_REGULAR, "master", objects.Node(name="node1")),

      (constants.NR_DRAINED, "master",

       objects.Node(name="node1", drained=True)),

      (constants.NR_OFFLINE,

       "master", objects.Node(name="node1", offline=True)),

      ]

    for (role, master_name, node) in checks:

      result = query._GetNodeRole(node, master_name)

      self.assertEqual(result, role)

      tested_role.add(result)

    self.assertEqual(tested_role, constants.NR_ALL)

class TestNodeQuery(unittest.TestCase):

  def _Create(self, selected):

    return query.Query(query.NODE_FIELDS, selected)

  def testSimple(self):

    cluster = objects.Cluster(cluster_name="testcluster",

                              ndparams=constants.NDC_DEFAULTS.copy())

    grp1 = objects.NodeGroup(name="default",

                             uuid="c0e89160-18e7-11e0-a46e-001d0904baeb",

                             alloc_policy=constants.ALLOC_POLICY_PREFERRED,

                             ipolicy=objects.MakeEmptyIPolicy(),

                             ndparams={},

                             )

    grp2 = objects.NodeGroup(name="group2",

                             uuid="c0e89160-18e7-11e0-a46e-001d0904babe",

                             alloc_policy=constants.ALLOC_POLICY_PREFERRED,

                             ipolicy=objects.MakeEmptyIPolicy(),

                             ndparams={constants.ND_SPINDLE_COUNT: 2},

                             )

    groups = {grp1.uuid: grp1, grp2.uuid: grp2}

    nodes = [

      objects.Node(name="node1", drained=False, group=grp1.uuid, ndparams={}),

      objects.Node(name="node2", drained=True, group=grp2.uuid, ndparams={}),

      objects.Node(name="node3", drained=False, group=grp1.uuid,

                   ndparams={constants.ND_SPINDLE_COUNT: 4}),

      ]

    for live_data in [None, dict.fromkeys([node.name for node in nodes], {})]:

      nqd = query.NodeQueryData(nodes, live_data, None, None, None, None,

                                groups, None, cluster)

      q = self._Create(["name", "drained"])

      self.assertEqual(q.RequestedData(), set([query.NQ_CONFIG]))

      self.assertEqual(q.Query(nqd),

                       [[(constants.RS_NORMAL, "node1"),

                         (constants.RS_NORMAL, False)],

                        [(constants.RS_NORMAL, "node2"),

                         (constants.RS_NORMAL, True)],

                        [(constants.RS_NORMAL, "node3"),

                         (constants.RS_NORMAL, False)],

                       ])

      self.assertEqual(q.OldStyleQuery(nqd),

                       [["node1", False],

                        ["node2", True],

                        ["node3", False]])

      q = self._Create(["ndp/spindle_count"])

      self.assertEqual(q.RequestedData(), set([query.NQ_GROUP]))

      self.assertEqual(q.Query(nqd),

                       [[(constants.RS_NORMAL,

                          constants.NDC_DEFAULTS[constants.ND_SPINDLE_COUNT])],

                        [(constants.RS_NORMAL,

                          grp2.ndparams[constants.ND_SPINDLE_COUNT])],

                        [(constants.RS_NORMAL,

                          nodes[2].ndparams[constants.ND_SPINDLE_COUNT])],

                       ])

  def test(self):

    selected = query.NODE_FIELDS.keys()

    field_index = dict((field, idx) for idx, field in enumerate(selected))

    q = self._Create(selected)

    self.assertEqual(q.RequestedData(),

                     set([query.NQ_CONFIG, query.NQ_LIVE, query.NQ_INST,

                          query.NQ_GROUP, query.NQ_OOB]))

    cluster = objects.Cluster(cluster_name="testcluster",

      hvparams=constants.HVC_DEFAULTS,

      beparams={

        constants.PP_DEFAULT: constants.BEC_DEFAULTS,

        },

      nicparams={

        constants.PP_DEFAULT: constants.NICC_DEFAULTS,

        },

      ndparams=constants.NDC_DEFAULTS,

        )

    node_names = ["node%s" % i for i in range(20)]

    master_name = node_names[3]

    nodes = [

      objects.Node(name=name,

                   primary_ip="192.0.2.%s" % idx,

                   secondary_ip="192.0.100.%s" % idx,

                   serial_no=7789 * idx,

                   master_candidate=(name != master_name and idx % 3 == 0),

                   offline=False,

                   drained=False,

                   powered=True,

                   vm_capable=True,

                   master_capable=False,

                   ndparams={},

                   group="default",

                   ctime=1290006900,

                   mtime=1290006913,

                   uuid="fd9ccebe-6339-43c9-a82e-94bbe575%04d" % idx)

      for idx, name in enumerate(node_names)

      ]

    master_node = nodes[3]

    master_node.AddTag("masternode")

    master_node.AddTag("another")

    master_node.AddTag("tag")

    master_node.ctime = None

    master_node.mtime = None

    assert master_node.name == master_name

    live_data_node = nodes[4]

    assert live_data_node.name != master_name

    fake_live_data = {

      "bootid": "a2504766-498e-4b25-b21e-d23098dc3af4",

      "cnodes": 4,

      "cnos": 3,

      "csockets": 4,

      "ctotal": 8,

      "mnode": 128,

      "mfree": 100,

      "mtotal": 4096,

      "dfree": 5 * 1024 * 1024,

      "dtotal": 100 * 1024 * 1024,

      "spfree": 0,

      "sptotal": 0,

      }

    assert (sorted(query._NODE_LIVE_FIELDS.keys()) ==

            sorted(fake_live_data.keys()))

    live_data = dict.fromkeys([node.uuid for node in nodes], {})

    live_data[live_data_node.uuid] = \

      dict((query._NODE_LIVE_FIELDS[name][2], value)

           for name, value in fake_live_data.items())

    node_to_primary_uuid = dict((node.uuid, set()) for node in nodes)

    node_to_primary_uuid[master_node.uuid].update(["inst1", "inst2"])

    node_to_secondary_uuid = dict((node.uuid, set()) for node in nodes)

    node_to_secondary_uuid[live_data_node.uuid].update(["instX", "instY",

                                                        "instZ"])

    inst_uuid_to_inst_name = {

      "inst1": "inst1-name",

      "inst2": "inst2-name",

      "instX": "instX-name",

      "instY": "instY-name",

      "instZ": "instZ-name"

    }

    ng_uuid = "492b4b74-8670-478a-b98d-4c53a76238e6"

    groups = {

      ng_uuid: objects.NodeGroup(name="ng1", uuid=ng_uuid, ndparams={}),

      }

    oob_not_powered_node = nodes[0]

    oob_not_powered_node.powered = False

    oob_support = dict((node.uuid, False) for node in nodes)

    oob_support[master_node.uuid] = True

    oob_support[oob_not_powered_node.uuid] = True

    master_node.group = ng_uuid

    nqd = query.NodeQueryData(nodes, live_data, master_node.uuid,

                              node_to_primary_uuid, node_to_secondary_uuid,

                              inst_uuid_to_inst_name, groups, oob_support,

                              cluster)

    result = q.Query(nqd)

    self.assert_(compat.all(len(row) == len(selected) for row in result))

    self.assertEqual([row[field_index["name"]] for row in result],

                     [(constants.RS_NORMAL, name) for name in node_names])

    node_to_row = dict((row[field_index["name"]][1], idx)

                       for idx, row in enumerate(result))

    master_row = result[node_to_row[master_name]]

    self.assert_(master_row[field_index["master"]])

    self.assert_(master_row[field_index["role"]], "M")

    self.assertEqual(master_row[field_index["group"]],

                     (constants.RS_NORMAL, "ng1"))

    self.assertEqual(master_row[field_index["group.uuid"]],

                     (constants.RS_NORMAL, ng_uuid))

    self.assertEqual(master_row[field_index["ctime"]],

                     (constants.RS_UNAVAIL, None))

    self.assertEqual(master_row[field_index["mtime"]],

                     (constants.RS_UNAVAIL, None))

    self.assert_(row[field_index["pip"]] == node.primary_ip and

                 row[field_index["sip"]] == node.secondary_ip and

                 set(row[field_index["tags"]]) == node.GetTags() and

                 row[field_index["serial_no"]] == node.serial_no and

                 row[field_index["role"]] == query._GetNodeRole(node,

                                                                master_name) and

                 (node.name == master_name or

                  (row[field_index["group"]] == "<unknown>" and

                   row[field_index["group.uuid"]] is None and

                   row[field_index["ctime"]] == (constants.RS_NORMAL,

                                                 node.ctime) and

                   row[field_index["mtime"]] == (constants.RS_NORMAL,

                                                 node.mtime) and

                   row[field_index["powered"]] == (constants.RS_NORMAL,

                                                   True))) or

                 (node.name == oob_not_powered_node and

                  row[field_index["powered"]] == (constants.RS_NORMAL,

                                                  False)) or

                 row[field_index["powered"]] == (constants.RS_UNAVAIL, None)

                 for row, node in zip(result, nodes))

    live_data_row = result[node_to_row[live_data_node.name]]

    for (field, value) in fake_live_data.items():

      self.assertEqual(live_data_row[field_index[field]],

                       (constants.RS_NORMAL, value))

    self.assertEqual(master_row[field_index["pinst_cnt"]],

                     (constants.RS_NORMAL, 2))

    self.assertEqual(live_data_row[field_index["sinst_cnt"]],

                     (constants.RS_NORMAL, 3))

    self.assertEqual(master_row[field_index["pinst_list"]],

                     (constants.RS_NORMAL,

                      [inst_uuid_to_inst_name[uuid] for uuid in

                       node_to_primary_uuid[master_node.uuid]]))

    self.assertEqual(live_data_row[field_index["sinst_list"]],

                     (constants.RS_NORMAL,

                      utils.NiceSort(

                        [inst_uuid_to_inst_name[uuid] for uuid in

                        node_to_secondary_uuid[live_data_node.uuid]])))

  def testGetLiveNodeField(self):

    nodes = [

      objects.Node(name="node1", drained=False, offline=False,

                   vm_capable=True),

      objects.Node(name="node2", drained=True, offline=False,

                   vm_capable=True),

      objects.Node(name="node3", drained=False, offline=False,

                   vm_capable=True),

      objects.Node(name="node4", drained=False, offline=True,

                   vm_capable=True),

      objects.Node(name="node5", drained=False, offline=False,

                   vm_capable=False),

      ]

    live_data = dict.fromkeys([node.name for node in nodes], {})

    # No data

    nqd = query.NodeQueryData(None, None, None, None, None, None, None, None,

                              None)

    self.assertEqual(query._GetLiveNodeField("hello", constants.QFT_NUMBER,

                                             nqd, nodes[0]),

                     query._FS_NODATA)

    # Missing field

    ctx = _QueryData(None, curlive_data={

      "some": 1,

      "other": 2,

      })

    self.assertEqual(query._GetLiveNodeField("hello", constants.QFT_NUMBER,

                                             ctx, nodes[0]),

                     query._FS_UNAVAIL)

    # Wrong format/datatype

    ctx = _QueryData(None, curlive_data={

      "hello": ["Hello World"],

      "other": 2,

      })

    self.assertEqual(query._GetLiveNodeField("hello", constants.QFT_NUMBER,

                                             ctx, nodes[0]),

                     query._FS_UNAVAIL)

    # Offline node

    assert nodes[3].offline

    ctx = _QueryData(None, curlive_data={})

    self.assertEqual(query._GetLiveNodeField("hello", constants.QFT_NUMBER,

                                             ctx, nodes[3]),

                     query._FS_OFFLINE, None)

    # Wrong field type

    ctx = _QueryData(None, curlive_data={"hello": 123})

    self.assertRaises(AssertionError, query._GetLiveNodeField,

                      "hello", constants.QFT_BOOL, ctx, nodes[0])

    # Non-vm_capable node

    assert not nodes[4].vm_capable

    ctx = _QueryData(None, curlive_data={})

    self.assertEqual(query._GetLiveNodeField("hello", constants.QFT_NUMBER,

                                             ctx, nodes[4]),

                     query._FS_UNAVAIL, None)

class TestInstanceQuery(unittest.TestCase):

  def _Create(self, selected):

    return query.Query(query.INSTANCE_FIELDS, selected)

  def testSimple(self):

    q = self._Create(["name", "be/maxmem", "ip"])

    self.assertEqual(q.RequestedData(), set([query.IQ_CONFIG]))

    cluster = objects.Cluster(cluster_name="testcluster",

      hvparams=constants.HVC_DEFAULTS,

      beparams={

        constants.PP_DEFAULT: constants.BEC_DEFAULTS,

        },

      nicparams={

        constants.PP_DEFAULT: constants.NICC_DEFAULTS,

        },

      os_hvp={},

      osparams={})

    instances = [

      objects.Instance(name="inst1", hvparams={}, beparams={}, osparams={},

                       nics=[], os="deb1"),

      objects.Instance(name="inst2", hvparams={}, nics=[], osparams={},

        os="foomoo",

        beparams={

          constants.BE_MAXMEM: 512,

        }),

      objects.Instance(name="inst3", hvparams={}, beparams={}, osparams={},

        os="dos", nics=[objects.NIC(ip="192.0.2.99", nicparams={})]),

      ]

    iqd = query.InstanceQueryData(instances, cluster, None, [], [], {},

                                  set(), {}, None, None, None)

    self.assertEqual(q.Query(iqd),

      [[(constants.RS_NORMAL, "inst1"),

        (constants.RS_NORMAL, 128),

        (constants.RS_UNAVAIL, None),

       ],

       [(constants.RS_NORMAL, "inst2"),

        (constants.RS_NORMAL, 512),

        (constants.RS_UNAVAIL, None),

       ],

       [(constants.RS_NORMAL, "inst3"),

        (constants.RS_NORMAL, 128),

        (constants.RS_NORMAL, "192.0.2.99"),

       ]])

    self.assertEqual(q.OldStyleQuery(iqd),

      [["inst1", 128, None],

       ["inst2", 512, None],

       ["inst3", 128, "192.0.2.99"]])

  def test(self):

    selected = query.INSTANCE_FIELDS.keys()

    fieldidx = dict((field, idx) for idx, field in enumerate(selected))

    macs = ["00:11:22:%02x:%02x:%02x" % (i % 255, i % 3, (i * 123) % 255)

            for i in range(20)]

    q = self._Create(selected)

    self.assertEqual(q.RequestedData(),

                     set([query.IQ_CONFIG, query.IQ_LIVE, query.IQ_DISKUSAGE,

                          query.IQ_CONSOLE, query.IQ_NODES, query.IQ_NETWORKS]))

    cluster = objects.Cluster(cluster_name="testcluster",

      hvparams=constants.HVC_DEFAULTS,

      beparams={

        constants.PP_DEFAULT: constants.BEC_DEFAULTS,

        },

      nicparams={

        constants.PP_DEFAULT: constants.NICC_DEFAULTS,

        },

      os_hvp={},

      tcpudp_port_pool=set(),

      osparams={

        "deb99": {

          "clean_install": "yes",

          },

        })

    offline_nodes = ["nodeoff1-uuid", "nodeoff2-uuid"]

    bad_nodes = ["nodebad1-uuid", "nodebad2-uuid", "nodebad3-uuid"] +\

                offline_nodes

    node_uuids = ["node%s-uuid" % i for i in range(10)] + bad_nodes

    instances = [

      objects.Instance(name="inst1", hvparams={}, beparams={}, nics=[],

        uuid="inst1-uuid",

        ctime=1291244000, mtime=1291244400, serial_no=30,

        admin_state=constants.ADMINST_UP, hypervisor=constants.HT_XEN_PVM,

        os="linux1",

        primary_node="node1-uuid",

        disk_template=constants.DT_PLAIN,

        disks=[],

        disks_active=True,

        osparams={}),

      objects.Instance(name="inst2", hvparams={}, nics=[],

        uuid="inst2-uuid",

        ctime=1291211000, mtime=1291211077, serial_no=1,

        admin_state=constants.ADMINST_UP, hypervisor=constants.HT_XEN_HVM,

        os="deb99",

        primary_node="node5-uuid",

        disk_template=constants.DT_DISKLESS,

        disks=[],

        disks_active=True,

        beparams={

          constants.BE_MAXMEM: 512,

          constants.BE_MINMEM: 256,

        },

        osparams={}),