X-Git-Url: https://code.grnet.gr/git/ganeti-local/blobdiff_plain/a6682fdcc173998be87b77043bfa56c0d12b1ca4..7fa310f6d84e06934a7d2bc55c9a1e2b84ce613a:/lib/rapi/rlib2.py

diff --git a/lib/rapi/rlib2.py b/lib/rapi/rlib2.py
index e54509e..66b0ece 100644
--- a/lib/rapi/rlib2.py
+++ b/lib/rapi/rlib2.py
@@ -45,8 +45,8 @@ from ganeti import opcodes
 from ganeti import http
 from ganeti import constants
 from ganeti import cli
-from ganeti import utils
 from ganeti import rapi
+from ganeti import ht
 from ganeti.rapi import baserlib
 
 
@@ -86,13 +86,15 @@ _NR_OFFLINE = "offline"
 _NR_REGULAR = "regular"
 
 _NR_MAP = {
-  "M": _NR_MASTER,
-  "C": _NR_MASTER_CANDIATE,
-  "D": _NR_DRAINED,
-  "O": _NR_OFFLINE,
-  "R": _NR_REGULAR,
+  constants.NR_MASTER: _NR_MASTER,
+  constants.NR_MCANDIDATE: _NR_MASTER_CANDIATE,
+  constants.NR_DRAINED: _NR_DRAINED,
+  constants.NR_OFFLINE: _NR_OFFLINE,
+  constants.NR_REGULAR: _NR_REGULAR,
   }
 
+assert frozenset(_NR_MAP.keys()) == constants.NR_ALL
+
 # Request data version field
 _REQ_DATA_VERSION = "__version__"
 
@@ -160,7 +162,7 @@ class R_2_os(baserlib.R_Generic):
 
     """
     cl = baserlib.GetClient()
-    op = opcodes.OpDiagnoseOS(output_fields=["name", "variants"], names=[])
+    op = opcodes.OpOsDiagnose(output_fields=["name", "variants"], names=[])
     job_id = baserlib.SubmitJob([op], cl)
     # we use custom feedback function, instead of print we log the status
     result = cli.PollJob(job_id, cl, feedback_fn=baserlib.FeedbackFn)
@@ -395,7 +397,7 @@ class R_2_nodes_name_role(baserlib.R_Generic):
     else:
       raise http.HttpBadRequest("Can't set '%s' role" % role)
 
-    op = opcodes.OpSetNodeParams(node_name=node_name,
+    op = opcodes.OpNodeSetParams(node_name=node_name,
                                  master_candidate=candidate,
                                  offline=offline,
                                  drained=drained,
@@ -420,23 +422,23 @@ class R_2_nodes_name_evacuate(baserlib.R_Generic):
 
     cl = baserlib.GetClient()
 
-    op = opcodes.OpNodeEvacuationStrategy(nodes=[node_name],
-                                          iallocator=iallocator,
-                                          remote_node=remote_node)
+    op = opcodes.OpNodeEvacStrategy(nodes=[node_name],
+                                    iallocator=iallocator,
+                                    remote_node=remote_node)
 
     job_id = baserlib.SubmitJob([op], cl)
     # we use custom feedback function, instead of print we log the status
     result = cli.PollJob(job_id, cl, feedback_fn=baserlib.FeedbackFn)
 
     jobs = []
-    for iname, node in result:
+    for iname, node in result[0]:
       if dry_run:
         jid = None
       else:
-        op = opcodes.OpReplaceDisks(instance_name=iname,
-                                    remote_node=node, disks=[],
-                                    mode=constants.REPLACE_DISK_CHG,
-                                    early_release=early_r)
+        op = opcodes.OpInstanceReplaceDisks(instance_name=iname,
+                                            remote_node=node, disks=[],
+                                            mode=constants.REPLACE_DISK_CHG,
+                                            early_release=early_r)
         jid = baserlib.SubmitJob([op])
       jobs.append((jid, iname, node))
 
@@ -464,7 +466,7 @@ class R_2_nodes_name_migrate(baserlib.R_Generic):
     else:
       mode = self._checkStringVariable("mode", default=None)
 
-    op = opcodes.OpMigrateNode(node_name=node_name, mode=mode)
+    op = opcodes.OpNodeMigrate(node_name=node_name, mode=mode)
 
     return baserlib.SubmitJob([op])
 
@@ -473,7 +475,7 @@ class R_2_nodes_name_storage(baserlib.R_Generic):
   """/2/nodes/[node_name]/storage resource.
 
   """
-  # LUQueryNodeStorage acquires locks, hence restricting access to GET
+  # LUNodeQueryStorage acquires locks, hence restricting access to GET
   GET_ACCESS = [rapi.RAPI_ACCESS_WRITE]
 
   def GET(self):
@@ -489,7 +491,7 @@ class R_2_nodes_name_storage(baserlib.R_Generic):
       raise http.HttpBadRequest("Missing the required 'output_fields'"
                                 " parameter")
 
-    op = opcodes.OpQueryNodeStorage(nodes=[node_name],
+    op = opcodes.OpNodeQueryStorage(nodes=[node_name],
                                     storage_type=storage_type,
                                     output_fields=output_fields.split(","))
     return baserlib.SubmitJob([op])
@@ -518,7 +520,7 @@ class R_2_nodes_name_storage_modify(baserlib.R_Generic):
       changes[constants.SF_ALLOCATABLE] = \
         bool(self._checkIntVariable("allocatable", default=1))
 
-    op = opcodes.OpModifyNodeStorage(node_name=node_name,
+    op = opcodes.OpNodeModifyStorage(node_name=node_name,
                                      storage_type=storage_type,
                                      name=name,
                                      changes=changes)
@@ -551,16 +553,20 @@ class R_2_nodes_name_storage_repair(baserlib.R_Generic):
 def _ParseCreateGroupRequest(data, dry_run):
   """Parses a request for creating a node group.
 
-  @rtype: L{opcodes.OpAddGroup}
+  @rtype: L{opcodes.OpGroupAdd}
   @return: Group creation opcode
 
   """
-  group_name = baserlib.CheckParameter(data, "name")
-  alloc_policy = baserlib.CheckParameter(data, "alloc_policy", default=None)
+  override = {
+    "dry_run": dry_run,
+    }
+
+  rename = {
+    "name": "group_name",
+    }
 
-  return opcodes.OpAddGroup(group_name=group_name,
-                            alloc_policy=alloc_policy,
-                            dry_run=dry_run)
+  return baserlib.FillOpcode(opcodes.OpGroupAdd, data, override,
+                             rename=rename)
 
 
 class R_2_groups(baserlib.R_Generic):
@@ -614,7 +620,7 @@ class R_2_groups_name(baserlib.R_Generic):
     """Delete a node group.
 
     """
-    op = opcodes.OpRemoveGroup(group_name=self.items[0],
+    op = opcodes.OpGroupRemove(group_name=self.items[0],
                                dry_run=bool(self.dryRun()))
 
     return baserlib.SubmitJob([op])
@@ -623,12 +629,14 @@ class R_2_groups_name(baserlib.R_Generic):
 def _ParseModifyGroupRequest(name, data):
   """Parses a request for modifying a node group.
 
-  @rtype: L{opcodes.OpSetGroupParams}
+  @rtype: L{opcodes.OpGroupSetParams}
   @return: Group modify opcode
 
   """
-  alloc_policy = baserlib.CheckParameter(data, "alloc_policy", default=None)
-  return opcodes.OpSetGroupParams(group_name=name, alloc_policy=alloc_policy)
+  return baserlib.FillOpcode(opcodes.OpGroupSetParams, data, {
+    "group_name": name,
+    })
+
 
 
 class R_2_groups_name_modify(baserlib.R_Generic):
@@ -658,15 +666,14 @@ def _ParseRenameGroupRequest(name, data, dry_run):
   @type dry_run: bool
   @param dry_run: whether to perform a dry run
 
-  @rtype: L{opcodes.OpRenameGroup}
+  @rtype: L{opcodes.OpGroupRename}
   @return: Node group rename opcode
 
   """
-  old_name = name
-  new_name = baserlib.CheckParameter(data, "new_name")
-
-  return opcodes.OpRenameGroup(old_name=old_name, new_name=new_name,
-                               dry_run=dry_run)
+  return baserlib.FillOpcode(opcodes.OpGroupRename, data, {
+    "group_name": name,
+    "dry_run": dry_run,
+    })
 
 
 class R_2_groups_name_rename(baserlib.R_Generic):
@@ -695,7 +702,7 @@ class R_2_groups_name_assign_nodes(baserlib.R_Generic):
     @return: a job id
 
     """
-    op = baserlib.FillOpcode(opcodes.OpAssignGroupNodes, self.request_body, {
+    op = baserlib.FillOpcode(opcodes.OpGroupAssignNodes, self.request_body, {
       "group_name": self.items[0],
       "dry_run": self.dryRun(),
       "force": self.useForce(),
@@ -707,103 +714,21 @@ class R_2_groups_name_assign_nodes(baserlib.R_Generic):
 def _ParseInstanceCreateRequestVersion1(data, dry_run):
   """Parses an instance creation request version 1.
 
-  @rtype: L{opcodes.OpCreateInstance}
+  @rtype: L{opcodes.OpInstanceCreate}
   @return: Instance creation opcode
 
   """
-  # Disks
-  disks_input = baserlib.CheckParameter(data, "disks", exptype=list)
-
-  disks = []
-  for idx, i in enumerate(disks_input):
-    baserlib.CheckType(i, dict, "Disk %d specification" % idx)
-
-    # Size is mandatory
-    try:
-      size = i[constants.IDISK_SIZE]
-    except KeyError:
-      raise http.HttpBadRequest("Disk %d specification wrong: missing disk"
-                                " size" % idx)
-
-    disk = {
-      constants.IDISK_SIZE: size,
-      }
-
-    # Optional disk access mode
-    try:
-      disk_access = i[constants.IDISK_MODE]
-    except KeyError:
-      pass
-    else:
-      disk[constants.IDISK_MODE] = disk_access
-
-    disks.append(disk)
+  override = {
+    "dry_run": dry_run,
+    }
 
-  assert len(disks_input) == len(disks)
+  rename = {
+    "os": "os_type",
+    "name": "instance_name",
+    }
 
-  # Network interfaces
-  nics_input = baserlib.CheckParameter(data, "nics", exptype=list)
-
-  nics = []
-  for idx, i in enumerate(nics_input):
-    baserlib.CheckType(i, dict, "NIC %d specification" % idx)
-
-    nic = {}
-
-    for field in constants.INIC_PARAMS:
-      try:
-        value = i[field]
-      except KeyError:
-        continue
-
-      nic[field] = value
-
-    nics.append(nic)
-
-  assert len(nics_input) == len(nics)
-
-  # HV/BE parameters
-  hvparams = baserlib.CheckParameter(data, "hvparams", default={})
-  utils.ForceDictType(hvparams, constants.HVS_PARAMETER_TYPES)
-
-  beparams = baserlib.CheckParameter(data, "beparams", default={})
-  utils.ForceDictType(beparams, constants.BES_PARAMETER_TYPES)
-
-  return opcodes.OpCreateInstance(
-    mode=baserlib.CheckParameter(data, "mode"),
-    instance_name=baserlib.CheckParameter(data, "name"),
-    os_type=baserlib.CheckParameter(data, "os"),
-    osparams=baserlib.CheckParameter(data, "osparams", default={}),
-    force_variant=baserlib.CheckParameter(data, "force_variant",
-                                          default=False),
-    no_install=baserlib.CheckParameter(data, "no_install", default=False),
-    pnode=baserlib.CheckParameter(data, "pnode", default=None),
-    snode=baserlib.CheckParameter(data, "snode", default=None),
-    disk_template=baserlib.CheckParameter(data, "disk_template"),
-    disks=disks,
-    nics=nics,
-    src_node=baserlib.CheckParameter(data, "src_node", default=None),
-    src_path=baserlib.CheckParameter(data, "src_path", default=None),
-    start=baserlib.CheckParameter(data, "start", default=True),
-    wait_for_sync=True,
-    ip_check=baserlib.CheckParameter(data, "ip_check", default=True),
-    name_check=baserlib.CheckParameter(data, "name_check", default=True),
-    file_storage_dir=baserlib.CheckParameter(data, "file_storage_dir",
-                                             default=None),
-    file_driver=baserlib.CheckParameter(data, "file_driver",
-                                        default=constants.FD_LOOP),
-    source_handshake=baserlib.CheckParameter(data, "source_handshake",
-                                             default=None),
-    source_x509_ca=baserlib.CheckParameter(data, "source_x509_ca",
-                                           default=None),
-    source_instance_name=baserlib.CheckParameter(data, "source_instance_name",
-                                                 default=None),
-    iallocator=baserlib.CheckParameter(data, "iallocator", default=None),
-    hypervisor=baserlib.CheckParameter(data, "hypervisor", default=None),
-    hvparams=hvparams,
-    beparams=beparams,
-    dry_run=dry_run,
-    )
+  return baserlib.FillOpcode(opcodes.OpInstanceCreate, data, override,
+                             rename=rename)
 
 
 class R_2_instances(baserlib.R_Generic):
@@ -826,67 +751,6 @@ class R_2_instances(baserlib.R_Generic):
       return baserlib.BuildUriList(instanceslist, "/2/instances/%s",
                                    uri_fields=("id", "uri"))
 
-  def _ParseVersion0CreateRequest(self):
-    """Parses an instance creation request version 0.
-
-    Request data version 0 is deprecated and should not be used anymore.
-
-    @rtype: L{opcodes.OpCreateInstance}
-    @return: Instance creation opcode
-
-    """
-    # Do not modify anymore, request data version 0 is deprecated
-    beparams = baserlib.MakeParamsDict(self.request_body,
-                                       constants.BES_PARAMETERS)
-    hvparams = baserlib.MakeParamsDict(self.request_body,
-                                       constants.HVS_PARAMETERS)
-    fn = self.getBodyParameter
-
-    # disk processing
-    disk_data = fn('disks')
-    if not isinstance(disk_data, list):
-      raise http.HttpBadRequest("The 'disks' parameter should be a list")
-    disks = []
-    for idx, d in enumerate(disk_data):
-      if not isinstance(d, int):
-        raise http.HttpBadRequest("Disk %d specification wrong: should"
-                                  " be an integer" % idx)
-      disks.append({"size": d})
-
-    # nic processing (one nic only)
-    nics = [{"mac": fn("mac", constants.VALUE_AUTO)}]
-    if fn("ip", None) is not None:
-      nics[0]["ip"] = fn("ip")
-    if fn("mode", None) is not None:
-      nics[0]["mode"] = fn("mode")
-    if fn("link", None) is not None:
-      nics[0]["link"] = fn("link")
-    if fn("bridge", None) is not None:
-      nics[0]["bridge"] = fn("bridge")
-
-    # Do not modify anymore, request data version 0 is deprecated
-    return opcodes.OpCreateInstance(
-      mode=constants.INSTANCE_CREATE,
-      instance_name=fn('name'),
-      disks=disks,
-      disk_template=fn('disk_template'),
-      os_type=fn('os'),
-      pnode=fn('pnode', None),
-      snode=fn('snode', None),
-      iallocator=fn('iallocator', None),
-      nics=nics,
-      start=fn('start', True),
-      ip_check=fn('ip_check', True),
-      name_check=fn('name_check', True),
-      wait_for_sync=True,
-      hypervisor=fn('hypervisor', None),
-      hvparams=hvparams,
-      beparams=beparams,
-      file_storage_dir=fn('file_storage_dir', None),
-      file_driver=fn('file_driver', constants.FD_LOOP),
-      dry_run=bool(self.dryRun()),
-      )
-
   def POST(self):
     """Create an instance.
 
@@ -900,10 +764,13 @@ class R_2_instances(baserlib.R_Generic):
     data_version = self.getBodyParameter(_REQ_DATA_VERSION, 0)
 
     if data_version == 0:
-      op = self._ParseVersion0CreateRequest()
+      raise http.HttpBadRequest("Instance creation request version 0 is no"
+                                " longer supported")
     elif data_version == 1:
-      op = _ParseInstanceCreateRequestVersion1(self.request_body,
-                                               self.dryRun())
+      data = self.request_body.copy()
+      # Remove "__version__"
+      data.pop(_REQ_DATA_VERSION, None)
+      op = _ParseInstanceCreateRequestVersion1(data, self.dryRun())
     else:
       raise http.HttpBadRequest("Unsupported request data version %s" %
                                 data_version)
@@ -933,7 +800,7 @@ class R_2_instances_name(baserlib.R_Generic):
     """Delete an instance.
 
     """
-    op = opcodes.OpRemoveInstance(instance_name=self.items[0],
+    op = opcodes.OpInstanceRemove(instance_name=self.items[0],
                                   ignore_failures=False,
                                   dry_run=bool(self.dryRun()))
     return baserlib.SubmitJob([op])
@@ -950,7 +817,7 @@ class R_2_instances_name_info(baserlib.R_Generic):
     instance_name = self.items[0]
     static = bool(self._checkIntVariable("static", default=0))
 
-    op = opcodes.OpQueryInstanceData(instances=[instance_name],
+    op = opcodes.OpInstanceQueryData(instances=[instance_name],
                                      static=static)
     return baserlib.SubmitJob([op])
 
@@ -972,7 +839,7 @@ class R_2_instances_name_reboot(baserlib.R_Generic):
     reboot_type = self.queryargs.get('type',
                                      [constants.INSTANCE_REBOOT_HARD])[0]
     ignore_secondaries = bool(self._checkIntVariable('ignore_secondaries'))
-    op = opcodes.OpRebootInstance(instance_name=instance_name,
+    op = opcodes.OpInstanceReboot(instance_name=instance_name,
                                   reboot_type=reboot_type,
                                   ignore_secondaries=ignore_secondaries,
                                   dry_run=bool(self.dryRun()))
@@ -995,13 +862,26 @@ class R_2_instances_name_startup(baserlib.R_Generic):
     """
     instance_name = self.items[0]
     force_startup = bool(self._checkIntVariable('force'))
-    op = opcodes.OpStartupInstance(instance_name=instance_name,
+    op = opcodes.OpInstanceStartup(instance_name=instance_name,
                                    force=force_startup,
                                    dry_run=bool(self.dryRun()))
 
     return baserlib.SubmitJob([op])
 
 
+def _ParseShutdownInstanceRequest(name, data, dry_run):
+  """Parses a request for an instance shutdown.
+
+  @rtype: L{opcodes.OpInstanceShutdown}
+  @return: Instance shutdown opcode
+
+  """
+  return baserlib.FillOpcode(opcodes.OpInstanceShutdown, data, {
+    "instance_name": name,
+    "dry_run": dry_run,
+    })
+
+
 class R_2_instances_name_shutdown(baserlib.R_Generic):
   """/2/instances/[instance_name]/shutdown resource.
 
@@ -1011,10 +891,13 @@ class R_2_instances_name_shutdown(baserlib.R_Generic):
   def PUT(self):
     """Shutdown an instance.
 
+    @return: a job id
+
     """
-    instance_name = self.items[0]
-    op = opcodes.OpShutdownInstance(instance_name=instance_name,
-                                    dry_run=bool(self.dryRun()))
+    baserlib.CheckType(self.request_body, dict, "Body contents")
+
+    op = _ParseShutdownInstanceRequest(self.items[0], self.request_body,
+                                       bool(self.dryRun()))
 
     return baserlib.SubmitJob([op])
 
@@ -1026,19 +909,19 @@ def _ParseInstanceReinstallRequest(name, data):
   if not isinstance(data, dict):
     raise http.HttpBadRequest("Invalid body contents, not a dictionary")
 
-  ostype = baserlib.CheckParameter(data, "os")
+  ostype = baserlib.CheckParameter(data, "os", default=None)
   start = baserlib.CheckParameter(data, "start", exptype=bool,
                                   default=True)
   osparams = baserlib.CheckParameter(data, "osparams", default=None)
 
   ops = [
-    opcodes.OpShutdownInstance(instance_name=name),
-    opcodes.OpReinstallInstance(instance_name=name, os_type=ostype,
+    opcodes.OpInstanceShutdown(instance_name=name),
+    opcodes.OpInstanceReinstall(instance_name=name, os_type=ostype,
                                 osparams=osparams),
     ]
 
   if start:
-    ops.append(opcodes.OpStartupInstance(instance_name=name, force=False))
+    ops.append(opcodes.OpInstanceStartup(instance_name=name, force=False))
 
   return ops
 
@@ -1062,20 +945,47 @@ class R_2_instances_name_reinstall(baserlib.R_Generic):
         raise http.HttpBadRequest("Can't combine query and body parameters")
 
       body = self.request_body
-    else:
-      if not self.queryargs:
-        raise http.HttpBadRequest("Missing query parameters")
+    elif self.queryargs:
       # Legacy interface, do not modify/extend
       body = {
         "os": self._checkStringVariable("os"),
         "start": not self._checkIntVariable("nostartup"),
         }
+    else:
+      body = {}
 
     ops = _ParseInstanceReinstallRequest(self.items[0], body)
 
     return baserlib.SubmitJob(ops)
 
 
+def _ParseInstanceReplaceDisksRequest(name, data):
+  """Parses a request for an instance export.
+
+  @rtype: L{opcodes.OpInstanceReplaceDisks}
+  @return: Instance export opcode
+
+  """
+  override = {
+    "instance_name": name,
+    }
+
+  # Parse disks
+  try:
+    raw_disks = data["disks"]
+  except KeyError:
+    pass
+  else:
+    if not ht.TListOf(ht.TInt)(raw_disks): # pylint: disable-msg=E1102
+      # Backwards compatibility for strings of the format "1, 2, 3"
+      try:
+        data["disks"] = [int(part) for part in raw_disks.split(",")]
+      except (TypeError, ValueError), err:
+        raise http.HttpBadRequest("Invalid disk index passed: %s" % str(err))
+
+  return baserlib.FillOpcode(opcodes.OpInstanceReplaceDisks, data, override)
+
+
 class R_2_instances_name_replace_disks(baserlib.R_Generic):
   """/2/instances/[instance_name]/replace-disks resource.
 
@@ -1084,25 +994,7 @@ class R_2_instances_name_replace_disks(baserlib.R_Generic):
     """Replaces disks on an instance.
 
     """
-    instance_name = self.items[0]
-    remote_node = self._checkStringVariable("remote_node", default=None)
-    mode = self._checkStringVariable("mode", default=None)
-    raw_disks = self._checkStringVariable("disks", default=None)
-    iallocator = self._checkStringVariable("iallocator", default=None)
-
-    if raw_disks:
-      try:
-        disks = [int(part) for part in raw_disks.split(",")]
-      except ValueError, err:
-        raise http.HttpBadRequest("Invalid disk index passed: %s" % str(err))
-    else:
-      disks = []
-
-    op = opcodes.OpReplaceDisks(instance_name=instance_name,
-                                remote_node=remote_node,
-                                mode=mode,
-                                disks=disks,
-                                iallocator=iallocator)
+    op = _ParseInstanceReplaceDisksRequest(self.items[0], self.request_body)
 
     return baserlib.SubmitJob([op])
 
@@ -1120,7 +1012,7 @@ class R_2_instances_name_activate_disks(baserlib.R_Generic):
     instance_name = self.items[0]
     ignore_size = bool(self._checkIntVariable('ignore_size'))
 
-    op = opcodes.OpActivateInstanceDisks(instance_name=instance_name,
+    op = opcodes.OpInstanceActivateDisks(instance_name=instance_name,
                                          ignore_size=ignore_size)
 
     return baserlib.SubmitJob([op])
@@ -1136,7 +1028,7 @@ class R_2_instances_name_deactivate_disks(baserlib.R_Generic):
     """
     instance_name = self.items[0]
 
-    op = opcodes.OpDeactivateInstanceDisks(instance_name=instance_name)
+    op = opcodes.OpInstanceDeactivateDisks(instance_name=instance_name)
 
     return baserlib.SubmitJob([op])
 
@@ -1167,23 +1059,15 @@ def _ParseExportInstanceRequest(name, data):
   @return: Instance export opcode
 
   """
-  mode = baserlib.CheckParameter(data, "mode",
-                                 default=constants.EXPORT_MODE_LOCAL)
-  target_node = baserlib.CheckParameter(data, "destination")
-  shutdown = baserlib.CheckParameter(data, "shutdown", exptype=bool)
-  remove_instance = baserlib.CheckParameter(data, "remove_instance",
-                                            exptype=bool, default=False)
-  x509_key_name = baserlib.CheckParameter(data, "x509_key_name", default=None)
-  destination_x509_ca = baserlib.CheckParameter(data, "destination_x509_ca",
-                                                default=None)
-
-  return opcodes.OpBackupExport(instance_name=name,
-                                mode=mode,
-                                target_node=target_node,
-                                shutdown=shutdown,
-                                remove_instance=remove_instance,
-                                x509_key_name=x509_key_name,
-                                destination_x509_ca=destination_x509_ca)
+  # Rename "destination" to "target_node"
+  try:
+    data["target_node"] = data.pop("destination")
+  except KeyError:
+    pass
+
+  return baserlib.FillOpcode(opcodes.OpBackupExport, data, {
+    "instance_name": name,
+    })
 
 
 class R_2_instances_name_export(baserlib.R_Generic):
@@ -1207,16 +1091,13 @@ class R_2_instances_name_export(baserlib.R_Generic):
 def _ParseMigrateInstanceRequest(name, data):
   """Parses a request for an instance migration.
 
-  @rtype: L{opcodes.OpMigrateInstance}
+  @rtype: L{opcodes.OpInstanceMigrate}
   @return: Instance migration opcode
 
   """
-  mode = baserlib.CheckParameter(data, "mode", default=None)
-  cleanup = baserlib.CheckParameter(data, "cleanup", exptype=bool,
-                                    default=False)
-
-  return opcodes.OpMigrateInstance(instance_name=name, mode=mode,
-                                   cleanup=cleanup)
+  return baserlib.FillOpcode(opcodes.OpInstanceMigrate, data, {
+    "instance_name": name,
+    })
 
 
 class R_2_instances_name_migrate(baserlib.R_Generic):
@@ -1239,16 +1120,13 @@ class R_2_instances_name_migrate(baserlib.R_Generic):
 def _ParseRenameInstanceRequest(name, data):
   """Parses a request for renaming an instance.
 
-  @rtype: L{opcodes.OpRenameInstance}
+  @rtype: L{opcodes.OpInstanceRename}
   @return: Instance rename opcode
 
   """
-  new_name = baserlib.CheckParameter(data, "new_name")
-  ip_check = baserlib.CheckParameter(data, "ip_check", default=True)
-  name_check = baserlib.CheckParameter(data, "name_check", default=True)
-
-  return opcodes.OpRenameInstance(instance_name=name, new_name=new_name,
-                                  name_check=name_check, ip_check=ip_check)
+  return baserlib.FillOpcode(opcodes.OpInstanceRename, data, {
+    "instance_name": name,
+    })
 
 
 class R_2_instances_name_rename(baserlib.R_Generic):
@@ -1271,34 +1149,13 @@ class R_2_instances_name_rename(baserlib.R_Generic):
 def _ParseModifyInstanceRequest(name, data):
   """Parses a request for modifying an instance.
 
-  @rtype: L{opcodes.OpSetInstanceParams}
+  @rtype: L{opcodes.OpInstanceSetParams}
   @return: Instance modify opcode
 
   """
-  osparams = baserlib.CheckParameter(data, "osparams", default={})
-  force = baserlib.CheckParameter(data, "force", default=False)
-  nics = baserlib.CheckParameter(data, "nics", default=[])
-  disks = baserlib.CheckParameter(data, "disks", default=[])
-  disk_template = baserlib.CheckParameter(data, "disk_template", default=None)
-  remote_node = baserlib.CheckParameter(data, "remote_node", default=None)
-  os_name = baserlib.CheckParameter(data, "os_name", default=None)
-  force_variant = baserlib.CheckParameter(data, "force_variant", default=False)
-
-  # HV/BE parameters
-  hvparams = baserlib.CheckParameter(data, "hvparams", default={})
-  utils.ForceDictType(hvparams, constants.HVS_PARAMETER_TYPES,
-                      allowed_values=[constants.VALUE_DEFAULT])
-
-  beparams = baserlib.CheckParameter(data, "beparams", default={})
-  utils.ForceDictType(beparams, constants.BES_PARAMETER_TYPES,
-                      allowed_values=[constants.VALUE_DEFAULT])
-
-  return opcodes.OpSetInstanceParams(instance_name=name, hvparams=hvparams,
-                                     beparams=beparams, osparams=osparams,
-                                     force=force, nics=nics, disks=disks,
-                                     disk_template=disk_template,
-                                     remote_node=remote_node, os_name=os_name,
-                                     force_variant=force_variant)
+  return baserlib.FillOpcode(opcodes.OpInstanceSetParams, data, {
+    "instance_name": name,
+    })
 
 
 class R_2_instances_name_modify(baserlib.R_Generic):
@@ -1328,7 +1185,7 @@ class R_2_instances_name_disk_grow(baserlib.R_Generic):
     @return: a job id
 
     """
-    op = baserlib.FillOpcode(opcodes.OpGrowDisk, self.request_body, {
+    op = baserlib.FillOpcode(opcodes.OpInstanceGrowDisk, self.request_body, {
       "instance_name": self.items[0],
       "disk": int(self.items[1]),
       })
@@ -1336,6 +1193,105 @@ class R_2_instances_name_disk_grow(baserlib.R_Generic):
     return baserlib.SubmitJob([op])
 
 
+class R_2_instances_name_console(baserlib.R_Generic):
+  """/2/instances/[instance_name]/console resource.
+
+  """
+  GET_ACCESS = [rapi.RAPI_ACCESS_WRITE]
+
+  def GET(self):
+    """Request information for connecting to instance's console.
+
+    @return: Serialized instance console description, see
+             L{objects.InstanceConsole}
+
+    """
+    client = baserlib.GetClient()
+
+    ((console, ), ) = client.QueryInstances([self.items[0]], ["console"], False)
+
+    if console is None:
+      raise http.HttpServiceUnavailable("Instance console unavailable")
+
+    assert isinstance(console, dict)
+    return console
+
+
+def _GetQueryFields(args):
+  """
+
+  """
+  try:
+    fields = args["fields"]
+  except KeyError:
+    raise http.HttpBadRequest("Missing 'fields' query argument")
+
+  return _SplitQueryFields(fields[0])
+
+
+def _SplitQueryFields(fields):
+  """
+
+  """
+  return [i.strip() for i in fields.split(",")]
+
+
+class R_2_query(baserlib.R_Generic):
+  """/2/query/[resource] resource.
+
+  """
+  # Results might contain sensitive information
+  GET_ACCESS = [rapi.RAPI_ACCESS_WRITE]
+
+  def _Query(self, fields, filter_):
+    return baserlib.GetClient().Query(self.items[0], fields, filter_).ToDict()
+
+  def GET(self):
+    """Returns resource information.
+
+    @return: Query result, see L{objects.QueryResponse}
+
+    """
+    return self._Query(_GetQueryFields(self.queryargs), None)
+
+  def PUT(self):
+    """Submits job querying for resources.
+
+    @return: Query result, see L{objects.QueryResponse}
+
+    """
+    body = self.request_body
+
+    baserlib.CheckType(body, dict, "Body contents")
+
+    try:
+      fields = body["fields"]
+    except KeyError:
+      fields = _GetQueryFields(self.queryargs)
+
+    return self._Query(fields, self.request_body.get("filter", None))
+
+
+class R_2_query_fields(baserlib.R_Generic):
+  """/2/query/[resource]/fields resource.
+
+  """
+  def GET(self):
+    """Retrieves list of available fields for a resource.
+
+    @return: List of serialized L{objects.QueryFieldDefinition}
+
+    """
+    try:
+      raw_fields = self.queryargs["fields"]
+    except KeyError:
+      fields = None
+    else:
+      fields = _SplitQueryFields(raw_fields[0])
+
+    return baserlib.GetClient().QueryFields(self.items[0], fields).ToDict()
+
+
 class _R_Tags(baserlib.R_Generic):
   """ Quasiclass for tagging resources