Synnefo » snf-ganeti

#!/usr/bin/python

#

# Copyright (C) 2010, 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 unittesting the RAPI rlib2 module

"""

import unittest

import itertools

import random

from ganeti import constants

from ganeti import opcodes

from ganeti import compat

from ganeti import http

from ganeti import query

import ganeti.rpc.errors as rpcerr

from ganeti import errors

from ganeti import rapi

from ganeti.rapi import rlib2

from ganeti.rapi import baserlib

from ganeti.rapi import connector

import testutils

class _FakeRequestPrivateData:

  def __init__(self, body_data):

    self.body_data = body_data

class _FakeRequest:

  def __init__(self, body_data):

    self.private = _FakeRequestPrivateData(body_data)

def _CreateHandler(cls, items, queryargs, body_data, client_cls):

  return cls(items, queryargs, _FakeRequest(body_data),

             _client_cls=client_cls)

class _FakeClient:

  def __init__(self, address=None):

    self._jobs = []

  def GetNextSubmittedJob(self):

    return self._jobs.pop(0)

  def SubmitJob(self, ops):

    job_id = str(1 + int(random.random() * 1000000))

    self._jobs.append((job_id, ops))

    return job_id

class _FakeClientFactory:

  def __init__(self, cls):

    self._client_cls = cls

    self._clients = []

  def GetNextClient(self):

    return self._clients.pop(0)

  def __call__(self, address=None):

    cl = self._client_cls(address=address)

    self._clients.append(cl)

    return cl

class RAPITestCase(testutils.GanetiTestCase):

  """Provides a few helper methods specific to RAPI testing.

  """

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

    """Creates a fake client factory the test may or may not use.

    """

    unittest.TestCase.__init__(self, *args, **kwargs)

    self._clfactory = _FakeClientFactory(_FakeClient)

  def assertNoNextClient(self, clfactory=None):

    """Insures that no further clients are present.

    """

    if clfactory is None:

      clfactory = self._clfactory

    self.assertRaises(IndexError, clfactory.GetNextClient)

  def getSubmittedOpcode(self, rapi_cls, items, query_args, body_data,

                         method_name, opcode_cls):

    """Submits a RAPI request and fetches the resulting opcode.

    """

    handler = _CreateHandler(rapi_cls, items, query_args, body_data,

                             self._clfactory)

    self.assertTrue(hasattr(handler, method_name),

                    "Handler lacks target method %s" % method_name)

    job_id = getattr(handler, method_name)()

    try:

      int(job_id)

    except ValueError:

      raise AssertionError("Returned value not job id; received %s" % job_id)

    cl = self._clfactory.GetNextClient()

    self.assertNoNextClient()

    (exp_job_id, (op, )) = cl.GetNextSubmittedJob()

    self.assertEqual(job_id, exp_job_id,

                     "Job IDs do not match: %s != %s" % (job_id, exp_job_id))

    self.assertRaises(IndexError, cl.GetNextSubmittedJob)

    self.assertTrue(isinstance(op, opcode_cls),

                    "Wrong opcode class: expected %s, got %s" %

                    (opcode_cls.__name__, op.__class__.__name__))

    return op

class TestConstants(unittest.TestCase):

  def testConsole(self):

    # Exporting the console field without authentication might expose

    # information

    assert "console" in query.INSTANCE_FIELDS

    self.assertTrue("console" not in rlib2.I_FIELDS)

  def testFields(self):

    checks = {

      constants.QR_INSTANCE: rlib2.I_FIELDS,

      constants.QR_NODE: rlib2.N_FIELDS,

      constants.QR_GROUP: rlib2.G_FIELDS,

      }

    for (qr, fields) in checks.items():

      self.assertFalse(set(fields) - set(query.ALL_FIELDS[qr].keys()))

class TestClientConnectError(unittest.TestCase):

  @staticmethod

  def _FailingClient(address=None):

    raise rpcerr.NoMasterError("test")

  def test(self):

    resources = [

      rlib2.R_2_groups,

      rlib2.R_2_instances,

      rlib2.R_2_nodes,

      ]

    for cls in resources:

      handler = _CreateHandler(cls, ["name"], {}, None, self._FailingClient)

      self.assertRaises(http.HttpBadGateway, handler.GET)

class TestJobSubmitError(unittest.TestCase):

  class _SubmitErrorClient:

    def __init__(self, address=None):

      pass

    @staticmethod

    def SubmitJob(ops):

      raise errors.JobQueueFull("test")

  def test(self):

    handler = _CreateHandler(rlib2.R_2_redist_config, [], {}, None,

                             self._SubmitErrorClient)

    self.assertRaises(http.HttpServiceUnavailable, handler.PUT)

class TestClusterModify(RAPITestCase):

  def test(self):

    body_data = {

      "vg_name": "testvg",

      "candidate_pool_size": 100,

      }

    op = self.getSubmittedOpcode(rlib2.R_2_cluster_modify, [], {}, body_data,

                                 "PUT", opcodes.OpClusterSetParams)

    self.assertEqual(op.vg_name, "testvg")

    self.assertEqual(op.candidate_pool_size, 100)

  def testInvalidValue(self):

    for attr in ["vg_name", "candidate_pool_size", "beparams", "_-Unknown#"]:

      handler = _CreateHandler(rlib2.R_2_cluster_modify, [], {}, {

        attr: True,

        }, self._clfactory)

      self.assertRaises(http.HttpBadRequest, handler.PUT)

      self.assertNoNextClient()

class TestRedistConfig(RAPITestCase):

  def test(self):

    self.getSubmittedOpcode(rlib2.R_2_redist_config, [], {}, None, "PUT",

                            opcodes.OpClusterRedistConf)

class TestNodeMigrate(RAPITestCase):

  def test(self):

    body_data = {

      "iallocator": "fooalloc",

      }

    op = self.getSubmittedOpcode(rlib2.R_2_nodes_name_migrate, ["node1"], {},

                                 body_data, "POST", opcodes.OpNodeMigrate)

    self.assertEqual(op.node_name, "node1")

    self.assertEqual(op.iallocator, "fooalloc")

  def testQueryArgsConflict(self):

    query_args = {

      "live": True,

      "mode": constants.HT_MIGRATION_NONLIVE,

      }

    handler = _CreateHandler(rlib2.R_2_nodes_name_migrate, ["node2"],

                             query_args, None, self._clfactory)

    self.assertRaises(http.HttpBadRequest, handler.POST)

    self.assertNoNextClient()

  def testQueryArgsMode(self):

    query_args = {

      "mode": [constants.HT_MIGRATION_LIVE],

      }

    op = self.getSubmittedOpcode(rlib2.R_2_nodes_name_migrate, ["node17292"],

                                 query_args, None, "POST",

                                 opcodes.OpNodeMigrate)

    self.assertEqual(op.node_name, "node17292")

    self.assertEqual(op.mode, constants.HT_MIGRATION_LIVE)

  def testQueryArgsLive(self):

    clfactory = _FakeClientFactory(_FakeClient)

    for live in [False, True]:

      query_args = {

        "live": [str(int(live))],

        }

      op = self.getSubmittedOpcode(rlib2.R_2_nodes_name_migrate, ["node6940"],

                                   query_args, None, "POST",

                                   opcodes.OpNodeMigrate)

      self.assertEqual(op.node_name, "node6940")

      if live:

        self.assertEqual(op.mode, constants.HT_MIGRATION_LIVE)

      else:

        self.assertEqual(op.mode, constants.HT_MIGRATION_NONLIVE)

class TestNodeEvacuate(RAPITestCase):

  def test(self):

    query_args = {

      "dry-run": ["1"],

      }

    body_data = {

      "mode": constants.NODE_EVAC_SEC,

      }

    op = self.getSubmittedOpcode(rlib2.R_2_nodes_name_evacuate, ["node92"],

                                 query_args, body_data, "POST",

                                 opcodes.OpNodeEvacuate)

    self.assertEqual(op.node_name, "node92")

    self.assertEqual(op.mode, constants.NODE_EVAC_SEC)

class TestNodePowercycle(RAPITestCase):

  def test(self):

    query_args = {

      "force": ["1"],

      }

    op = self.getSubmittedOpcode(rlib2.R_2_nodes_name_powercycle, ["node20744"],

                                 query_args, None, "POST",

                                 opcodes.OpNodePowercycle)

    self.assertEqual(op.node_name, "node20744")

    self.assertTrue(op.force)

class TestGroupAssignNodes(RAPITestCase):

  def test(self):

    clfactory = _FakeClientFactory(_FakeClient)

    query_args = {

      "dry-run": ["1"],

      "force": ["1"],

      }

    body_data = {

      "nodes": ["n2", "n3"],

      }

    op = self.getSubmittedOpcode(rlib2.R_2_groups_name_assign_nodes, ["grp-a"],

                                 query_args, body_data, "PUT",

                                 opcodes.OpGroupAssignNodes)

    self.assertEqual(op.group_name, "grp-a")

    self.assertEqual(op.nodes, ["n2", "n3"])

    self.assertTrue(op.dry_run)

    self.assertTrue(op.force)

class TestInstanceDelete(RAPITestCase):

  def test(self):

    query_args = {

      "dry-run": ["1"],

      }

    op = self.getSubmittedOpcode(rlib2.R_2_instances_name, ["inst30965"],

                                 query_args, {}, "DELETE",

                                 opcodes.OpInstanceRemove)

    self.assertEqual(op.instance_name, "inst30965")

    self.assertTrue(op.dry_run)

    self.assertFalse(op.ignore_failures)

class TestInstanceInfo(RAPITestCase):

  def test(self):

    query_args = {

      "static": ["1"],

      }

    op = self.getSubmittedOpcode(rlib2.R_2_instances_name_info, ["inst31217"],

                                 query_args, {}, "GET",

                                 opcodes.OpInstanceQueryData)

    self.assertEqual(op.instances, ["inst31217"])

    self.assertTrue(op.static)

class TestInstanceReboot(RAPITestCase):

  def test(self):

    query_args = {

      "dry-run": ["1"],

      "ignore_secondaries": ["1"],

      "reason": ["System update"],

      }

    op = self.getSubmittedOpcode(rlib2.R_2_instances_name_reboot, ["inst847"],

                                 query_args, {}, "POST",

                                 opcodes.OpInstanceReboot)

    self.assertEqual(op.instance_name, "inst847")

    self.assertEqual(op.reboot_type, constants.INSTANCE_REBOOT_HARD)

    self.assertTrue(op.ignore_secondaries)

    self.assertTrue(op.dry_run)

    self.assertEqual(op.reason[0][0], constants.OPCODE_REASON_SRC_USER)

    self.assertEqual(op.reason[0][1], "System update")

    self.assertEqual(op.reason[1][0],

                     "%s:%s" % (constants.OPCODE_REASON_SRC_RLIB2,

                                "instances_name_reboot"))

    self.assertEqual(op.reason[1][1], "")

class TestInstanceStartup(RAPITestCase):

  def test(self):

    query_args = {

      "force": ["1"],

      "no_remember": ["1"],

      "reason": ["Newly created instance"],

      }

    op = self.getSubmittedOpcode(rlib2.R_2_instances_name_startup,

                                 ["inst31083"], query_args, {}, "PUT",

                                 opcodes.OpInstanceStartup)

    self.assertEqual(op.instance_name, "inst31083")

    self.assertTrue(op.no_remember)

    self.assertTrue(op.force)

    self.assertFalse(op.dry_run)

    self.assertEqual(op.reason[0][0], constants.OPCODE_REASON_SRC_USER)

    self.assertEqual(op.reason[0][1], "Newly created instance")

    self.assertEqual(op.reason[1][0],

                     "%s:%s" % (constants.OPCODE_REASON_SRC_RLIB2,

                                "instances_name_startup"))

    self.assertEqual(op.reason[1][1], "")

class TestInstanceShutdown(RAPITestCase):

  def test(self):

    query_args = {

      "no_remember": ["0"],

      "reason": ["Not used anymore"],

      }

    op = self.getSubmittedOpcode(rlib2.R_2_instances_name_shutdown,

                                 ["inst26791"], query_args, {}, "PUT",

                                 opcodes.OpInstanceShutdown)

    self.assertEqual(op.instance_name, "inst26791")

    self.assertFalse(op.no_remember)

    self.assertFalse(op.dry_run)

    self.assertEqual(op.reason[0][0], constants.OPCODE_REASON_SRC_USER)

    self.assertEqual(op.reason[0][1], "Not used anymore")

    self.assertEqual(op.reason[1][0],

                     "%s:%s" % (constants.OPCODE_REASON_SRC_RLIB2,

                                "instances_name_shutdown"))

    self.assertEqual(op.reason[1][1], "")

class TestInstanceActivateDisks(RAPITestCase):

  def test(self):

    query_args = {

      "ignore_size": ["1"],

      }

    op = self.getSubmittedOpcode(rlib2.R_2_instances_name_activate_disks,

                                 ["xyz"], query_args, {}, "PUT",

                                 opcodes.OpInstanceActivateDisks)

    self.assertEqual(op.instance_name, "xyz")

    self.assertTrue(op.ignore_size)

    self.assertFalse(op.dry_run)

class TestInstanceDeactivateDisks(RAPITestCase):

  def test(self):

    op = self.getSubmittedOpcode(rlib2.R_2_instances_name_deactivate_disks,

                                 ["inst22357"], {}, {}, "PUT",

                                 opcodes.OpInstanceDeactivateDisks)

    self.assertEqual(op.instance_name, "inst22357")

    self.assertFalse(op.dry_run)

    self.assertFalse(op.force)

class TestInstanceRecreateDisks(RAPITestCase):

  def test(self):

    op = self.getSubmittedOpcode(rlib2.R_2_instances_name_recreate_disks,

                                 ["inst22357"], {}, {}, "POST",

                                 opcodes.OpInstanceRecreateDisks)

    self.assertEqual(op.instance_name, "inst22357")

    self.assertFalse(op.dry_run)

    self.assertFalse(hasattr(op, "force"))

class TestInstanceFailover(RAPITestCase):

  def test(self):

    op = self.getSubmittedOpcode(rlib2.R_2_instances_name_failover,

                                 ["inst12794"], {}, {}, "PUT",

                                 opcodes.OpInstanceFailover)

    self.assertEqual(op.instance_name, "inst12794")

    self.assertFalse(op.dry_run)

    self.assertFalse(hasattr(op, "force"))

class TestInstanceDiskGrow(RAPITestCase):

  def test(self):

    data = {

      "amount": 1024,

      }

    op = self.getSubmittedOpcode(rlib2.R_2_instances_name_disk_grow,

                                 ["inst10742", "3"], {}, data, "POST",

                                 opcodes.OpInstanceGrowDisk)

    self.assertEqual(op.instance_name, "inst10742")

    self.assertEqual(op.disk, 3)

    self.assertEqual(op.amount, 1024)

    self.assertFalse(op.dry_run)

    self.assertFalse(hasattr(op, "force"))

class TestInstanceModify(RAPITestCase):

  def testCustomParamRename(self):

    name = "instant_instance"

    data = {

      "custom_beparams": {},

      "custom_hvparams": {},

      }

    op = self.getSubmittedOpcode(rlib2.R_2_instances_name_modify, [name], {},

                                 data, "PUT", opcodes.OpInstanceSetParams)

    self.assertEqual(op.beparams, {})

    self.assertEqual(op.hvparams, {})

    # Define both

    data["beparams"] = {}

    assert "beparams" in data and "custom_beparams" in data

    handler = _CreateHandler(rlib2.R_2_instances_name_modify, [name], {}, data,

                             self._clfactory)

    self.assertRaises(http.HttpBadRequest, handler.PUT)

class TestBackupPrepare(RAPITestCase):

  def test(self):

    query_args = {

      "mode": constants.EXPORT_MODE_REMOTE,

      }

    op = self.getSubmittedOpcode(rlib2.R_2_instances_name_prepare_export,

                                 ["inst17925"], query_args, {}, "PUT",

                                 opcodes.OpBackupPrepare)

    self.assertEqual(op.instance_name, "inst17925")

    self.assertEqual(op.mode, constants.EXPORT_MODE_REMOTE)

    self.assertFalse(op.dry_run)

    self.assertFalse(hasattr(op, "force"))

class TestGroupRemove(RAPITestCase):

  def test(self):

    op = self.getSubmittedOpcode(rlib2.R_2_groups_name, ["grp28575"], {}, {},

                                 "DELETE", opcodes.OpGroupRemove)

    self.assertEqual(op.group_name, "grp28575")

    self.assertFalse(op.dry_run)

    self.assertFalse(hasattr(op, "force"))

class TestStorageQuery(RAPITestCase):

  def test(self):

    query_args = {

      "storage_type": constants.ST_LVM_PV,

      "output_fields": "name,other",

      }

    op = self.getSubmittedOpcode(rlib2.R_2_nodes_name_storage, ["node21075"],

                                 query_args, {}, "GET",

                                 opcodes.OpNodeQueryStorage)

    self.assertEqual(op.nodes, ["node21075"])

    self.assertEqual(op.storage_type, constants.ST_LVM_PV)

    self.assertEqual(op.output_fields, ["name", "other"])

    self.assertFalse(op.dry_run)

    self.assertFalse(hasattr(op, "force"))

  def testErrors(self):

    # storage type which does not support space reporting

    queryargs = {

      "storage_type": constants.ST_DISKLESS,

      }

    handler = _CreateHandler(rlib2.R_2_nodes_name_storage,

                             ["node21273"], queryargs, {}, self._clfactory)

    self.assertRaises(http.HttpBadRequest, handler.GET)

    queryargs = {

      "storage_type": constants.ST_LVM_VG,

      }

    handler = _CreateHandler(rlib2.R_2_nodes_name_storage,

                             ["node21273"], queryargs, {}, self._clfactory)

    self.assertRaises(http.HttpBadRequest, handler.GET)

    queryargs = {

      "storage_type": "##unknown_storage##",

      "output_fields": "name,other",

      }

    handler = _CreateHandler(rlib2.R_2_nodes_name_storage,

                             ["node10315"], queryargs, {}, self._clfactory)

    self.assertRaises(http.HttpBadRequest, handler.GET)

class TestStorageModify(RAPITestCase):

  def test(self):

    clfactory = _FakeClientFactory(_FakeClient)

    for allocatable in [None, "1", "0"]:

      query_args = {

        "storage_type": constants.ST_LVM_VG,

        "name": "pv-a",

        }

      if allocatable is not None:

        query_args["allocatable"] = allocatable

      op = self.getSubmittedOpcode(rlib2.R_2_nodes_name_storage_modify,

                                   ["node9292"], query_args, {}, "PUT",

                                   opcodes.OpNodeModifyStorage)

      self.assertEqual(op.node_name, "node9292")

      self.assertEqual(op.storage_type, constants.ST_LVM_VG)

      self.assertEqual(op.name, "pv-a")

      if allocatable is None:

        self.assertFalse(op.changes)

      else:

        assert allocatable in ("0", "1")

        self.assertEqual(op.changes, {

          constants.SF_ALLOCATABLE: (allocatable == "1"),

          })

      self.assertFalse(op.dry_run)

      self.assertFalse(hasattr(op, "force"))

  def testErrors(self):

    # No storage type

    queryargs = {

      "name": "xyz",

      }

    handler = _CreateHandler(rlib2.R_2_nodes_name_storage_modify,

                             ["node26016"], queryargs, {}, self._clfactory)

    self.assertRaises(http.HttpBadRequest, handler.PUT)

    # No name

    queryargs = {

      "storage_type": constants.ST_LVM_VG,

      }

    handler = _CreateHandler(rlib2.R_2_nodes_name_storage_modify,

                             ["node21218"], queryargs, {}, self._clfactory)

    self.assertRaises(http.HttpBadRequest, handler.PUT)

    # Invalid value

    queryargs = {

      "storage_type": constants.ST_LVM_VG,

      "name": "pv-b",

      "allocatable": "noint",

      }

    handler = _CreateHandler(rlib2.R_2_nodes_name_storage_modify,

                             ["node30685"], queryargs, {}, self._clfactory)

    self.assertRaises(http.HttpBadRequest, handler.PUT)

class TestStorageRepair(RAPITestCase):

  def test(self):

    query_args = {

      "storage_type": constants.ST_LVM_PV,

      "name": "pv16611",

      }

    op = self.getSubmittedOpcode(rlib2.R_2_nodes_name_storage_repair,

                                 ["node19265"], query_args, {}, "PUT",

                                 opcodes.OpRepairNodeStorage)

    self.assertEqual(op.node_name, "node19265")

    self.assertEqual(op.storage_type, constants.ST_LVM_PV)

    self.assertEqual(op.name, "pv16611")

    self.assertFalse(op.dry_run)

    self.assertFalse(hasattr(op, "force"))

  def testErrors(self):

    # No storage type

    queryargs = {

      "name": "xyz",

      }

    handler = _CreateHandler(rlib2.R_2_nodes_name_storage_repair,

                             ["node11275"], queryargs, {}, self._clfactory)

    self.assertRaises(http.HttpBadRequest, handler.PUT)

    # No name

    queryargs = {

      "storage_type": constants.ST_LVM_VG,

      }

    handler = _CreateHandler(rlib2.R_2_nodes_name_storage_repair,

                             ["node21218"], queryargs, {}, self._clfactory)

    self.assertRaises(http.HttpBadRequest, handler.PUT)

class TestTags(RAPITestCase):

  TAG_HANDLERS = [

    rlib2.R_2_instances_name_tags,

    rlib2.R_2_nodes_name_tags,

    rlib2.R_2_groups_name_tags,

    rlib2.R_2_tags,

    ]

  def testSetAndDelete(self):

    for method, opcls in [("PUT", opcodes.OpTagsSet),

                          ("DELETE", opcodes.OpTagsDel)]:

      for idx, handler in enumerate(self.TAG_HANDLERS):

        dry_run = bool(idx % 2)

        name = "test%s" % idx

        queryargs = {

          "tag": ["foo", "bar", "baz"],

          "dry-run": str(int(dry_run)),

          }

        op = self.getSubmittedOpcode(handler, [name], queryargs, {}, method,

                                     opcls)

        self.assertEqual(op.kind, handler.TAG_LEVEL)

        if handler.TAG_LEVEL == constants.TAG_CLUSTER:

          self.assertTrue(op.name is None)

        else:

          self.assertEqual(op.name, name)

        self.assertEqual(op.tags, ["foo", "bar", "baz"])

        self.assertEqual(op.dry_run, dry_run)

        self.assertFalse(hasattr(op, "force"))

class TestInstanceCreation(RAPITestCase):

  def test(self):

    name = "inst863.example.com"

    disk_variants = [

      # No disks

      [],

      # Two disks

      [{"size": 5, }, {"size": 100, }],

      # Disk with mode

      [{"size": 123, "mode": constants.DISK_RDWR, }],

      ]

    nic_variants = [

      # No NIC

      [],

      # Three NICs

      [{}, {}, {}],

      # Two NICs

      [

        { "ip": "192.0.2.6", "mode": constants.NIC_MODE_ROUTED,

          "mac": "01:23:45:67:68:9A",

        },

        { "mode": constants.NIC_MODE_BRIDGED, "link": "br1" },

      ],

      ]

    beparam_variants = [

      None,

      {},

      { constants.BE_VCPUS: 2, },

      { constants.BE_MAXMEM: 200, },

      { constants.BE_MEMORY: 256, },

      { constants.BE_VCPUS: 2,

        constants.BE_MAXMEM: 1024,

        constants.BE_MINMEM: 1024,

        constants.BE_AUTO_BALANCE: True,

        constants.BE_ALWAYS_FAILOVER: True, }

      ]

    hvparam_variants = [

      None,

      { constants.HV_BOOT_ORDER: "anc", },

      { constants.HV_KERNEL_PATH: "/boot/fookernel",

        constants.HV_ROOT_PATH: "/dev/hda1", },

      ]

    for mode in [constants.INSTANCE_CREATE, constants.INSTANCE_IMPORT]:

      for nics in nic_variants:

        for disk_template in constants.DISK_TEMPLATES:

          for disks in disk_variants:

            for beparams in beparam_variants:

              for hvparams in hvparam_variants:

                for dry_run in [False, True]:

                  query_args = {

                    "dry-run": str(int(dry_run)),

                    }

                  data = {

                    rlib2._REQ_DATA_VERSION: 1,

                    "name": name,

                    "hypervisor": constants.HT_FAKE,

                    "disks": disks,

                    "nics": nics,

                    "mode": mode,

                    "disk_template": disk_template,

                    "os": "debootstrap",

                    }

                  if beparams is not None:

                    data["beparams"] = beparams

                  if hvparams is not None:

                    data["hvparams"] = hvparams

                  op = self.getSubmittedOpcode(