code.grnet.gr Git - ganeti-local/blob - lib/opcodes.py

   1 #
   2 #
   3
   4 # Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Google Inc.
   5 #
   6 # This program is free software; you can redistribute it and/or modify
   7 # it under the terms of the GNU General Public License as published by
   8 # the Free Software Foundation; either version 2 of the License, or
   9 # (at your option) any later version.
  10 #
  11 # This program is distributed in the hope that it will be useful, but
  12 # WITHOUT ANY WARRANTY; without even the implied warranty of
  13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 # General Public License for more details.
  15 #
  16 # You should have received a copy of the GNU General Public License
  17 # along with this program; if not, write to the Free Software
  18 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19 # 02110-1301, USA.
  20
  21
  22 """OpCodes module
  23
  24 This module implements the data structures which define the cluster
  25 operations - the so-called opcodes.
  26
  27 Every operation which modifies the cluster state is expressed via
  28 opcodes.
  29
  30 """
  31
  32 # this are practically structures, so disable the message about too
  33 # few public methods:
  34 # pylint: disable=R0903
  35
  36 import logging
  37 import re
  38
  39 from ganeti import constants
  40 from ganeti import errors
  41 from ganeti import ht
  42 from ganeti import objects
  43 from ganeti import objectutils
  44
  45
  46 # Common opcode attributes
  47
  48 #: output fields for a query operation
  49 _POutputFields = ("output_fields", ht.NoDefault, ht.TListOf(ht.TNonEmptyString),
  50                   "Selected output fields")
  51
  52 #: the shutdown timeout
  53 _PShutdownTimeout = \
  54   ("shutdown_timeout", constants.DEFAULT_SHUTDOWN_TIMEOUT, ht.TPositiveInt,
  55    "How long to wait for instance to shut down")
  56
  57 #: the force parameter
  58 _PForce = ("force", False, ht.TBool, "Whether to force the operation")
  59
  60 #: a required instance name (for single-instance LUs)
  61 _PInstanceName = ("instance_name", ht.NoDefault, ht.TNonEmptyString,
  62                   "Instance name")
  63
  64 #: Whether to ignore offline nodes
  65 _PIgnoreOfflineNodes = ("ignore_offline_nodes", False, ht.TBool,
  66                         "Whether to ignore offline nodes")
  67
  68 #: a required node name (for single-node LUs)
  69 _PNodeName = ("node_name", ht.NoDefault, ht.TNonEmptyString, "Node name")
  70
  71 #: a required node group name (for single-group LUs)
  72 _PGroupName = ("group_name", ht.NoDefault, ht.TNonEmptyString, "Group name")
  73
  74 #: Migration type (live/non-live)
  75 _PMigrationMode = ("mode", None,
  76                    ht.TOr(ht.TNone, ht.TElemOf(constants.HT_MIGRATION_MODES)),
  77                    "Migration mode")
  78
  79 #: Obsolete 'live' migration mode (boolean)
  80 _PMigrationLive = ("live", None, ht.TMaybeBool,
  81                    "Legacy setting for live migration, do not use")
  82
  83 #: Tag type
  84 _PTagKind = ("kind", ht.NoDefault, ht.TElemOf(constants.VALID_TAG_TYPES),
  85              "Tag kind")
  86
  87 #: List of tag strings
  88 _PTags = ("tags", ht.NoDefault, ht.TListOf(ht.TNonEmptyString),
  89           "List of tag names")
  90
  91 _PForceVariant = ("force_variant", False, ht.TBool,
  92                   "Whether to force an unknown OS variant")
  93
  94 _PWaitForSync = ("wait_for_sync", True, ht.TBool,
  95                  "Whether to wait for the disk to synchronize")
  96
  97 _PWaitForSyncFalse = ("wait_for_sync", False, ht.TBool,
  98                       "Whether to wait for the disk to synchronize"
  99                       " (defaults to false)")
 100
 101 _PIgnoreConsistency = ("ignore_consistency", False, ht.TBool,
 102                        "Whether to ignore disk consistency")
 103
 104 _PStorageName = ("name", ht.NoDefault, ht.TMaybeString, "Storage name")
 105
 106 _PUseLocking = ("use_locking", False, ht.TBool,
 107                 "Whether to use synchronization")
 108
 109 _PNameCheck = ("name_check", True, ht.TBool, "Whether to check name")
 110
 111 _PNodeGroupAllocPolicy = \
 112   ("alloc_policy", None,
 113    ht.TOr(ht.TNone, ht.TElemOf(constants.VALID_ALLOC_POLICIES)),
 114    "Instance allocation policy")
 115
 116 _PGroupNodeParams = ("ndparams", None, ht.TMaybeDict,
 117                      "Default node parameters for group")
 118
 119 _PQueryWhat = ("what", ht.NoDefault, ht.TElemOf(constants.QR_VIA_OP),
 120                "Resource(s) to query for")
 121
 122 _PEarlyRelease = ("early_release", False, ht.TBool,
 123                   "Whether to release locks as soon as possible")
 124
 125 _PIpCheckDoc = "Whether to ensure instance's IP address is inactive"
 126
 127 #: Do not remember instance state changes
 128 _PNoRemember = ("no_remember", False, ht.TBool,
 129                 "Do not remember the state change")
 130
 131 #: Target node for instance migration/failover
 132 _PMigrationTargetNode = ("target_node", None, ht.TMaybeString,
 133                          "Target node for shared-storage instances")
 134
 135 _PStartupPaused = ("startup_paused", False, ht.TBool,
 136                    "Pause instance at startup")
 137
 138 _PVerbose = ("verbose", False, ht.TBool, "Verbose mode")
 139
 140 # Parameters for cluster verification
 141 _PDebugSimulateErrors = ("debug_simulate_errors", False, ht.TBool,
 142                          "Whether to simulate errors (useful for debugging)")
 143 _PErrorCodes = ("error_codes", False, ht.TBool, "Error codes")
 144 _PSkipChecks = ("skip_checks", ht.EmptyList,
 145                 ht.TListOf(ht.TElemOf(constants.VERIFY_OPTIONAL_CHECKS)),
 146                 "Which checks to skip")
 147 _PIgnoreErrors = ("ignore_errors", ht.EmptyList,
 148                   ht.TListOf(ht.TElemOf(constants.CV_ALL_ECODES_STRINGS)),
 149                   "List of error codes that should be treated as warnings")
 150
 151 # Disk parameters
 152 _PDiskParams = ("diskparams", None,
 153                 ht.TOr(
 154                   ht.TDictOf(ht.TElemOf(constants.DISK_TEMPLATES), ht.TDict),
 155                   ht.TNone),
 156                 "Disk templates' parameter defaults")
 157
 158 # Parameters for node resource model
 159 _PHvState = ("hv_state", None, ht.TMaybeDict, "Set hypervisor states")
 160 _PDiskState = ("disk_state", None, ht.TMaybeDict, "Set disk states")
 161
 162
 163 _PIgnoreIpolicy = ("ignore_ipolicy", False, ht.TBool,
 164                    "Whether to ignore ipolicy violations")
 165
 166 # Allow runtime changes while migrating
 167 _PAllowRuntimeChgs = ("allow_runtime_changes", True, ht.TBool,
 168                       "Allow runtime changes (eg. memory ballooning)")
 169
 170
 171 #: OP_ID conversion regular expression
 172 _OPID_RE = re.compile("([a-z])([A-Z])")
 173
 174 #: Utility function for L{OpClusterSetParams}
 175 _TestClusterOsListItem = \
 176   ht.TAnd(ht.TIsLength(2), ht.TItems([
 177     ht.TElemOf(constants.DDMS_VALUES),
 178     ht.TNonEmptyString,
 179     ]))
 180
 181 _TestClusterOsList = ht.TMaybeListOf(_TestClusterOsListItem)
 182
 183 # TODO: Generate check from constants.INIC_PARAMS_TYPES
 184 #: Utility function for testing NIC definitions
 185 _TestNicDef = \
 186   ht.Comment("NIC parameters")(ht.TDictOf(ht.TElemOf(constants.INIC_PARAMS),
 187                                           ht.TOr(ht.TNone, ht.TNonEmptyString)))
 188
 189 _TSetParamsResultItemItems = [
 190   ht.Comment("name of changed parameter")(ht.TNonEmptyString),
 191   ht.Comment("new value")(ht.TAny),
 192   ]
 193
 194 _TSetParamsResult = \
 195   ht.TListOf(ht.TAnd(ht.TIsLength(len(_TSetParamsResultItemItems)),
 196                      ht.TItems(_TSetParamsResultItemItems)))
 197
 198 # TODO: Generate check from constants.IDISK_PARAMS_TYPES (however, not all users
 199 # of this check support all parameters)
 200 _TDiskParams = \
 201   ht.Comment("Disk parameters")(ht.TDictOf(ht.TElemOf(constants.IDISK_PARAMS),
 202                                            ht.TOr(ht.TNonEmptyString, ht.TInt)))
 203
 204 _TQueryRow = \
 205   ht.TListOf(ht.TAnd(ht.TIsLength(2),
 206                      ht.TItems([ht.TElemOf(constants.RS_ALL),
 207                                 ht.TAny])))
 208
 209 _TQueryResult = ht.TListOf(_TQueryRow)
 210
 211 _TOldQueryRow = ht.TListOf(ht.TAny)
 212
 213 _TOldQueryResult = ht.TListOf(_TOldQueryRow)
 214
 215
 216 _SUMMARY_PREFIX = {
 217   "CLUSTER_": "C_",
 218   "GROUP_": "G_",
 219   "NODE_": "N_",
 220   "INSTANCE_": "I_",
 221   }
 222
 223 #: Attribute name for dependencies
 224 DEPEND_ATTR = "depends"
 225
 226 #: Attribute name for comment
 227 COMMENT_ATTR = "comment"
 228
 229
 230 def _NameToId(name):
 231   """Convert an opcode class name to an OP_ID.
 232
 233   @type name: string
 234   @param name: the class name, as OpXxxYyy
 235   @rtype: string
 236   @return: the name in the OP_XXXX_YYYY format
 237
 238   """
 239   if not name.startswith("Op"):
 240     return None
 241   # Note: (?<=[a-z])(?=[A-Z]) would be ideal, since it wouldn't
 242   # consume any input, and hence we would just have all the elements
 243   # in the list, one by one; but it seems that split doesn't work on
 244   # non-consuming input, hence we have to process the input string a
 245   # bit
 246   name = _OPID_RE.sub(r"\1,\2", name)
 247   elems = name.split(",")
 248   return "_".join(n.upper() for n in elems)
 249
 250
 251 def _GenerateObjectTypeCheck(obj, fields_types):
 252   """Helper to generate type checks for objects.
 253
 254   @param obj: The object to generate type checks
 255   @param fields_types: The fields and their types as a dict
 256   @return: A ht type check function
 257
 258   """
 259   assert set(obj.GetAllSlots()) == set(fields_types.keys()), \
 260     "%s != %s" % (set(obj.GetAllSlots()), set(fields_types.keys()))
 261   return ht.TStrictDict(True, True, fields_types)
 262
 263
 264 _TQueryFieldDef = \
 265   _GenerateObjectTypeCheck(objects.QueryFieldDefinition, {
 266     "name": ht.TNonEmptyString,
 267     "title": ht.TNonEmptyString,
 268     "kind": ht.TElemOf(constants.QFT_ALL),
 269     "doc": ht.TNonEmptyString,
 270     })
 271
 272
 273 def RequireFileStorage():
 274   """Checks that file storage is enabled.
 275
 276   While it doesn't really fit into this module, L{utils} was deemed too large
 277   of a dependency to be imported for just one or two functions.
 278
 279   @raise errors.OpPrereqError: when file storage is disabled
 280
 281   """
 282   if not constants.ENABLE_FILE_STORAGE:
 283     raise errors.OpPrereqError("File storage disabled at configure time",
 284                                errors.ECODE_INVAL)
 285
 286
 287 def RequireSharedFileStorage():
 288   """Checks that shared file storage is enabled.
 289
 290   While it doesn't really fit into this module, L{utils} was deemed too large
 291   of a dependency to be imported for just one or two functions.
 292
 293   @raise errors.OpPrereqError: when shared file storage is disabled
 294
 295   """
 296   if not constants.ENABLE_SHARED_FILE_STORAGE:
 297     raise errors.OpPrereqError("Shared file storage disabled at"
 298                                " configure time", errors.ECODE_INVAL)
 299
 300
 301 @ht.WithDesc("CheckFileStorage")
 302 def _CheckFileStorage(value):
 303   """Ensures file storage is enabled if used.
 304
 305   """
 306   if value == constants.DT_FILE:
 307     RequireFileStorage()
 308   elif value == constants.DT_SHARED_FILE:
 309     RequireSharedFileStorage()
 310   return True
 311
 312
 313 def _BuildDiskTemplateCheck(accept_none):
 314   """Builds check for disk template.
 315
 316   @type accept_none: bool
 317   @param accept_none: whether to accept None as a correct value
 318   @rtype: callable
 319
 320   """
 321   template_check = ht.TElemOf(constants.DISK_TEMPLATES)
 322
 323   if accept_none:
 324     template_check = ht.TOr(template_check, ht.TNone)
 325
 326   return ht.TAnd(template_check, _CheckFileStorage)
 327
 328
 329 def _CheckStorageType(storage_type):
 330   """Ensure a given storage type is valid.
 331
 332   """
 333   if storage_type not in constants.VALID_STORAGE_TYPES:
 334     raise errors.OpPrereqError("Unknown storage type: %s" % storage_type,
 335                                errors.ECODE_INVAL)
 336   if storage_type == constants.ST_FILE:
 337     RequireFileStorage()
 338   return True
 339
 340
 341 #: Storage type parameter
 342 _PStorageType = ("storage_type", ht.NoDefault, _CheckStorageType,
 343                  "Storage type")
 344
 345
 346 class _AutoOpParamSlots(objectutils.AutoSlots):
 347   """Meta class for opcode definitions.
 348
 349   """
 350   def __new__(mcs, name, bases, attrs):
 351     """Called when a class should be created.
 352
 353     @param mcs: The meta class
 354     @param name: Name of created class
 355     @param bases: Base classes
 356     @type attrs: dict
 357     @param attrs: Class attributes
 358
 359     """
 360     assert "OP_ID" not in attrs, "Class '%s' defining OP_ID" % name
 361
 362     slots = mcs._GetSlots(attrs)
 363     assert "OP_DSC_FIELD" not in attrs or attrs["OP_DSC_FIELD"] in slots, \
 364       "Class '%s' uses unknown field in OP_DSC_FIELD" % name
 365
 366     attrs["OP_ID"] = _NameToId(name)
 367
 368     return objectutils.AutoSlots.__new__(mcs, name, bases, attrs)
 369
 370   @classmethod
 371   def _GetSlots(mcs, attrs):
 372     """Build the slots out of OP_PARAMS.
 373
 374     """
 375     # Always set OP_PARAMS to avoid duplicates in BaseOpCode.GetAllParams
 376     params = attrs.setdefault("OP_PARAMS", [])
 377
 378     # Use parameter names as slots
 379     return [pname for (pname, _, _, _) in params]
 380
 381
 382 class BaseOpCode(objectutils.ValidatedSlots):
 383   """A simple serializable object.
 384
 385   This object serves as a parent class for OpCode without any custom
 386   field handling.
 387
 388   """
 389   # pylint: disable=E1101
 390   # as OP_ID is dynamically defined
 391   __metaclass__ = _AutoOpParamSlots
 392
 393   def __getstate__(self):
 394     """Generic serializer.
 395
 396     This method just returns the contents of the instance as a
 397     dictionary.
 398
 399     @rtype:  C{dict}
 400     @return: the instance attributes and their values
 401
 402     """
 403     state = {}
 404     for name in self.GetAllSlots():
 405       if hasattr(self, name):
 406         state[name] = getattr(self, name)
 407     return state
 408
 409   def __setstate__(self, state):
 410     """Generic unserializer.
 411
 412     This method just restores from the serialized state the attributes
 413     of the current instance.
 414
 415     @param state: the serialized opcode data
 416     @type state:  C{dict}
 417
 418     """
 419     if not isinstance(state, dict):
 420       raise ValueError("Invalid data to __setstate__: expected dict, got %s" %
 421                        type(state))
 422
 423     for name in self.GetAllSlots():
 424       if name not in state and hasattr(self, name):
 425         delattr(self, name)
 426
 427     for name in state:
 428       setattr(self, name, state[name])
 429
 430   @classmethod
 431   def GetAllParams(cls):
 432     """Compute list of all parameters for an opcode.
 433
 434     """
 435     slots = []
 436     for parent in cls.__mro__:
 437       slots.extend(getattr(parent, "OP_PARAMS", []))
 438     return slots
 439
 440   def Validate(self, set_defaults): # pylint: disable=W0221
 441     """Validate opcode parameters, optionally setting default values.
 442
 443     @type set_defaults: bool
 444     @param set_defaults: Whether to set default values
 445     @raise errors.OpPrereqError: When a parameter value doesn't match
 446                                  requirements
 447
 448     """
 449     for (attr_name, default, test, _) in self.GetAllParams():
 450       assert test == ht.NoType or callable(test)
 451
 452       if not hasattr(self, attr_name):
 453         if default == ht.NoDefault:
 454           raise errors.OpPrereqError("Required parameter '%s.%s' missing" %
 455                                      (self.OP_ID, attr_name),
 456                                      errors.ECODE_INVAL)
 457         elif set_defaults:
 458           if callable(default):
 459             dval = default()
 460           else:
 461             dval = default
 462           setattr(self, attr_name, dval)
 463
 464       if test == ht.NoType:
 465         # no tests here
 466         continue
 467
 468       if set_defaults or hasattr(self, attr_name):
 469         attr_val = getattr(self, attr_name)
 470         if not test(attr_val):
 471           logging.error("OpCode %s, parameter %s, has invalid type %s/value %s",
 472                         self.OP_ID, attr_name, type(attr_val), attr_val)
 473           raise errors.OpPrereqError("Parameter '%s.%s' fails validation" %
 474                                      (self.OP_ID, attr_name),
 475                                      errors.ECODE_INVAL)
 476
 477
 478 def _BuildJobDepCheck(relative):
 479   """Builds check for job dependencies (L{DEPEND_ATTR}).
 480
 481   @type relative: bool
 482   @param relative: Whether to accept relative job IDs (negative)
 483   @rtype: callable
 484
 485   """
 486   if relative:
 487     job_id = ht.TOr(ht.TJobId, ht.TRelativeJobId)
 488   else:
 489     job_id = ht.TJobId
 490
 491   job_dep = \
 492     ht.TAnd(ht.TIsLength(2),
 493             ht.TItems([job_id,
 494                        ht.TListOf(ht.TElemOf(constants.JOBS_FINALIZED))]))
 495
 496   return ht.TMaybeListOf(job_dep)
 497
 498
 499 TNoRelativeJobDependencies = _BuildJobDepCheck(False)
 500
 501 #: List of submission status and job ID as returned by C{SubmitManyJobs}
 502 _TJobIdListItem = \
 503   ht.TAnd(ht.TIsLength(2),
 504           ht.TItems([ht.Comment("success")(ht.TBool),
 505                      ht.Comment("Job ID if successful, error message"
 506                                 " otherwise")(ht.TOr(ht.TString,
 507                                                      ht.TJobId))]))
 508 TJobIdList = ht.TListOf(_TJobIdListItem)
 509
 510 #: Result containing only list of submitted jobs
 511 TJobIdListOnly = ht.TStrictDict(True, True, {
 512   constants.JOB_IDS_KEY: ht.Comment("List of submitted jobs")(TJobIdList),
 513   })
 514
 515
 516 class OpCode(BaseOpCode):
 517   """Abstract OpCode.
 518
 519   This is the root of the actual OpCode hierarchy. All clases derived
 520   from this class should override OP_ID.
 521
 522   @cvar OP_ID: The ID of this opcode. This should be unique amongst all
 523                children of this class.
 524   @cvar OP_DSC_FIELD: The name of a field whose value will be included in the
 525                       string returned by Summary(); see the docstring of that
 526                       method for details).
 527   @cvar OP_PARAMS: List of opcode attributes, the default values they should
 528                    get if not already defined, and types they must match.
 529   @cvar OP_RESULT: Callable to verify opcode result
 530   @cvar WITH_LU: Boolean that specifies whether this should be included in
 531       mcpu's dispatch table
 532   @ivar dry_run: Whether the LU should be run in dry-run mode, i.e. just
 533                  the check steps
 534   @ivar priority: Opcode priority for queue
 535
 536   """
 537   # pylint: disable=E1101
 538   # as OP_ID is dynamically defined
 539   WITH_LU = True
 540   OP_PARAMS = [
 541     ("dry_run", None, ht.TMaybeBool, "Run checks only, don't execute"),
 542     ("debug_level", None, ht.TOr(ht.TNone, ht.TPositiveInt), "Debug level"),
 543     ("priority", constants.OP_PRIO_DEFAULT,
 544      ht.TElemOf(constants.OP_PRIO_SUBMIT_VALID), "Opcode priority"),
 545     (DEPEND_ATTR, None, _BuildJobDepCheck(True),
 546      "Job dependencies; if used through ``SubmitManyJobs`` relative (negative)"
 547      " job IDs can be used; see :doc:`design document <design-chained-jobs>`"
 548      " for details"),
 549     (COMMENT_ATTR, None, ht.TMaybeString,
 550      "Comment describing the purpose of the opcode"),
 551     ]
 552   OP_RESULT = None
 553
 554   def __getstate__(self):
 555     """Specialized getstate for opcodes.
 556
 557     This method adds to the state dictionary the OP_ID of the class,
 558     so that on unload we can identify the correct class for
 559     instantiating the opcode.
 560
 561     @rtype:   C{dict}
 562     @return:  the state as a dictionary
 563
 564     """
 565     data = BaseOpCode.__getstate__(self)
 566     data["OP_ID"] = self.OP_ID
 567     return data
 568
 569   @classmethod
 570   def LoadOpCode(cls, data):
 571     """Generic load opcode method.
 572
 573     The method identifies the correct opcode class from the dict-form
 574     by looking for a OP_ID key, if this is not found, or its value is
 575     not available in this module as a child of this class, we fail.
 576
 577     @type data:  C{dict}
 578     @param data: the serialized opcode
 579
 580     """
 581     if not isinstance(data, dict):
 582       raise ValueError("Invalid data to LoadOpCode (%s)" % type(data))
 583     if "OP_ID" not in data:
 584       raise ValueError("Invalid data to LoadOpcode, missing OP_ID")
 585     op_id = data["OP_ID"]
 586     op_class = None
 587     if op_id in OP_MAPPING:
 588       op_class = OP_MAPPING[op_id]
 589     else:
 590       raise ValueError("Invalid data to LoadOpCode: OP_ID %s unsupported" %
 591                        op_id)
 592     op = op_class()
 593     new_data = data.copy()
 594     del new_data["OP_ID"]
 595     op.__setstate__(new_data)
 596     return op
 597
 598   def Summary(self):
 599     """Generates a summary description of this opcode.
 600
 601     The summary is the value of the OP_ID attribute (without the "OP_"
 602     prefix), plus the value of the OP_DSC_FIELD attribute, if one was
 603     defined; this field should allow to easily identify the operation
 604     (for an instance creation job, e.g., it would be the instance
 605     name).
 606
 607     """
 608     assert self.OP_ID is not None and len(self.OP_ID) > 3
 609     # all OP_ID start with OP_, we remove that
 610     txt = self.OP_ID[3:]
 611     field_name = getattr(self, "OP_DSC_FIELD", None)
 612     if field_name:
 613       field_value = getattr(self, field_name, None)
 614       if isinstance(field_value, (list, tuple)):
 615         field_value = ",".join(str(i) for i in field_value)
 616       txt = "%s(%s)" % (txt, field_value)
 617     return txt
 618
 619   def TinySummary(self):
 620     """Generates a compact summary description of the opcode.
 621
 622     """
 623     assert self.OP_ID.startswith("OP_")
 624
 625     text = self.OP_ID[3:]
 626
 627     for (prefix, supplement) in _SUMMARY_PREFIX.items():
 628       if text.startswith(prefix):
 629         return supplement + text[len(prefix):]
 630
 631     return text
 632
 633
 634 # cluster opcodes
 635
 636 class OpClusterPostInit(OpCode):
 637   """Post cluster initialization.
 638
 639   This opcode does not touch the cluster at all. Its purpose is to run hooks
 640   after the cluster has been initialized.
 641
 642   """
 643   OP_RESULT = ht.TBool
 644
 645
 646 class OpClusterDestroy(OpCode):
 647   """Destroy the cluster.
 648
 649   This opcode has no other parameters. All the state is irreversibly
 650   lost after the execution of this opcode.
 651
 652   """
 653   OP_RESULT = ht.TNonEmptyString
 654
 655
 656 class OpClusterQuery(OpCode):
 657   """Query cluster information."""
 658   OP_RESULT = ht.TDictOf(ht.TNonEmptyString, ht.TAny)
 659
 660
 661 class OpClusterVerify(OpCode):
 662   """Submits all jobs necessary to verify the cluster.
 663
 664   """
 665   OP_PARAMS = [
 666     _PDebugSimulateErrors,
 667     _PErrorCodes,
 668     _PSkipChecks,
 669     _PIgnoreErrors,
 670     _PVerbose,
 671     ("group_name", None, ht.TMaybeString, "Group to verify")
 672     ]
 673   OP_RESULT = TJobIdListOnly
 674
 675
 676 class OpClusterVerifyConfig(OpCode):
 677   """Verify the cluster config.
 678
 679   """
 680   OP_PARAMS = [
 681     _PDebugSimulateErrors,
 682     _PErrorCodes,
 683     _PIgnoreErrors,
 684     _PVerbose,
 685     ]
 686   OP_RESULT = ht.TBool
 687
 688
 689 class OpClusterVerifyGroup(OpCode):
 690   """Run verify on a node group from the cluster.
 691
 692   @type skip_checks: C{list}
 693   @ivar skip_checks: steps to be skipped from the verify process; this
 694                      needs to be a subset of
 695                      L{constants.VERIFY_OPTIONAL_CHECKS}; currently
 696                      only L{constants.VERIFY_NPLUSONE_MEM} can be passed
 697
 698   """
 699   OP_DSC_FIELD = "group_name"
 700   OP_PARAMS = [
 701     _PGroupName,
 702     _PDebugSimulateErrors,
 703     _PErrorCodes,
 704     _PSkipChecks,
 705     _PIgnoreErrors,
 706     _PVerbose,
 707     ]
 708   OP_RESULT = ht.TBool
 709
 710
 711 class OpClusterVerifyDisks(OpCode):
 712   """Verify the cluster disks.
 713
 714   """
 715   OP_RESULT = TJobIdListOnly
 716
 717
 718 class OpGroupVerifyDisks(OpCode):
 719   """Verifies the status of all disks in a node group.
 720
 721   Result: a tuple of three elements:
 722     - dict of node names with issues (values: error msg)
 723     - list of instances with degraded disks (that should be activated)
 724     - dict of instances with missing logical volumes (values: (node, vol)
 725       pairs with details about the missing volumes)
 726
 727   In normal operation, all lists should be empty. A non-empty instance
 728   list (3rd element of the result) is still ok (errors were fixed) but
 729   non-empty node list means some node is down, and probably there are
 730   unfixable drbd errors.
 731
 732   Note that only instances that are drbd-based are taken into
 733   consideration. This might need to be revisited in the future.
 734
 735   """
 736   OP_DSC_FIELD = "group_name"
 737   OP_PARAMS = [
 738     _PGroupName,
 739     ]
 740   OP_RESULT = \
 741     ht.TAnd(ht.TIsLength(3),
 742             ht.TItems([ht.TDictOf(ht.TString, ht.TString),
 743                        ht.TListOf(ht.TString),
 744                        ht.TDictOf(ht.TString,
 745                                   ht.TListOf(ht.TListOf(ht.TString)))]))
 746
 747
 748 class OpClusterRepairDiskSizes(OpCode):
 749   """Verify the disk sizes of the instances and fixes configuration
 750   mimatches.
 751
 752   Parameters: optional instances list, in case we want to restrict the
 753   checks to only a subset of the instances.
 754
 755   Result: a list of tuples, (instance, disk, new-size) for changed
 756   configurations.
 757
 758   In normal operation, the list should be empty.
 759
 760   @type instances: list
 761   @ivar instances: the list of instances to check, or empty for all instances
 762
 763   """
 764   OP_PARAMS = [
 765     ("instances", ht.EmptyList, ht.TListOf(ht.TNonEmptyString), None),
 766     ]
 767   OP_RESULT = ht.TListOf(ht.TAnd(ht.TIsLength(3),
 768                                  ht.TItems([ht.TNonEmptyString,
 769                                             ht.TPositiveInt,
 770                                             ht.TPositiveInt])))
 771
 772
 773 class OpClusterConfigQuery(OpCode):
 774   """Query cluster configuration values."""
 775   OP_PARAMS = [
 776     _POutputFields
 777     ]
 778   OP_RESULT = ht.TListOf(ht.TAny)
 779
 780
 781 class OpClusterRename(OpCode):
 782   """Rename the cluster.
 783
 784   @type name: C{str}
 785   @ivar name: The new name of the cluster. The name and/or the master IP
 786               address will be changed to match the new name and its IP
 787               address.
 788
 789   """
 790   OP_DSC_FIELD = "name"
 791   OP_PARAMS = [
 792     ("name", ht.NoDefault, ht.TNonEmptyString, None),
 793     ]
 794   OP_RESULT = ht.TNonEmptyString
 795
 796
 797 class OpClusterSetParams(OpCode):
 798   """Change the parameters of the cluster.
 799
 800   @type vg_name: C{str} or C{None}
 801   @ivar vg_name: The new volume group name or None to disable LVM usage.
 802
 803   """
 804   OP_PARAMS = [
 805     _PHvState,
 806     _PDiskState,
 807     ("vg_name", None, ht.TMaybeString, "Volume group name"),
 808     ("enabled_hypervisors", None,
 809      ht.TOr(ht.TAnd(ht.TListOf(ht.TElemOf(constants.HYPER_TYPES)), ht.TTrue),
 810             ht.TNone),
 811      "List of enabled hypervisors"),
 812     ("hvparams", None, ht.TOr(ht.TDictOf(ht.TNonEmptyString, ht.TDict),
 813                               ht.TNone),
 814      "Cluster-wide hypervisor parameter defaults, hypervisor-dependent"),
 815     ("beparams", None, ht.TOr(ht.TDict, ht.TNone),
 816      "Cluster-wide backend parameter defaults"),
 817     ("os_hvp", None, ht.TOr(ht.TDictOf(ht.TNonEmptyString, ht.TDict),
 818                             ht.TNone),
 819      "Cluster-wide per-OS hypervisor parameter defaults"),
 820     ("osparams", None, ht.TOr(ht.TDictOf(ht.TNonEmptyString, ht.TDict),
 821                               ht.TNone),
 822      "Cluster-wide OS parameter defaults"),
 823     _PDiskParams,
 824     ("candidate_pool_size", None, ht.TOr(ht.TStrictPositiveInt, ht.TNone),
 825      "Master candidate pool size"),
 826     ("uid_pool", None, ht.NoType,
 827      "Set UID pool, must be list of lists describing UID ranges (two items,"
 828      " start and end inclusive)"),
 829     ("add_uids", None, ht.NoType,
 830      "Extend UID pool, must be list of lists describing UID ranges (two"
 831      " items, start and end inclusive) to be added"),
 832     ("remove_uids", None, ht.NoType,
 833      "Shrink UID pool, must be list of lists describing UID ranges (two"
 834      " items, start and end inclusive) to be removed"),
 835     ("maintain_node_health", None, ht.TMaybeBool,
 836      "Whether to automatically maintain node health"),
 837     ("prealloc_wipe_disks", None, ht.TMaybeBool,
 838      "Whether to wipe disks before allocating them to instances"),
 839     ("nicparams", None, ht.TMaybeDict, "Cluster-wide NIC parameter defaults"),
 840     ("ndparams", None, ht.TMaybeDict, "Cluster-wide node parameter defaults"),
 841     ("ipolicy", None, ht.TMaybeDict,
 842      "Cluster-wide :ref:`instance policy <rapi-ipolicy>` specs"),
 843     ("drbd_helper", None, ht.TOr(ht.TString, ht.TNone), "DRBD helper program"),
 844     ("default_iallocator", None, ht.TOr(ht.TString, ht.TNone),
 845      "Default iallocator for cluster"),
 846     ("master_netdev", None, ht.TOr(ht.TString, ht.TNone),
 847      "Master network device"),
 848     ("master_netmask", None, ht.TOr(ht.TInt, ht.TNone),
 849      "Netmask of the master IP"),
 850     ("reserved_lvs", None, ht.TMaybeListOf(ht.TNonEmptyString),
 851      "List of reserved LVs"),
 852     ("hidden_os", None, _TestClusterOsList,
 853      "Modify list of hidden operating systems: each modification must have"
 854      " two items, the operation and the OS name; the operation can be"
 855      " ``%s`` or ``%s``" % (constants.DDM_ADD, constants.DDM_REMOVE)),
 856     ("blacklisted_os", None, _TestClusterOsList,
 857      "Modify list of blacklisted operating systems: each modification must"
 858      " have two items, the operation and the OS name; the operation can be"
 859      " ``%s`` or ``%s``" % (constants.DDM_ADD, constants.DDM_REMOVE)),
 860     ("use_external_mip_script", None, ht.TMaybeBool,
 861      "Whether to use an external master IP address setup script"),
 862     ]
 863   OP_RESULT = ht.TNone
 864
 865
 866 class OpClusterRedistConf(OpCode):
 867   """Force a full push of the cluster configuration.
 868
 869   """
 870   OP_RESULT = ht.TNone
 871
 872
 873 class OpClusterActivateMasterIp(OpCode):
 874   """Activate the master IP on the master node.
 875
 876   """
 877   OP_RESULT = ht.TNone
 878
 879
 880 class OpClusterDeactivateMasterIp(OpCode):
 881   """Deactivate the master IP on the master node.
 882
 883   """
 884   OP_RESULT = ht.TNone
 885
 886
 887 class OpQuery(OpCode):
 888   """Query for resources/items.
 889
 890   @ivar what: Resources to query for, must be one of L{constants.QR_VIA_OP}
 891   @ivar fields: List of fields to retrieve
 892   @ivar qfilter: Query filter
 893
 894   """
 895   OP_DSC_FIELD = "what"
 896   OP_PARAMS = [
 897     _PQueryWhat,
 898     _PUseLocking,
 899     ("fields", ht.NoDefault, ht.TListOf(ht.TNonEmptyString),
 900      "Requested fields"),
 901     ("qfilter", None, ht.TOr(ht.TNone, ht.TList),
 902      "Query filter"),
 903     ]
 904   OP_RESULT = \
 905     _GenerateObjectTypeCheck(objects.QueryResponse, {
 906       "fields": ht.TListOf(_TQueryFieldDef),
 907       "data": _TQueryResult,
 908       })
 909
 910
 911 class OpQueryFields(OpCode):
 912   """Query for available resource/item fields.
 913
 914   @ivar what: Resources to query for, must be one of L{constants.QR_VIA_OP}
 915   @ivar fields: List of fields to retrieve
 916
 917   """
 918   OP_DSC_FIELD = "what"
 919   OP_PARAMS = [
 920     _PQueryWhat,
 921     ("fields", None, ht.TMaybeListOf(ht.TNonEmptyString),
 922      "Requested fields; if not given, all are returned"),
 923     ]
 924   OP_RESULT = \
 925     _GenerateObjectTypeCheck(objects.QueryFieldsResponse, {
 926       "fields": ht.TListOf(_TQueryFieldDef),
 927       })
 928
 929
 930 class OpOobCommand(OpCode):
 931   """Interact with OOB."""
 932   OP_PARAMS = [
 933     ("node_names", ht.EmptyList, ht.TListOf(ht.TNonEmptyString),
 934      "List of nodes to run the OOB command against"),
 935     ("command", None, ht.TElemOf(constants.OOB_COMMANDS),
 936      "OOB command to be run"),
 937     ("timeout", constants.OOB_TIMEOUT, ht.TInt,
 938      "Timeout before the OOB helper will be terminated"),
 939     ("ignore_status", False, ht.TBool,
 940      "Ignores the node offline status for power off"),
 941     ("power_delay", constants.OOB_POWER_DELAY, ht.TPositiveFloat,
 942      "Time in seconds to wait between powering on nodes"),
 943     ]
 944   # Fixme: Make it more specific with all the special cases in LUOobCommand
 945   OP_RESULT = _TQueryResult
 946
 947
 948 # node opcodes
 949
 950 class OpNodeRemove(OpCode):
 951   """Remove a node.
 952
 953   @type node_name: C{str}
 954   @ivar node_name: The name of the node to remove. If the node still has
 955                    instances on it, the operation will fail.
 956
 957   """
 958   OP_DSC_FIELD = "node_name"
 959   OP_PARAMS = [
 960     _PNodeName,
 961     ]
 962   OP_RESULT = ht.TNone
 963
 964
 965 class OpNodeAdd(OpCode):
 966   """Add a node to the cluster.
 967
 968   @type node_name: C{str}
 969   @ivar node_name: The name of the node to add. This can be a short name,
 970                    but it will be expanded to the FQDN.
 971   @type primary_ip: IP address
 972   @ivar primary_ip: The primary IP of the node. This will be ignored when the
 973                     opcode is submitted, but will be filled during the node
 974                     add (so it will be visible in the job query).
 975   @type secondary_ip: IP address
 976   @ivar secondary_ip: The secondary IP of the node. This needs to be passed
 977                       if the cluster has been initialized in 'dual-network'
 978                       mode, otherwise it must not be given.
 979   @type readd: C{bool}
 980   @ivar readd: Whether to re-add an existing node to the cluster. If
 981                this is not passed, then the operation will abort if the node
 982                name is already in the cluster; use this parameter to 'repair'
 983                a node that had its configuration broken, or was reinstalled
 984                without removal from the cluster.
 985   @type group: C{str}
 986   @ivar group: The node group to which this node will belong.
 987   @type vm_capable: C{bool}
 988   @ivar vm_capable: The vm_capable node attribute
 989   @type master_capable: C{bool}
 990   @ivar master_capable: The master_capable node attribute
 991
 992   """
 993   OP_DSC_FIELD = "node_name"
 994   OP_PARAMS = [
 995     _PNodeName,
 996     _PHvState,
 997     _PDiskState,
 998     ("primary_ip", None, ht.NoType, "Primary IP address"),
 999     ("secondary_ip", None, ht.TMaybeString, "Secondary IP address"),
1000     ("readd", False, ht.TBool, "Whether node is re-added to cluster"),
1001     ("group", None, ht.TMaybeString, "Initial node group"),
1002     ("master_capable", None, ht.TMaybeBool,
1003      "Whether node can become master or master candidate"),
1004     ("vm_capable", None, ht.TMaybeBool,
1005      "Whether node can host instances"),
1006     ("ndparams", None, ht.TMaybeDict, "Node parameters"),
1007     ]
1008   OP_RESULT = ht.TNone
1009
1010
1011 class OpNodeQuery(OpCode):
1012   """Compute the list of nodes."""
1013   OP_PARAMS = [
1014     _POutputFields,
1015     _PUseLocking,
1016     ("names", ht.EmptyList, ht.TListOf(ht.TNonEmptyString),
1017      "Empty list to query all nodes, node names otherwise"),
1018     ]
1019   OP_RESULT = _TOldQueryResult
1020
1021
1022 class OpNodeQueryvols(OpCode):
1023   """Get list of volumes on node."""
1024   OP_PARAMS = [
1025     _POutputFields,
1026     ("nodes", ht.EmptyList, ht.TListOf(ht.TNonEmptyString),
1027      "Empty list to query all nodes, node names otherwise"),
1028     ]
1029   OP_RESULT = ht.TListOf(ht.TAny)
1030
1031
1032 class OpNodeQueryStorage(OpCode):
1033   """Get information on storage for node(s)."""
1034   OP_PARAMS = [
1035     _POutputFields,
1036     _PStorageType,
1037     ("nodes", ht.EmptyList, ht.TListOf(ht.TNonEmptyString), "List of nodes"),
1038     ("name", None, ht.TMaybeString, "Storage name"),
1039     ]
1040   OP_RESULT = _TOldQueryResult
1041
1042
1043 class OpNodeModifyStorage(OpCode):
1044   """Modifies the properies of a storage unit"""
1045   OP_DSC_FIELD = "node_name"
1046   OP_PARAMS = [
1047     _PNodeName,
1048     _PStorageType,
1049     _PStorageName,
1050     ("changes", ht.NoDefault, ht.TDict, "Requested changes"),
1051     ]
1052   OP_RESULT = ht.TNone
1053
1054
1055 class OpRepairNodeStorage(OpCode):
1056   """Repairs the volume group on a node."""
1057   OP_DSC_FIELD = "node_name"
1058   OP_PARAMS = [
1059     _PNodeName,
1060     _PStorageType,
1061     _PStorageName,
1062     _PIgnoreConsistency,
1063     ]
1064   OP_RESULT = ht.TNone
1065
1066
1067 class OpNodeSetParams(OpCode):
1068   """Change the parameters of a node."""
1069   OP_DSC_FIELD = "node_name"
1070   OP_PARAMS = [
1071     _PNodeName,
1072     _PForce,
1073     _PHvState,
1074     _PDiskState,
1075     ("master_candidate", None, ht.TMaybeBool,
1076      "Whether the node should become a master candidate"),
1077     ("offline", None, ht.TMaybeBool,
1078      "Whether the node should be marked as offline"),
1079     ("drained", None, ht.TMaybeBool,
1080      "Whether the node should be marked as drained"),
1081     ("auto_promote", False, ht.TBool,
1082      "Whether node(s) should be promoted to master candidate if necessary"),
1083     ("master_capable", None, ht.TMaybeBool,
1084      "Denote whether node can become master or master candidate"),
1085     ("vm_capable", None, ht.TMaybeBool,
1086      "Denote whether node can host instances"),
1087     ("secondary_ip", None, ht.TMaybeString,
1088      "Change node's secondary IP address"),
1089     ("ndparams", None, ht.TMaybeDict, "Set node parameters"),
1090     ("powered", None, ht.TMaybeBool,
1091      "Whether the node should be marked as powered"),
1092     ]
1093   OP_RESULT = _TSetParamsResult
1094
1095
1096 class OpNodePowercycle(OpCode):
1097   """Tries to powercycle a node."""
1098   OP_DSC_FIELD = "node_name"
1099   OP_PARAMS = [
1100     _PNodeName,
1101     _PForce,
1102     ]
1103   OP_RESULT = ht.TMaybeString
1104
1105
1106 class OpNodeMigrate(OpCode):
1107   """Migrate all instances from a node."""
1108   OP_DSC_FIELD = "node_name"
1109   OP_PARAMS = [
1110     _PNodeName,
1111     _PMigrationMode,
1112     _PMigrationLive,
1113     _PMigrationTargetNode,
1114     _PAllowRuntimeChgs,
1115     _PIgnoreIpolicy,
1116     ("iallocator", None, ht.TMaybeString,
1117      "Iallocator for deciding the target node for shared-storage instances"),
1118     ]
1119   OP_RESULT = TJobIdListOnly
1120
1121
1122 class OpNodeEvacuate(OpCode):
1123   """Evacuate instances off a number of nodes."""
1124   OP_DSC_FIELD = "node_name"
1125   OP_PARAMS = [
1126     _PEarlyRelease,
1127     _PNodeName,
1128     ("remote_node", None, ht.TMaybeString, "New secondary node"),
1129     ("iallocator", None, ht.TMaybeString, "Iallocator for computing solution"),
1130     ("mode", ht.NoDefault, ht.TElemOf(constants.NODE_EVAC_MODES),
1131      "Node evacuation mode"),
1132     ]
1133   OP_RESULT = TJobIdListOnly
1134
1135
1136 # instance opcodes
1137
1138 class OpInstanceCreate(OpCode):
1139   """Create an instance.
1140
1141   @ivar instance_name: Instance name
1142   @ivar mode: Instance creation mode (one of L{constants.INSTANCE_CREATE_MODES})
1143   @ivar source_handshake: Signed handshake from source (remote import only)
1144   @ivar source_x509_ca: Source X509 CA in PEM format (remote import only)
1145   @ivar source_instance_name: Previous name of instance (remote import only)
1146   @ivar source_shutdown_timeout: Shutdown timeout used for source instance
1147     (remote import only)
1148
1149   """
1150   OP_DSC_FIELD = "instance_name"
1151   OP_PARAMS = [
1152     _PInstanceName,
1153     _PForceVariant,
1154     _PWaitForSync,
1155     _PNameCheck,
1156     _PIgnoreIpolicy,
1157     ("beparams", ht.EmptyDict, ht.TDict, "Backend parameters for instance"),
1158     ("disks", ht.NoDefault, ht.TListOf(_TDiskParams),
1159      "Disk descriptions, for example ``[{\"%s\": 100}, {\"%s\": 5}]``;"
1160      " each disk definition must contain a ``%s`` value and"
1161      " can contain an optional ``%s`` value denoting the disk access mode"
1162      " (%s)" %
1163      (constants.IDISK_SIZE, constants.IDISK_SIZE, constants.IDISK_SIZE,
1164       constants.IDISK_MODE,
1165       " or ".join("``%s``" % i for i in sorted(constants.DISK_ACCESS_SET)))),
1166     ("disk_template", ht.NoDefault, _BuildDiskTemplateCheck(True),
1167      "Disk template"),
1168     ("file_driver", None, ht.TOr(ht.TNone, ht.TElemOf(constants.FILE_DRIVER)),
1169      "Driver for file-backed disks"),
1170     ("file_storage_dir", None, ht.TMaybeString,
1171      "Directory for storing file-backed disks"),
1172     ("hvparams", ht.EmptyDict, ht.TDict,
1173      "Hypervisor parameters for instance, hypervisor-dependent"),
1174     ("hypervisor", None, ht.TMaybeString, "Hypervisor"),
1175     ("iallocator", None, ht.TMaybeString,
1176      "Iallocator for deciding which node(s) to use"),
1177     ("identify_defaults", False, ht.TBool,
1178      "Reset instance parameters to default if equal"),
1179     ("ip_check", True, ht.TBool, _PIpCheckDoc),
1180     ("mode", ht.NoDefault, ht.TElemOf(constants.INSTANCE_CREATE_MODES),
1181      "Instance creation mode"),
1182     ("nics", ht.NoDefault, ht.TListOf(_TestNicDef),
1183      "List of NIC (network interface) definitions, for example"
1184      " ``[{}, {}, {\"%s\": \"198.51.100.4\"}]``; each NIC definition can"
1185      " contain the optional values %s" %
1186      (constants.INIC_IP,
1187       ", ".join("``%s``" % i for i in sorted(constants.INIC_PARAMS)))),
1188     ("no_install", None, ht.TMaybeBool,
1189      "Do not install the OS (will disable automatic start)"),
1190     ("osparams", ht.EmptyDict, ht.TDict, "OS parameters for instance"),
1191     ("os_type", None, ht.TMaybeString, "Operating system"),
1192     ("pnode", None, ht.TMaybeString, "Primary node"),
1193     ("snode", None, ht.TMaybeString, "Secondary node"),
1194     ("source_handshake", None, ht.TOr(ht.TList, ht.TNone),
1195      "Signed handshake from source (remote import only)"),
1196     ("source_instance_name", None, ht.TMaybeString,
1197      "Source instance name (remote import only)"),
1198     ("source_shutdown_timeout", constants.DEFAULT_SHUTDOWN_TIMEOUT,
1199      ht.TPositiveInt,
1200      "How long source instance was given to shut down (remote import only)"),
1201     ("source_x509_ca", None, ht.TMaybeString,
1202      "Source X509 CA in PEM format (remote import only)"),
1203     ("src_node", None, ht.TMaybeString, "Source node for import"),
1204     ("src_path", None, ht.TMaybeString, "Source directory for import"),
1205     ("start", True, ht.TBool, "Whether to start instance after creation"),
1206     ("tags", ht.EmptyList, ht.TListOf(ht.TNonEmptyString), "Instance tags"),
1207     ]
1208   OP_RESULT = ht.Comment("instance nodes")(ht.TListOf(ht.TNonEmptyString))
1209
1210
1211 class OpInstanceReinstall(OpCode):
1212   """Reinstall an instance's OS."""
1213   OP_DSC_FIELD = "instance_name"
1214   OP_PARAMS = [
1215     _PInstanceName,
1216     _PForceVariant,
1217     ("os_type", None, ht.TMaybeString, "Instance operating system"),
1218     ("osparams", None, ht.TMaybeDict, "Temporary OS parameters"),
1219     ]
1220   OP_RESULT = ht.TNone
1221
1222
1223 class OpInstanceRemove(OpCode):
1224   """Remove an instance."""
1225   OP_DSC_FIELD = "instance_name"
1226   OP_PARAMS = [
1227     _PInstanceName,
1228     _PShutdownTimeout,
1229     ("ignore_failures", False, ht.TBool,
1230      "Whether to ignore failures during removal"),
1231     ]
1232   OP_RESULT = ht.TNone
1233
1234
1235 class OpInstanceRename(OpCode):
1236   """Rename an instance."""
1237   OP_PARAMS = [
1238     _PInstanceName,
1239     _PNameCheck,
1240     ("new_name", ht.NoDefault, ht.TNonEmptyString, "New instance name"),
1241     ("ip_check", False, ht.TBool, _PIpCheckDoc),
1242     ]
1243   OP_RESULT = ht.Comment("New instance name")(ht.TNonEmptyString)
1244
1245
1246 class OpInstanceStartup(OpCode):
1247   """Startup an instance."""
1248   OP_DSC_FIELD = "instance_name"
1249   OP_PARAMS = [
1250     _PInstanceName,
1251     _PForce,
1252     _PIgnoreOfflineNodes,
1253     ("hvparams", ht.EmptyDict, ht.TDict,
1254      "Temporary hypervisor parameters, hypervisor-dependent"),
1255     ("beparams", ht.EmptyDict, ht.TDict, "Temporary backend parameters"),
1256     _PNoRemember,
1257     _PStartupPaused,
1258     ]
1259   OP_RESULT = ht.TNone
1260
1261
1262 class OpInstanceShutdown(OpCode):
1263   """Shutdown an instance."""
1264   OP_DSC_FIELD = "instance_name"
1265   OP_PARAMS = [
1266     _PInstanceName,
1267     _PIgnoreOfflineNodes,
1268     ("timeout", constants.DEFAULT_SHUTDOWN_TIMEOUT, ht.TPositiveInt,
1269      "How long to wait for instance to shut down"),
1270     _PNoRemember,
1271     ]
1272   OP_RESULT = ht.TNone
1273
1274
1275 class OpInstanceReboot(OpCode):
1276   """Reboot an instance."""
1277   OP_DSC_FIELD = "instance_name"
1278   OP_PARAMS = [
1279     _PInstanceName,
1280     _PShutdownTimeout,
1281     ("ignore_secondaries", False, ht.TBool,
1282      "Whether to start the instance even if secondary disks are failing"),
1283     ("reboot_type", ht.NoDefault, ht.TElemOf(constants.REBOOT_TYPES),
1284      "How to reboot instance"),
1285     ]
1286   OP_RESULT = ht.TNone
1287
1288
1289 class OpInstanceReplaceDisks(OpCode):
1290   """Replace the disks of an instance."""
1291   OP_DSC_FIELD = "instance_name"
1292   OP_PARAMS = [
1293     _PInstanceName,
1294     _PEarlyRelease,
1295     _PIgnoreIpolicy,
1296     ("mode", ht.NoDefault, ht.TElemOf(constants.REPLACE_MODES),
1297      "Replacement mode"),
1298     ("disks", ht.EmptyList, ht.TListOf(ht.TPositiveInt),
1299      "Disk indexes"),
1300     ("remote_node", None, ht.TMaybeString, "New secondary node"),
1301     ("iallocator", None, ht.TMaybeString,
1302      "Iallocator for deciding new secondary node"),
1303     ]
1304   OP_RESULT = ht.TNone
1305
1306
1307 class OpInstanceFailover(OpCode):
1308   """Failover an instance."""
1309   OP_DSC_FIELD = "instance_name"
1310   OP_PARAMS = [
1311     _PInstanceName,
1312     _PShutdownTimeout,
1313     _PIgnoreConsistency,
1314     _PMigrationTargetNode,
1315     _PIgnoreIpolicy,
1316     ("iallocator", None, ht.TMaybeString,
1317      "Iallocator for deciding the target node for shared-storage instances"),
1318     ]
1319   OP_RESULT = ht.TNone
1320
1321
1322 class OpInstanceMigrate(OpCode):
1323   """Migrate an instance.
1324
1325   This migrates (without shutting down an instance) to its secondary
1326   node.
1327
1328   @ivar instance_name: the name of the instance
1329   @ivar mode: the migration mode (live, non-live or None for auto)
1330
1331   """
1332   OP_DSC_FIELD = "instance_name"
1333   OP_PARAMS = [
1334     _PInstanceName,
1335     _PMigrationMode,
1336     _PMigrationLive,
1337     _PMigrationTargetNode,
1338     _PAllowRuntimeChgs,
1339     _PIgnoreIpolicy,
1340     ("cleanup", False, ht.TBool,
1341      "Whether a previously failed migration should be cleaned up"),
1342     ("iallocator", None, ht.TMaybeString,
1343      "Iallocator for deciding the target node for shared-storage instances"),
1344     ("allow_failover", False, ht.TBool,
1345      "Whether we can fallback to failover if migration is not possible"),
1346     ]
1347   OP_RESULT = ht.TNone
1348
1349
1350 class OpInstanceMove(OpCode):
1351   """Move an instance.
1352
1353   This move (with shutting down an instance and data copying) to an
1354   arbitrary node.
1355
1356   @ivar instance_name: the name of the instance
1357   @ivar target_node: the destination node
1358
1359   """
1360   OP_DSC_FIELD = "instance_name"
1361   OP_PARAMS = [
1362     _PInstanceName,
1363     _PShutdownTimeout,
1364     _PIgnoreIpolicy,
1365     ("target_node", ht.NoDefault, ht.TNonEmptyString, "Target node"),
1366     _PIgnoreConsistency,
1367     ]
1368   OP_RESULT = ht.TNone
1369
1370
1371 class OpInstanceConsole(OpCode):
1372   """Connect to an instance's console."""
1373   OP_DSC_FIELD = "instance_name"
1374   OP_PARAMS = [
1375     _PInstanceName
1376     ]
1377   OP_RESULT = ht.TDict
1378
1379
1380 class OpInstanceActivateDisks(OpCode):
1381   """Activate an instance's disks."""
1382   OP_DSC_FIELD = "instance_name"
1383   OP_PARAMS = [
1384     _PInstanceName,
1385     ("ignore_size", False, ht.TBool, "Whether to ignore recorded size"),
1386     _PWaitForSyncFalse,
1387     ]
1388   OP_RESULT = ht.TListOf(ht.TAnd(ht.TIsLength(3),
1389                                  ht.TItems([ht.TNonEmptyString,
1390                                             ht.TNonEmptyString,
1391                                             ht.TNonEmptyString])))
1392
1393
1394 class OpInstanceDeactivateDisks(OpCode):
1395   """Deactivate an instance's disks."""
1396   OP_DSC_FIELD = "instance_name"
1397   OP_PARAMS = [
1398     _PInstanceName,
1399     _PForce,
1400     ]
1401   OP_RESULT = ht.TNone
1402
1403
1404 class OpInstanceRecreateDisks(OpCode):
1405   """Recreate an instance's disks."""
1406   _TDiskChanges = \
1407     ht.TAnd(ht.TIsLength(2),
1408             ht.TItems([ht.Comment("Disk index")(ht.TPositiveInt),
1409                        ht.Comment("Parameters")(_TDiskParams)]))
1410
1411   OP_DSC_FIELD = "instance_name"
1412   OP_PARAMS = [
1413     _PInstanceName,
1414     ("disks", ht.EmptyList,
1415      ht.TOr(ht.TListOf(ht.TPositiveInt), ht.TListOf(_TDiskChanges)),
1416      "List of disk indexes (deprecated) or a list of tuples containing a disk"
1417      " index and a possibly empty dictionary with disk parameter changes"),
1418     ("nodes", ht.EmptyList, ht.TListOf(ht.TNonEmptyString),
1419      "New instance nodes, if relocation is desired"),
1420     ("iallocator", None, ht.TMaybeString,
1421      "Iallocator for deciding new nodes"),
1422     ]
1423   OP_RESULT = ht.TNone
1424
1425
1426 class OpInstanceQuery(OpCode):
1427   """Compute the list of instances."""
1428   OP_PARAMS = [
1429     _POutputFields,
1430     _PUseLocking,
1431     ("names", ht.EmptyList, ht.TListOf(ht.TNonEmptyString),
1432      "Empty list to query all instances, instance names otherwise"),
1433     ]
1434   OP_RESULT = _TOldQueryResult
1435
1436
1437 class OpInstanceQueryData(OpCode):
1438   """Compute the run-time status of instances."""
1439   OP_PARAMS = [
1440     _PUseLocking,
1441     ("instances", ht.EmptyList, ht.TListOf(ht.TNonEmptyString),
1442      "Instance names"),
1443     ("static", False, ht.TBool,
1444      "Whether to only return configuration data without querying"
1445      " nodes"),
1446     ]
1447   OP_RESULT = ht.TDictOf(ht.TNonEmptyString, ht.TDict)
1448
1449
1450 def _TestInstSetParamsModList(fn):
1451   """Generates a check for modification lists.
1452
1453   """
1454   # Old format
1455   # TODO: Remove in version 2.8 including support in LUInstanceSetParams
1456   old_mod_item_fn = \
1457     ht.TAnd(ht.TIsLength(2), ht.TItems([
1458       ht.TOr(ht.TElemOf(constants.DDMS_VALUES), ht.TPositiveInt),
1459       fn,
1460       ]))
1461
1462   # New format, supporting adding/removing disks/NICs at arbitrary indices
1463   mod_item_fn = \
1464     ht.TAnd(ht.TIsLength(3), ht.TItems([
1465       ht.TElemOf(constants.DDMS_VALUES_WITH_MODIFY),
1466       ht.Comment("Disk index, can be negative, e.g. -1 for last disk")(ht.TInt),
1467       fn,
1468       ]))
1469
1470   return ht.TOr(ht.Comment("Recommended")(ht.TListOf(mod_item_fn)),
1471                 ht.Comment("Deprecated")(ht.TListOf(old_mod_item_fn)))
1472
1473
1474 class OpInstanceSetParams(OpCode):
1475   """Change the parameters of an instance.
1476
1477   """
1478   TestNicModifications = _TestInstSetParamsModList(_TestNicDef)
1479   TestDiskModifications = _TestInstSetParamsModList(_TDiskParams)
1480
1481   OP_DSC_FIELD = "instance_name"
1482   OP_PARAMS = [
1483     _PInstanceName,
1484     _PForce,
1485     _PForceVariant,
1486     _PIgnoreIpolicy,
1487     ("nics", ht.EmptyList, TestNicModifications,
1488      "List of NIC changes: each item is of the form ``(op, index, settings)``,"
1489      " ``op`` is one of ``%s``, ``%s`` or ``%s``, ``index`` can be either -1"
1490      " to refer to the last position, or a zero-based index number; a"
1491      " deprecated version of this parameter used the form ``(op, settings)``,"
1492      " where ``op`` can be ``%s`` to add a new NIC with the specified"
1493      " settings, ``%s`` to remove the last NIC or a number to modify the"
1494      " settings of the NIC with that index" %
1495      (constants.DDM_ADD, constants.DDM_MODIFY, constants.DDM_REMOVE,
1496       constants.DDM_ADD, constants.DDM_REMOVE)),
1497     ("disks", ht.EmptyList, TestDiskModifications,
1498      "List of disk changes; see ``nics``"),
1499     ("beparams", ht.EmptyDict, ht.TDict, "Per-instance backend parameters"),
1500     ("runtime_mem", None, ht.TMaybeStrictPositiveInt, "New runtime memory"),
1501     ("hvparams", ht.EmptyDict, ht.TDict,
1502      "Per-instance hypervisor parameters, hypervisor-dependent"),
1503     ("disk_template", None, ht.TOr(ht.TNone, _BuildDiskTemplateCheck(False)),
1504      "Disk template for instance"),
1505     ("remote_node", None, ht.TMaybeString,
1506      "Secondary node (used when changing disk template)"),
1507     ("os_name", None, ht.TMaybeString,
1508      "Change the instance's OS without reinstalling the instance"),
1509     ("osparams", None, ht.TMaybeDict, "Per-instance OS parameters"),
1510     ("wait_for_sync", True, ht.TBool,
1511      "Whether to wait for the disk to synchronize, when changing template"),
1512     ("offline", None, ht.TMaybeBool, "Whether to mark instance as offline"),
1513     ]
1514   OP_RESULT = _TSetParamsResult
1515
1516
1517 class OpInstanceGrowDisk(OpCode):
1518   """Grow a disk of an instance."""
1519   OP_DSC_FIELD = "instance_name"
1520   OP_PARAMS = [
1521     _PInstanceName,
1522     _PWaitForSync,
1523     ("disk", ht.NoDefault, ht.TInt, "Disk index"),
1524     ("amount", ht.NoDefault, ht.TPositiveInt,
1525      "Amount of disk space to add (megabytes)"),
1526     ("absolute", False, ht.TBool,
1527      "Whether the amount parameter is an absolute target or a relative one"),
1528     ]
1529   OP_RESULT = ht.TNone
1530
1531
1532 class OpInstanceChangeGroup(OpCode):
1533   """Moves an instance to another node group."""
1534   OP_DSC_FIELD = "instance_name"
1535   OP_PARAMS = [
1536     _PInstanceName,
1537     _PEarlyRelease,
1538     ("iallocator", None, ht.TMaybeString, "Iallocator for computing solution"),
1539     ("target_groups", None, ht.TMaybeListOf(ht.TNonEmptyString),
1540      "Destination group names or UUIDs (defaults to \"all but current group\""),
1541     ]
1542   OP_RESULT = TJobIdListOnly
1543
1544
1545 # Node group opcodes
1546
1547 class OpGroupAdd(OpCode):
1548   """Add a node group to the cluster."""
1549   OP_DSC_FIELD = "group_name"
1550   OP_PARAMS = [
1551     _PGroupName,
1552     _PNodeGroupAllocPolicy,
1553     _PGroupNodeParams,
1554     _PDiskParams,
1555     _PHvState,
1556     _PDiskState,
1557     ("ipolicy", None, ht.TMaybeDict,
1558      "Group-wide :ref:`instance policy <rapi-ipolicy>` specs"),
1559     ]
1560   OP_RESULT = ht.TNone
1561
1562
1563 class OpGroupAssignNodes(OpCode):
1564   """Assign nodes to a node group."""
1565   OP_DSC_FIELD = "group_name"
1566   OP_PARAMS = [
1567     _PGroupName,
1568     _PForce,
1569     ("nodes", ht.NoDefault, ht.TListOf(ht.TNonEmptyString),
1570      "List of nodes to assign"),
1571     ]
1572   OP_RESULT = ht.TNone
1573
1574
1575 class OpGroupQuery(OpCode):
1576   """Compute the list of node groups."""
1577   OP_PARAMS = [
1578     _POutputFields,
1579     ("names", ht.EmptyList, ht.TListOf(ht.TNonEmptyString),
1580      "Empty list to query all groups, group names otherwise"),
1581     ]
1582   OP_RESULT = _TOldQueryResult
1583
1584
1585 class OpGroupSetParams(OpCode):
1586   """Change the parameters of a node group."""
1587   OP_DSC_FIELD = "group_name"
1588   OP_PARAMS = [
1589     _PGroupName,
1590     _PNodeGroupAllocPolicy,
1591     _PGroupNodeParams,
1592     _PDiskParams,
1593     _PHvState,
1594     _PDiskState,
1595     ("ipolicy", None, ht.TMaybeDict, "Group-wide instance policy specs"),
1596     ]
1597   OP_RESULT = _TSetParamsResult
1598
1599
1600 class OpGroupRemove(OpCode):
1601   """Remove a node group from the cluster."""
1602   OP_DSC_FIELD = "group_name"
1603   OP_PARAMS = [
1604     _PGroupName,
1605     ]
1606   OP_RESULT = ht.TNone
1607
1608
1609 class OpGroupRename(OpCode):
1610   """Rename a node group in the cluster."""
1611   OP_PARAMS = [
1612     _PGroupName,
1613     ("new_name", ht.NoDefault, ht.TNonEmptyString, "New group name"),
1614     ]
1615   OP_RESULT = ht.Comment("New group name")(ht.TNonEmptyString)
1616
1617
1618 class OpGroupEvacuate(OpCode):
1619   """Evacuate a node group in the cluster."""
1620   OP_DSC_FIELD = "group_name"
1621   OP_PARAMS = [
1622     _PGroupName,
1623     _PEarlyRelease,
1624     ("iallocator", None, ht.TMaybeString, "Iallocator for computing solution"),
1625     ("target_groups", None, ht.TMaybeListOf(ht.TNonEmptyString),
1626      "Destination group names or UUIDs"),
1627     ]
1628   OP_RESULT = TJobIdListOnly
1629
1630
1631 # OS opcodes
1632 class OpOsDiagnose(OpCode):
1633   """Compute the list of guest operating systems."""
1634   OP_PARAMS = [
1635     _POutputFields,
1636     ("names", ht.EmptyList, ht.TListOf(ht.TNonEmptyString),
1637      "Which operating systems to diagnose"),
1638     ]
1639   OP_RESULT = _TOldQueryResult
1640
1641
1642 # Exports opcodes
1643 class OpBackupQuery(OpCode):
1644   """Compute the list of exported images."""
1645   OP_PARAMS = [
1646     _PUseLocking,
1647     ("nodes", ht.EmptyList, ht.TListOf(ht.TNonEmptyString),
1648      "Empty list to query all nodes, node names otherwise"),
1649     ]
1650   OP_RESULT = ht.TDictOf(ht.TNonEmptyString,
1651                          ht.TOr(ht.Comment("False on error")(ht.TBool),
1652                                 ht.TListOf(ht.TNonEmptyString)))
1653
1654
1655 class OpBackupPrepare(OpCode):
1656   """Prepares an instance export.
1657
1658   @ivar instance_name: Instance name
1659   @ivar mode: Export mode (one of L{constants.EXPORT_MODES})
1660
1661   """
1662   OP_DSC_FIELD = "instance_name"
1663   OP_PARAMS = [
1664     _PInstanceName,
1665     ("mode", ht.NoDefault, ht.TElemOf(constants.EXPORT_MODES),
1666      "Export mode"),
1667     ]
1668   OP_RESULT = ht.TOr(ht.TNone, ht.TDict)
1669
1670
1671 class OpBackupExport(OpCode):
1672   """Export an instance.
1673
1674   For local exports, the export destination is the node name. For remote
1675   exports, the export destination is a list of tuples, each consisting of
1676   hostname/IP address, port, HMAC and HMAC salt. The HMAC is calculated using
1677   the cluster domain secret over the value "${index}:${hostname}:${port}". The
1678   destination X509 CA must be a signed certificate.
1679
1680   @ivar mode: Export mode (one of L{constants.EXPORT_MODES})
1681   @ivar target_node: Export destination
1682   @ivar x509_key_name: X509 key to use (remote export only)
1683   @ivar destination_x509_ca: Destination X509 CA in PEM format (remote export
1684                              only)
1685
1686   """
1687   OP_DSC_FIELD = "instance_name"
1688   OP_PARAMS = [
1689     _PInstanceName,
1690     _PShutdownTimeout,
1691     # TODO: Rename target_node as it changes meaning for different export modes
1692     # (e.g. "destination")
1693     ("target_node", ht.NoDefault, ht.TOr(ht.TNonEmptyString, ht.TList),
1694      "Destination information, depends on export mode"),
1695     ("shutdown", True, ht.TBool, "Whether to shutdown instance before export"),
1696     ("remove_instance", False, ht.TBool,
1697      "Whether to remove instance after export"),
1698     ("ignore_remove_failures", False, ht.TBool,
1699      "Whether to ignore failures while removing instances"),
1700     ("mode", constants.EXPORT_MODE_LOCAL, ht.TElemOf(constants.EXPORT_MODES),
1701      "Export mode"),
1702     ("x509_key_name", None, ht.TOr(ht.TList, ht.TNone),
1703      "Name of X509 key (remote export only)"),
1704     ("destination_x509_ca", None, ht.TMaybeString,
1705      "Destination X509 CA (remote export only)"),
1706     ]
1707   OP_RESULT = \
1708     ht.TAnd(ht.TIsLength(2), ht.TItems([
1709       ht.Comment("Finalizing status")(ht.TBool),
1710       ht.Comment("Status for every exported disk")(ht.TListOf(ht.TBool)),
1711       ]))
1712
1713
1714 class OpBackupRemove(OpCode):
1715   """Remove an instance's export."""
1716   OP_DSC_FIELD = "instance_name"
1717   OP_PARAMS = [
1718     _PInstanceName,
1719     ]
1720   OP_RESULT = ht.TNone
1721
1722
1723 # Tags opcodes
1724 class OpTagsGet(OpCode):
1725   """Returns the tags of the given object."""
1726   OP_DSC_FIELD = "name"
1727   OP_PARAMS = [
1728     _PTagKind,
1729     # Not using _PUseLocking as the default is different for historical reasons
1730     ("use_locking", True, ht.TBool, "Whether to use synchronization"),
1731     # Name is only meaningful for nodes and instances
1732     ("name", ht.NoDefault, ht.TMaybeString,
1733      "Name of object to retrieve tags from"),
1734     ]
1735   OP_RESULT = ht.TListOf(ht.TNonEmptyString)
1736
1737
1738 class OpTagsSearch(OpCode):
1739   """Searches the tags in the cluster for a given pattern."""
1740   OP_DSC_FIELD = "pattern"
1741   OP_PARAMS = [
1742     ("pattern", ht.NoDefault, ht.TNonEmptyString,
1743      "Search pattern (regular expression)"),
1744     ]
1745   OP_RESULT = ht.TListOf(ht.TAnd(ht.TIsLength(2), ht.TItems([
1746     ht.TNonEmptyString,
1747     ht.TNonEmptyString,
1748     ])))
1749
1750
1751 class OpTagsSet(OpCode):
1752   """Add a list of tags on a given object."""
1753   OP_PARAMS = [
1754     _PTagKind,
1755     _PTags,
1756     # Name is only meaningful for nodes and instances
1757     ("name", ht.NoDefault, ht.TMaybeString,
1758      "Name of object where tag(s) should be added"),
1759     ]
1760   OP_RESULT = ht.TNone
1761
1762
1763 class OpTagsDel(OpCode):
1764   """Remove a list of tags from a given object."""
1765   OP_PARAMS = [
1766     _PTagKind,
1767     _PTags,
1768     # Name is only meaningful for nodes and instances
1769     ("name", ht.NoDefault, ht.TMaybeString,
1770      "Name of object where tag(s) should be deleted"),
1771     ]
1772   OP_RESULT = ht.TNone
1773
1774
1775 # Test opcodes
1776 class OpTestDelay(OpCode):
1777   """Sleeps for a configured amount of time.
1778
1779   This is used just for debugging and testing.
1780
1781   Parameters:
1782     - duration: the time to sleep
1783     - on_master: if true, sleep on the master
1784     - on_nodes: list of nodes in which to sleep
1785
1786   If the on_master parameter is true, it will execute a sleep on the
1787   master (before any node sleep).
1788
1789   If the on_nodes list is not empty, it will sleep on those nodes
1790   (after the sleep on the master, if that is enabled).
1791
1792   As an additional feature, the case of duration < 0 will be reported
1793   as an execution error, so this opcode can be used as a failure
1794   generator. The case of duration == 0 will not be treated specially.
1795
1796   """
1797   OP_DSC_FIELD = "duration"
1798   OP_PARAMS = [
1799     ("duration", ht.NoDefault, ht.TNumber, None),
1800     ("on_master", True, ht.TBool, None),
1801     ("on_nodes", ht.EmptyList, ht.TListOf(ht.TNonEmptyString), None),
1802     ("repeat", 0, ht.TPositiveInt, None),
1803     ]
1804
1805
1806 class OpTestAllocator(OpCode):
1807   """Allocator framework testing.
1808
1809   This opcode has two modes:
1810     - gather and return allocator input for a given mode (allocate new
1811       or replace secondary) and a given instance definition (direction
1812       'in')
1813     - run a selected allocator for a given operation (as above) and
1814       return the allocator output (direction 'out')
1815
1816   """
1817   OP_DSC_FIELD = "allocator"
1818   OP_PARAMS = [
1819     ("direction", ht.NoDefault,
1820      ht.TElemOf(constants.VALID_IALLOCATOR_DIRECTIONS), None),
1821     ("mode", ht.NoDefault, ht.TElemOf(constants.VALID_IALLOCATOR_MODES), None),
1822     ("name", ht.NoDefault, ht.TNonEmptyString, None),
1823     ("nics", ht.NoDefault,
1824      ht.TMaybeListOf(ht.TDictOf(ht.TElemOf([constants.INIC_MAC,
1825                                             constants.INIC_IP,
1826                                             "bridge"]),
1827                                 ht.TOr(ht.TNone, ht.TNonEmptyString))),
1828      None),
1829     ("disks", ht.NoDefault, ht.TOr(ht.TNone, ht.TList), None),
1830     ("hypervisor", None, ht.TMaybeString, None),
1831     ("allocator", None, ht.TMaybeString, None),
1832     ("tags", ht.EmptyList, ht.TListOf(ht.TNonEmptyString), None),
1833     ("memory", None, ht.TOr(ht.TNone, ht.TPositiveInt), None),
1834     ("vcpus", None, ht.TOr(ht.TNone, ht.TPositiveInt), None),
1835     ("os", None, ht.TMaybeString, None),
1836     ("disk_template", None, ht.TMaybeString, None),
1837     ("instances", None, ht.TMaybeListOf(ht.TNonEmptyString), None),
1838     ("evac_mode", None,
1839      ht.TOr(ht.TNone, ht.TElemOf(constants.IALLOCATOR_NEVAC_MODES)), None),
1840     ("target_groups", None, ht.TMaybeListOf(ht.TNonEmptyString), None),
1841     ("spindle_use", 1, ht.TPositiveInt, None),
1842     ("count", 1, ht.TPositiveInt, None),
1843     ]
1844
1845
1846 class OpTestJqueue(OpCode):
1847   """Utility opcode to test some aspects of the job queue.
1848
1849   """
1850   OP_PARAMS = [
1851     ("notify_waitlock", False, ht.TBool, None),
1852     ("notify_exec", False, ht.TBool, None),
1853     ("log_messages", ht.EmptyList, ht.TListOf(ht.TString), None),
1854     ("fail", False, ht.TBool, None),
1855     ]
1856
1857
1858 class OpTestDummy(OpCode):
1859   """Utility opcode used by unittests.
1860
1861   """
1862   OP_PARAMS = [
1863     ("result", ht.NoDefault, ht.NoType, None),
1864     ("messages", ht.NoDefault, ht.NoType, None),
1865     ("fail", ht.NoDefault, ht.NoType, None),
1866     ("submit_jobs", None, ht.NoType, None),
1867     ]
1868   WITH_LU = False
1869
1870
1871 def _GetOpList():
1872   """Returns list of all defined opcodes.
1873
1874   Does not eliminate duplicates by C{OP_ID}.
1875
1876   """
1877   return [v for v in globals().values()
1878           if (isinstance(v, type) and issubclass(v, OpCode) and
1879               hasattr(v, "OP_ID") and v is not OpCode)]
1880
1881
1882 OP_MAPPING = dict((v.OP_ID, v) for v in _GetOpList())