Statistics
| Branch: | Tag: | Revision:

root / lib / opcodes.py @ cfdf561d

History | View | Annotate | Download (58.2 kB)

1
#
2
#
3

    
4
# Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011 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

    
44

    
45
# Common opcode attributes
46

    
47
#: output fields for a query operation
48
_POutputFields = ("output_fields", ht.NoDefault, ht.TListOf(ht.TNonEmptyString),
49
                  "Selected output fields")
50

    
51
#: the shutdown timeout
52
_PShutdownTimeout = \
53
  ("shutdown_timeout", constants.DEFAULT_SHUTDOWN_TIMEOUT, ht.TPositiveInt,
54
   "How long to wait for instance to shut down")
55

    
56
#: the force parameter
57
_PForce = ("force", False, ht.TBool, "Whether to force the operation")
58

    
59
#: a required instance name (for single-instance LUs)
60
_PInstanceName = ("instance_name", ht.NoDefault, ht.TNonEmptyString,
61
                  "Instance name")
62

    
63
#: Whether to ignore offline nodes
64
_PIgnoreOfflineNodes = ("ignore_offline_nodes", False, ht.TBool,
65
                        "Whether to ignore offline nodes")
66

    
67
#: a required node name (for single-node LUs)
68
_PNodeName = ("node_name", ht.NoDefault, ht.TNonEmptyString, "Node name")
69

    
70
#: a required node group name (for single-group LUs)
71
_PGroupName = ("group_name", ht.NoDefault, ht.TNonEmptyString, "Group name")
72

    
73
#: Migration type (live/non-live)
74
_PMigrationMode = ("mode", None,
75
                   ht.TOr(ht.TNone, ht.TElemOf(constants.HT_MIGRATION_MODES)),
76
                   "Migration mode")
77

    
78
#: Obsolete 'live' migration mode (boolean)
79
_PMigrationLive = ("live", None, ht.TMaybeBool,
80
                   "Legacy setting for live migration, do not use")
81

    
82
#: Tag type
83
_PTagKind = ("kind", ht.NoDefault, ht.TElemOf(constants.VALID_TAG_TYPES), None)
84

    
85
#: List of tag strings
86
_PTags = ("tags", ht.NoDefault, ht.TListOf(ht.TNonEmptyString), None)
87

    
88
_PForceVariant = ("force_variant", False, ht.TBool,
89
                  "Whether to force an unknown OS variant")
90

    
91
_PWaitForSync = ("wait_for_sync", True, ht.TBool,
92
                 "Whether to wait for the disk to synchronize")
93

    
94
_PIgnoreConsistency = ("ignore_consistency", False, ht.TBool,
95
                       "Whether to ignore disk consistency")
96

    
97
_PStorageName = ("name", ht.NoDefault, ht.TMaybeString, "Storage name")
98

    
99
_PUseLocking = ("use_locking", False, ht.TBool,
100
                "Whether to use synchronization")
101

    
102
_PNameCheck = ("name_check", True, ht.TBool, "Whether to check name")
103

    
104
_PNodeGroupAllocPolicy = \
105
  ("alloc_policy", None,
106
   ht.TOr(ht.TNone, ht.TElemOf(constants.VALID_ALLOC_POLICIES)),
107
   "Instance allocation policy")
108

    
109
_PGroupNodeParams = ("ndparams", None, ht.TMaybeDict,
110
                     "Default node parameters for group")
111

    
112
_PQueryWhat = ("what", ht.NoDefault, ht.TElemOf(constants.QR_VIA_OP),
113
               "Resource(s) to query for")
114

    
115
_PEarlyRelease = ("early_release", False, ht.TBool,
116
                  "Whether to release locks as soon as possible")
117

    
118
_PIpCheckDoc = "Whether to ensure instance's IP address is inactive"
119

    
120
#: Do not remember instance state changes
121
_PNoRemember = ("no_remember", False, ht.TBool,
122
                "Do not remember the state change")
123

    
124
#: Target node for instance migration/failover
125
_PMigrationTargetNode = ("target_node", None, ht.TMaybeString,
126
                         "Target node for shared-storage instances")
127

    
128
_PStartupPaused = ("startup_paused", False, ht.TBool,
129
                   "Pause instance at startup")
130

    
131
_PVerbose = ("verbose", False, ht.TBool, "Verbose mode")
132

    
133
# Parameters for cluster verification
134
_PDebugSimulateErrors = ("debug_simulate_errors", False, ht.TBool,
135
                         "Whether to simulate errors (useful for debugging)")
136
_PErrorCodes = ("error_codes", False, ht.TBool, "Error codes")
137
_PSkipChecks = ("skip_checks", ht.EmptyList,
138
                ht.TListOf(ht.TElemOf(constants.VERIFY_OPTIONAL_CHECKS)),
139
                "Which checks to skip")
140
_PIgnoreErrors = ("ignore_errors", ht.EmptyList,
141
                  ht.TListOf(ht.TElemOf(constants.CV_ALL_ECODES_STRINGS)),
142
                  "List of error codes that should be treated as warnings")
143

    
144
# Disk parameters
145
_PDiskParams = ("diskparams", None,
146
                ht.TOr(
147
                  ht.TDictOf(ht.TElemOf(constants.DISK_TEMPLATES), ht.TDict),
148
                  ht.TNone),
149
                "Disk templates' parameter defaults")
150

    
151
# Parameters for node resource model
152
_PHvState = ("hv_state", None, ht.TMaybeDict, "Set hypervisor states")
153
_PDiskState = ("disk_state", None, ht.TMaybeDict, "Set disk states")
154

    
155

    
156
_PIgnoreIpolicy = ("ignore_ipolicy", False, ht.TBool,
157
                   "Whether to ignore ipolicy violations")
158

    
159
# Allow runtime changes while migrating
160
_PAllowRuntimeChgs = ("allow_runtime_changes", True, ht.TBool,
161
                      "Allow runtime changes (eg. memory ballooning)")
162

    
163

    
164
#: OP_ID conversion regular expression
165
_OPID_RE = re.compile("([a-z])([A-Z])")
166

    
167
#: Utility function for L{OpClusterSetParams}
168
_TestClusterOsListItem = \
169
  ht.TAnd(ht.TIsLength(2), ht.TItems([
170
    ht.TElemOf(constants.DDMS_VALUES),
171
    ht.TNonEmptyString,
172
    ]))
173

    
174
_TestClusterOsList = ht.TMaybeListOf(_TestClusterOsListItem)
175

    
176
# TODO: Generate check from constants.INIC_PARAMS_TYPES
177
#: Utility function for testing NIC definitions
178
_TestNicDef = \
179
  ht.Comment("NIC parameters")(ht.TDictOf(ht.TElemOf(constants.INIC_PARAMS),
180
                                          ht.TOr(ht.TNone, ht.TNonEmptyString)))
181

    
182
_TSetParamsResultItemItems = [
183
  ht.Comment("name of changed parameter")(ht.TNonEmptyString),
184
  ht.Comment("new value")(ht.TAny),
185
  ]
186

    
187
_TSetParamsResult = \
188
  ht.TListOf(ht.TAnd(ht.TIsLength(len(_TSetParamsResultItemItems)),
189
                     ht.TItems(_TSetParamsResultItemItems)))
190

    
191
# TODO: Generate check from constants.IDISK_PARAMS_TYPES (however, not all users
192
# of this check support all parameters)
193
_TDiskParams = \
194
  ht.Comment("Disk parameters")(ht.TDictOf(ht.TElemOf(constants.IDISK_PARAMS),
195
                                           ht.TOr(ht.TNonEmptyString, ht.TInt)))
196

    
197
_TQueryRow = \
198
  ht.TListOf(ht.TAnd(ht.TIsLength(2),
199
                     ht.TItems([ht.TElemOf(constants.RS_ALL),
200
                                ht.TAny])))
201

    
202
_TQueryResult = ht.TListOf(_TQueryRow)
203

    
204
_TOldQueryRow = ht.TListOf(ht.TAny)
205

    
206
_TOldQueryResult = ht.TListOf(_TOldQueryRow)
207

    
208

    
209
_SUMMARY_PREFIX = {
210
  "CLUSTER_": "C_",
211
  "GROUP_": "G_",
212
  "NODE_": "N_",
213
  "INSTANCE_": "I_",
214
  }
215

    
216
#: Attribute name for dependencies
217
DEPEND_ATTR = "depends"
218

    
219
#: Attribute name for comment
220
COMMENT_ATTR = "comment"
221

    
222

    
223
def _NameToId(name):
224
  """Convert an opcode class name to an OP_ID.
225

226
  @type name: string
227
  @param name: the class name, as OpXxxYyy
228
  @rtype: string
229
  @return: the name in the OP_XXXX_YYYY format
230

231
  """
232
  if not name.startswith("Op"):
233
    return None
234
  # Note: (?<=[a-z])(?=[A-Z]) would be ideal, since it wouldn't
235
  # consume any input, and hence we would just have all the elements
236
  # in the list, one by one; but it seems that split doesn't work on
237
  # non-consuming input, hence we have to process the input string a
238
  # bit
239
  name = _OPID_RE.sub(r"\1,\2", name)
240
  elems = name.split(",")
241
  return "_".join(n.upper() for n in elems)
242

    
243

    
244
def _GenerateObjectTypeCheck(obj, fields_types):
245
  """Helper to generate type checks for objects.
246

247
  @param obj: The object to generate type checks
248
  @param fields_types: The fields and their types as a dict
249
  @return: A ht type check function
250

251
  """
252
  assert set(obj.GetAllSlots()) == set(fields_types.keys()), \
253
    "%s != %s" % (set(obj.GetAllSlots()), set(fields_types.keys()))
254
  return ht.TStrictDict(True, True, fields_types)
255

    
256

    
257
_TQueryFieldDef = \
258
  _GenerateObjectTypeCheck(objects.QueryFieldDefinition, {
259
    "name": ht.TNonEmptyString,
260
    "title": ht.TNonEmptyString,
261
    "kind": ht.TElemOf(constants.QFT_ALL),
262
    "doc": ht.TNonEmptyString,
263
    })
264

    
265

    
266
def RequireFileStorage():
267
  """Checks that file storage is enabled.
268

269
  While it doesn't really fit into this module, L{utils} was deemed too large
270
  of a dependency to be imported for just one or two functions.
271

272
  @raise errors.OpPrereqError: when file storage is disabled
273

274
  """
275
  if not constants.ENABLE_FILE_STORAGE:
276
    raise errors.OpPrereqError("File storage disabled at configure time",
277
                               errors.ECODE_INVAL)
278

    
279

    
280
def RequireSharedFileStorage():
281
  """Checks that shared file storage is enabled.
282

283
  While it doesn't really fit into this module, L{utils} was deemed too large
284
  of a dependency to be imported for just one or two functions.
285

286
  @raise errors.OpPrereqError: when shared file storage is disabled
287

288
  """
289
  if not constants.ENABLE_SHARED_FILE_STORAGE:
290
    raise errors.OpPrereqError("Shared file storage disabled at"
291
                               " configure time", errors.ECODE_INVAL)
292

    
293

    
294
@ht.WithDesc("CheckFileStorage")
295
def _CheckFileStorage(value):
296
  """Ensures file storage is enabled if used.
297

298
  """
299
  if value == constants.DT_FILE:
300
    RequireFileStorage()
301
  elif value == constants.DT_SHARED_FILE:
302
    RequireSharedFileStorage()
303
  return True
304

    
305

    
306
def _BuildDiskTemplateCheck(accept_none):
307
  """Builds check for disk template.
308

309
  @type accept_none: bool
310
  @param accept_none: whether to accept None as a correct value
311
  @rtype: callable
312

313
  """
314
  template_check = ht.TElemOf(constants.DISK_TEMPLATES)
315

    
316
  if accept_none:
317
    template_check = ht.TOr(template_check, ht.TNone)
318

    
319
  return ht.TAnd(template_check, _CheckFileStorage)
320

    
321

    
322
def _CheckStorageType(storage_type):
323
  """Ensure a given storage type is valid.
324

325
  """
326
  if storage_type not in constants.VALID_STORAGE_TYPES:
327
    raise errors.OpPrereqError("Unknown storage type: %s" % storage_type,
328
                               errors.ECODE_INVAL)
329
  if storage_type == constants.ST_FILE:
330
    RequireFileStorage()
331
  return True
332

    
333

    
334
#: Storage type parameter
335
_PStorageType = ("storage_type", ht.NoDefault, _CheckStorageType,
336
                 "Storage type")
337

    
338

    
339
class _AutoOpParamSlots(type):
340
  """Meta class for opcode definitions.
341

342
  """
343
  def __new__(mcs, name, bases, attrs):
344
    """Called when a class should be created.
345

346
    @param mcs: The meta class
347
    @param name: Name of created class
348
    @param bases: Base classes
349
    @type attrs: dict
350
    @param attrs: Class attributes
351

352
    """
353
    assert "__slots__" not in attrs, \
354
      "Class '%s' defines __slots__ when it should use OP_PARAMS" % name
355
    assert "OP_ID" not in attrs, "Class '%s' defining OP_ID" % name
356

    
357
    attrs["OP_ID"] = _NameToId(name)
358

    
359
    # Always set OP_PARAMS to avoid duplicates in BaseOpCode.GetAllParams
360
    params = attrs.setdefault("OP_PARAMS", [])
361

    
362
    # Use parameter names as slots
363
    slots = [pname for (pname, _, _, _) in params]
364

    
365
    assert "OP_DSC_FIELD" not in attrs or attrs["OP_DSC_FIELD"] in slots, \
366
      "Class '%s' uses unknown field in OP_DSC_FIELD" % name
367

    
368
    attrs["__slots__"] = slots
369

    
370
    return type.__new__(mcs, name, bases, attrs)
371

    
372

    
373
class BaseOpCode(object):
374
  """A simple serializable object.
375

376
  This object serves as a parent class for OpCode without any custom
377
  field handling.
378

379
  """
380
  # pylint: disable=E1101
381
  # as OP_ID is dynamically defined
382
  __metaclass__ = _AutoOpParamSlots
383

    
384
  def __init__(self, **kwargs):
385
    """Constructor for BaseOpCode.
386

387
    The constructor takes only keyword arguments and will set
388
    attributes on this object based on the passed arguments. As such,
389
    it means that you should not pass arguments which are not in the
390
    __slots__ attribute for this class.
391

392
    """
393
    slots = self._all_slots()
394
    for key in kwargs:
395
      if key not in slots:
396
        raise TypeError("Object %s doesn't support the parameter '%s'" %
397
                        (self.__class__.__name__, key))
398
      setattr(self, key, kwargs[key])
399

    
400
  def __getstate__(self):
401
    """Generic serializer.
402

403
    This method just returns the contents of the instance as a
404
    dictionary.
405

406
    @rtype:  C{dict}
407
    @return: the instance attributes and their values
408

409
    """
410
    state = {}
411
    for name in self._all_slots():
412
      if hasattr(self, name):
413
        state[name] = getattr(self, name)
414
    return state
415

    
416
  def __setstate__(self, state):
417
    """Generic unserializer.
418

419
    This method just restores from the serialized state the attributes
420
    of the current instance.
421

422
    @param state: the serialized opcode data
423
    @type state:  C{dict}
424

425
    """
426
    if not isinstance(state, dict):
427
      raise ValueError("Invalid data to __setstate__: expected dict, got %s" %
428
                       type(state))
429

    
430
    for name in self._all_slots():
431
      if name not in state and hasattr(self, name):
432
        delattr(self, name)
433

    
434
    for name in state:
435
      setattr(self, name, state[name])
436

    
437
  @classmethod
438
  def _all_slots(cls):
439
    """Compute the list of all declared slots for a class.
440

441
    """
442
    slots = []
443
    for parent in cls.__mro__:
444
      slots.extend(getattr(parent, "__slots__", []))
445
    return slots
446

    
447
  @classmethod
448
  def GetAllParams(cls):
449
    """Compute list of all parameters for an opcode.
450

451
    """
452
    slots = []
453
    for parent in cls.__mro__:
454
      slots.extend(getattr(parent, "OP_PARAMS", []))
455
    return slots
456

    
457
  def Validate(self, set_defaults):
458
    """Validate opcode parameters, optionally setting default values.
459

460
    @type set_defaults: bool
461
    @param set_defaults: Whether to set default values
462
    @raise errors.OpPrereqError: When a parameter value doesn't match
463
                                 requirements
464

465
    """
466
    for (attr_name, default, test, _) in self.GetAllParams():
467
      assert test == ht.NoType or callable(test)
468

    
469
      if not hasattr(self, attr_name):
470
        if default == ht.NoDefault:
471
          raise errors.OpPrereqError("Required parameter '%s.%s' missing" %
472
                                     (self.OP_ID, attr_name),
473
                                     errors.ECODE_INVAL)
474
        elif set_defaults:
475
          if callable(default):
476
            dval = default()
477
          else:
478
            dval = default
479
          setattr(self, attr_name, dval)
480

    
481
      if test == ht.NoType:
482
        # no tests here
483
        continue
484

    
485
      if set_defaults or hasattr(self, attr_name):
486
        attr_val = getattr(self, attr_name)
487
        if not test(attr_val):
488
          logging.error("OpCode %s, parameter %s, has invalid type %s/value %s",
489
                        self.OP_ID, attr_name, type(attr_val), attr_val)
490
          raise errors.OpPrereqError("Parameter '%s.%s' fails validation" %
491
                                     (self.OP_ID, attr_name),
492
                                     errors.ECODE_INVAL)
493

    
494

    
495
def _BuildJobDepCheck(relative):
496
  """Builds check for job dependencies (L{DEPEND_ATTR}).
497

498
  @type relative: bool
499
  @param relative: Whether to accept relative job IDs (negative)
500
  @rtype: callable
501

502
  """
503
  if relative:
504
    job_id = ht.TOr(ht.TJobId, ht.TRelativeJobId)
505
  else:
506
    job_id = ht.TJobId
507

    
508
  job_dep = \
509
    ht.TAnd(ht.TIsLength(2),
510
            ht.TItems([job_id,
511
                       ht.TListOf(ht.TElemOf(constants.JOBS_FINALIZED))]))
512

    
513
  return ht.TMaybeListOf(job_dep)
514

    
515

    
516
TNoRelativeJobDependencies = _BuildJobDepCheck(False)
517

    
518
#: List of submission status and job ID as returned by C{SubmitManyJobs}
519
_TJobIdListItem = \
520
  ht.TAnd(ht.TIsLength(2),
521
          ht.TItems([ht.Comment("success")(ht.TBool),
522
                     ht.Comment("Job ID if successful, error message"
523
                                " otherwise")(ht.TOr(ht.TString,
524
                                                     ht.TJobId))]))
525
TJobIdList = ht.TListOf(_TJobIdListItem)
526

    
527
#: Result containing only list of submitted jobs
528
TJobIdListOnly = ht.TStrictDict(True, True, {
529
  constants.JOB_IDS_KEY: ht.Comment("List of submitted jobs")(TJobIdList),
530
  })
531

    
532

    
533
class OpCode(BaseOpCode):
534
  """Abstract OpCode.
535

536
  This is the root of the actual OpCode hierarchy. All clases derived
537
  from this class should override OP_ID.
538

539
  @cvar OP_ID: The ID of this opcode. This should be unique amongst all
540
               children of this class.
541
  @cvar OP_DSC_FIELD: The name of a field whose value will be included in the
542
                      string returned by Summary(); see the docstring of that
543
                      method for details).
544
  @cvar OP_PARAMS: List of opcode attributes, the default values they should
545
                   get if not already defined, and types they must match.
546
  @cvar OP_RESULT: Callable to verify opcode result
547
  @cvar WITH_LU: Boolean that specifies whether this should be included in
548
      mcpu's dispatch table
549
  @ivar dry_run: Whether the LU should be run in dry-run mode, i.e. just
550
                 the check steps
551
  @ivar priority: Opcode priority for queue
552

553
  """
554
  # pylint: disable=E1101
555
  # as OP_ID is dynamically defined
556
  WITH_LU = True
557
  OP_PARAMS = [
558
    ("dry_run", None, ht.TMaybeBool, "Run checks only, don't execute"),
559
    ("debug_level", None, ht.TOr(ht.TNone, ht.TPositiveInt), "Debug level"),
560
    ("priority", constants.OP_PRIO_DEFAULT,
561
     ht.TElemOf(constants.OP_PRIO_SUBMIT_VALID), "Opcode priority"),
562
    (DEPEND_ATTR, None, _BuildJobDepCheck(True),
563
     "Job dependencies; if used through ``SubmitManyJobs`` relative (negative)"
564
     " job IDs can be used; see :doc:`design document <design-chained-jobs>`"
565
     " for details"),
566
    (COMMENT_ATTR, None, ht.TMaybeString,
567
     "Comment describing the purpose of the opcode"),
568
    ]
569
  OP_RESULT = None
570

    
571
  def __getstate__(self):
572
    """Specialized getstate for opcodes.
573

574
    This method adds to the state dictionary the OP_ID of the class,
575
    so that on unload we can identify the correct class for
576
    instantiating the opcode.
577

578
    @rtype:   C{dict}
579
    @return:  the state as a dictionary
580

581
    """
582
    data = BaseOpCode.__getstate__(self)
583
    data["OP_ID"] = self.OP_ID
584
    return data
585

    
586
  @classmethod
587
  def LoadOpCode(cls, data):
588
    """Generic load opcode method.
589

590
    The method identifies the correct opcode class from the dict-form
591
    by looking for a OP_ID key, if this is not found, or its value is
592
    not available in this module as a child of this class, we fail.
593

594
    @type data:  C{dict}
595
    @param data: the serialized opcode
596

597
    """
598
    if not isinstance(data, dict):
599
      raise ValueError("Invalid data to LoadOpCode (%s)" % type(data))
600
    if "OP_ID" not in data:
601
      raise ValueError("Invalid data to LoadOpcode, missing OP_ID")
602
    op_id = data["OP_ID"]
603
    op_class = None
604
    if op_id in OP_MAPPING:
605
      op_class = OP_MAPPING[op_id]
606
    else:
607
      raise ValueError("Invalid data to LoadOpCode: OP_ID %s unsupported" %
608
                       op_id)
609
    op = op_class()
610
    new_data = data.copy()
611
    del new_data["OP_ID"]
612
    op.__setstate__(new_data)
613
    return op
614

    
615
  def Summary(self):
616
    """Generates a summary description of this opcode.
617

618
    The summary is the value of the OP_ID attribute (without the "OP_"
619
    prefix), plus the value of the OP_DSC_FIELD attribute, if one was
620
    defined; this field should allow to easily identify the operation
621
    (for an instance creation job, e.g., it would be the instance
622
    name).
623

624
    """
625
    assert self.OP_ID is not None and len(self.OP_ID) > 3
626
    # all OP_ID start with OP_, we remove that
627
    txt = self.OP_ID[3:]
628
    field_name = getattr(self, "OP_DSC_FIELD", None)
629
    if field_name:
630
      field_value = getattr(self, field_name, None)
631
      if isinstance(field_value, (list, tuple)):
632
        field_value = ",".join(str(i) for i in field_value)
633
      txt = "%s(%s)" % (txt, field_value)
634
    return txt
635

    
636
  def TinySummary(self):
637
    """Generates a compact summary description of the opcode.
638

639
    """
640
    assert self.OP_ID.startswith("OP_")
641

    
642
    text = self.OP_ID[3:]
643

    
644
    for (prefix, supplement) in _SUMMARY_PREFIX.items():
645
      if text.startswith(prefix):
646
        return supplement + text[len(prefix):]
647

    
648
    return text
649

    
650

    
651
# cluster opcodes
652

    
653
class OpClusterPostInit(OpCode):
654
  """Post cluster initialization.
655

656
  This opcode does not touch the cluster at all. Its purpose is to run hooks
657
  after the cluster has been initialized.
658

659
  """
660
  OP_RESULT = ht.TBool
661

    
662

    
663
class OpClusterDestroy(OpCode):
664
  """Destroy the cluster.
665

666
  This opcode has no other parameters. All the state is irreversibly
667
  lost after the execution of this opcode.
668

669
  """
670
  OP_RESULT = ht.TNonEmptyString
671

    
672

    
673
class OpClusterQuery(OpCode):
674
  """Query cluster information."""
675
  OP_RESULT = ht.TDictOf(ht.TNonEmptyString, ht.TAny)
676

    
677

    
678
class OpClusterVerify(OpCode):
679
  """Submits all jobs necessary to verify the cluster.
680

681
  """
682
  OP_PARAMS = [
683
    _PDebugSimulateErrors,
684
    _PErrorCodes,
685
    _PSkipChecks,
686
    _PIgnoreErrors,
687
    _PVerbose,
688
    ("group_name", None, ht.TMaybeString, "Group to verify")
689
    ]
690
  OP_RESULT = TJobIdListOnly
691

    
692

    
693
class OpClusterVerifyConfig(OpCode):
694
  """Verify the cluster config.
695

696
  """
697
  OP_PARAMS = [
698
    _PDebugSimulateErrors,
699
    _PErrorCodes,
700
    _PIgnoreErrors,
701
    _PVerbose,
702
    ]
703
  OP_RESULT = ht.TBool
704

    
705

    
706
class OpClusterVerifyGroup(OpCode):
707
  """Run verify on a node group from the cluster.
708

709
  @type skip_checks: C{list}
710
  @ivar skip_checks: steps to be skipped from the verify process; this
711
                     needs to be a subset of
712
                     L{constants.VERIFY_OPTIONAL_CHECKS}; currently
713
                     only L{constants.VERIFY_NPLUSONE_MEM} can be passed
714

715
  """
716
  OP_DSC_FIELD = "group_name"
717
  OP_PARAMS = [
718
    _PGroupName,
719
    _PDebugSimulateErrors,
720
    _PErrorCodes,
721
    _PSkipChecks,
722
    _PIgnoreErrors,
723
    _PVerbose,
724
    ]
725
  OP_RESULT = ht.TBool
726

    
727

    
728
class OpClusterVerifyDisks(OpCode):
729
  """Verify the cluster disks.
730

731
  """
732
  OP_RESULT = TJobIdListOnly
733

    
734

    
735
class OpGroupVerifyDisks(OpCode):
736
  """Verifies the status of all disks in a node group.
737

738
  Result: a tuple of three elements:
739
    - dict of node names with issues (values: error msg)
740
    - list of instances with degraded disks (that should be activated)
741
    - dict of instances with missing logical volumes (values: (node, vol)
742
      pairs with details about the missing volumes)
743

744
  In normal operation, all lists should be empty. A non-empty instance
745
  list (3rd element of the result) is still ok (errors were fixed) but
746
  non-empty node list means some node is down, and probably there are
747
  unfixable drbd errors.
748

749
  Note that only instances that are drbd-based are taken into
750
  consideration. This might need to be revisited in the future.
751

752
  """
753
  OP_DSC_FIELD = "group_name"
754
  OP_PARAMS = [
755
    _PGroupName,
756
    ]
757
  OP_RESULT = \
758
    ht.TAnd(ht.TIsLength(3),
759
            ht.TItems([ht.TDictOf(ht.TString, ht.TString),
760
                       ht.TListOf(ht.TString),
761
                       ht.TDictOf(ht.TString,
762
                                  ht.TListOf(ht.TListOf(ht.TString)))]))
763

    
764

    
765
class OpClusterRepairDiskSizes(OpCode):
766
  """Verify the disk sizes of the instances and fixes configuration
767
  mimatches.
768

769
  Parameters: optional instances list, in case we want to restrict the
770
  checks to only a subset of the instances.
771

772
  Result: a list of tuples, (instance, disk, new-size) for changed
773
  configurations.
774

775
  In normal operation, the list should be empty.
776

777
  @type instances: list
778
  @ivar instances: the list of instances to check, or empty for all instances
779

780
  """
781
  OP_PARAMS = [
782
    ("instances", ht.EmptyList, ht.TListOf(ht.TNonEmptyString), None),
783
    ]
784
  OP_RESULT = ht.TListOf(ht.TAnd(ht.TIsLength(3),
785
                                 ht.TItems([ht.TNonEmptyString,
786
                                            ht.TPositiveInt,
787
                                            ht.TPositiveInt])))
788

    
789

    
790
class OpClusterConfigQuery(OpCode):
791
  """Query cluster configuration values."""
792
  OP_PARAMS = [
793
    _POutputFields
794
    ]
795
  OP_RESULT = ht.TListOf(ht.TAny)
796

    
797

    
798
class OpClusterRename(OpCode):
799
  """Rename the cluster.
800

801
  @type name: C{str}
802
  @ivar name: The new name of the cluster. The name and/or the master IP
803
              address will be changed to match the new name and its IP
804
              address.
805

806
  """
807
  OP_DSC_FIELD = "name"
808
  OP_PARAMS = [
809
    ("name", ht.NoDefault, ht.TNonEmptyString, None),
810
    ]
811
  OP_RESULT = ht.TNonEmptyString
812

    
813

    
814
class OpClusterSetParams(OpCode):
815
  """Change the parameters of the cluster.
816

817
  @type vg_name: C{str} or C{None}
818
  @ivar vg_name: The new volume group name or None to disable LVM usage.
819

820
  """
821
  OP_PARAMS = [
822
    _PHvState,
823
    _PDiskState,
824
    ("vg_name", None, ht.TMaybeString, "Volume group name"),
825
    ("enabled_hypervisors", None,
826
     ht.TOr(ht.TAnd(ht.TListOf(ht.TElemOf(constants.HYPER_TYPES)), ht.TTrue),
827
            ht.TNone),
828
     "List of enabled hypervisors"),
829
    ("hvparams", None, ht.TOr(ht.TDictOf(ht.TNonEmptyString, ht.TDict),
830
                              ht.TNone),
831
     "Cluster-wide hypervisor parameter defaults, hypervisor-dependent"),
832
    ("beparams", None, ht.TOr(ht.TDict, ht.TNone),
833
     "Cluster-wide backend parameter defaults"),
834
    ("os_hvp", None, ht.TOr(ht.TDictOf(ht.TNonEmptyString, ht.TDict),
835
                            ht.TNone),
836
     "Cluster-wide per-OS hypervisor parameter defaults"),
837
    ("osparams", None, ht.TOr(ht.TDictOf(ht.TNonEmptyString, ht.TDict),
838
                              ht.TNone),
839
     "Cluster-wide OS parameter defaults"),
840
    _PDiskParams,
841
    ("candidate_pool_size", None, ht.TOr(ht.TStrictPositiveInt, ht.TNone),
842
     "Master candidate pool size"),
843
    ("uid_pool", None, ht.NoType,
844
     "Set UID pool, must be list of lists describing UID ranges (two items,"
845
     " start and end inclusive)"),
846
    ("add_uids", None, ht.NoType,
847
     "Extend UID pool, must be list of lists describing UID ranges (two"
848
     " items, start and end inclusive) to be added"),
849
    ("remove_uids", None, ht.NoType,
850
     "Shrink UID pool, must be list of lists describing UID ranges (two"
851
     " items, start and end inclusive) to be removed"),
852
    ("maintain_node_health", None, ht.TMaybeBool,
853
     "Whether to automatically maintain node health"),
854
    ("prealloc_wipe_disks", None, ht.TMaybeBool,
855
     "Whether to wipe disks before allocating them to instances"),
856
    ("nicparams", None, ht.TMaybeDict, "Cluster-wide NIC parameter defaults"),
857
    ("ndparams", None, ht.TMaybeDict, "Cluster-wide node parameter defaults"),
858
    ("ipolicy", None, ht.TMaybeDict,
859
     "Cluster-wide :ref:`instance policy <rapi-ipolicy>` specs"),
860
    ("drbd_helper", None, ht.TOr(ht.TString, ht.TNone), "DRBD helper program"),
861
    ("default_iallocator", None, ht.TOr(ht.TString, ht.TNone),
862
     "Default iallocator for cluster"),
863
    ("master_netdev", None, ht.TOr(ht.TString, ht.TNone),
864
     "Master network device"),
865
    ("master_netmask", None, ht.TOr(ht.TInt, ht.TNone),
866
     "Netmask of the master IP"),
867
    ("reserved_lvs", None, ht.TMaybeListOf(ht.TNonEmptyString),
868
     "List of reserved LVs"),
869
    ("hidden_os", None, _TestClusterOsList,
870
     "Modify list of hidden operating systems. Each modification must have"
871
     " two items, the operation and the OS name. The operation can be"
872
     " ``%s`` or ``%s``." % (constants.DDM_ADD, constants.DDM_REMOVE)),
873
    ("blacklisted_os", None, _TestClusterOsList,
874
     "Modify list of blacklisted operating systems. Each modification must have"
875
     " two items, the operation and the OS name. The operation can be"
876
     " ``%s`` or ``%s``." % (constants.DDM_ADD, constants.DDM_REMOVE)),
877
    ("use_external_mip_script", None, ht.TMaybeBool,
878
     "Whether to use an external master IP address setup script"),
879
    ]
880
  OP_RESULT = ht.TNone
881

    
882

    
883
class OpClusterRedistConf(OpCode):
884
  """Force a full push of the cluster configuration.
885

886
  """
887
  OP_RESULT = ht.TNone
888

    
889

    
890
class OpClusterActivateMasterIp(OpCode):
891
  """Activate the master IP on the master node.
892

893
  """
894
  OP_RESULT = ht.TNone
895

    
896

    
897
class OpClusterDeactivateMasterIp(OpCode):
898
  """Deactivate the master IP on the master node.
899

900
  """
901
  OP_RESULT = ht.TNone
902

    
903

    
904
class OpQuery(OpCode):
905
  """Query for resources/items.
906

907
  @ivar what: Resources to query for, must be one of L{constants.QR_VIA_OP}
908
  @ivar fields: List of fields to retrieve
909
  @ivar qfilter: Query filter
910

911
  """
912
  OP_DSC_FIELD = "what"
913
  OP_PARAMS = [
914
    _PQueryWhat,
915
    _PUseLocking,
916
    ("fields", ht.NoDefault, ht.TListOf(ht.TNonEmptyString),
917
     "Requested fields"),
918
    ("qfilter", None, ht.TOr(ht.TNone, ht.TList),
919
     "Query filter"),
920
    ]
921
  OP_RESULT = \
922
    _GenerateObjectTypeCheck(objects.QueryResponse, {
923
      "fields": ht.TListOf(_TQueryFieldDef),
924
      "data": _TQueryResult,
925
      })
926

    
927

    
928
class OpQueryFields(OpCode):
929
  """Query for available resource/item fields.
930

931
  @ivar what: Resources to query for, must be one of L{constants.QR_VIA_OP}
932
  @ivar fields: List of fields to retrieve
933

934
  """
935
  OP_DSC_FIELD = "what"
936
  OP_PARAMS = [
937
    _PQueryWhat,
938
    ("fields", None, ht.TMaybeListOf(ht.TNonEmptyString),
939
     "Requested fields; if not given, all are returned"),
940
    ]
941
  OP_RESULT = \
942
    _GenerateObjectTypeCheck(objects.QueryFieldsResponse, {
943
      "fields": ht.TListOf(_TQueryFieldDef),
944
      })
945

    
946

    
947
class OpOobCommand(OpCode):
948
  """Interact with OOB."""
949
  OP_PARAMS = [
950
    ("node_names", ht.EmptyList, ht.TListOf(ht.TNonEmptyString),
951
     "List of nodes to run the OOB command against"),
952
    ("command", None, ht.TElemOf(constants.OOB_COMMANDS),
953
     "OOB command to be run"),
954
    ("timeout", constants.OOB_TIMEOUT, ht.TInt,
955
     "Timeout before the OOB helper will be terminated"),
956
    ("ignore_status", False, ht.TBool,
957
     "Ignores the node offline status for power off"),
958
    ("power_delay", constants.OOB_POWER_DELAY, ht.TPositiveFloat,
959
     "Time in seconds to wait between powering on nodes"),
960
    ]
961
  # Fixme: Make it more specific with all the special cases in LUOobCommand
962
  OP_RESULT = _TQueryResult
963

    
964

    
965
# node opcodes
966

    
967
class OpNodeRemove(OpCode):
968
  """Remove a node.
969

970
  @type node_name: C{str}
971
  @ivar node_name: The name of the node to remove. If the node still has
972
                   instances on it, the operation will fail.
973

974
  """
975
  OP_DSC_FIELD = "node_name"
976
  OP_PARAMS = [
977
    _PNodeName,
978
    ]
979
  OP_RESULT = ht.TNone
980

    
981

    
982
class OpNodeAdd(OpCode):
983
  """Add a node to the cluster.
984

985
  @type node_name: C{str}
986
  @ivar node_name: The name of the node to add. This can be a short name,
987
                   but it will be expanded to the FQDN.
988
  @type primary_ip: IP address
989
  @ivar primary_ip: The primary IP of the node. This will be ignored when the
990
                    opcode is submitted, but will be filled during the node
991
                    add (so it will be visible in the job query).
992
  @type secondary_ip: IP address
993
  @ivar secondary_ip: The secondary IP of the node. This needs to be passed
994
                      if the cluster has been initialized in 'dual-network'
995
                      mode, otherwise it must not be given.
996
  @type readd: C{bool}
997
  @ivar readd: Whether to re-add an existing node to the cluster. If
998
               this is not passed, then the operation will abort if the node
999
               name is already in the cluster; use this parameter to 'repair'
1000
               a node that had its configuration broken, or was reinstalled
1001
               without removal from the cluster.
1002
  @type group: C{str}
1003
  @ivar group: The node group to which this node will belong.
1004
  @type vm_capable: C{bool}
1005
  @ivar vm_capable: The vm_capable node attribute
1006
  @type master_capable: C{bool}
1007
  @ivar master_capable: The master_capable node attribute
1008

1009
  """
1010
  OP_DSC_FIELD = "node_name"
1011
  OP_PARAMS = [
1012
    _PNodeName,
1013
    _PHvState,
1014
    _PDiskState,
1015
    ("primary_ip", None, ht.NoType, "Primary IP address"),
1016
    ("secondary_ip", None, ht.TMaybeString, "Secondary IP address"),
1017
    ("readd", False, ht.TBool, "Whether node is re-added to cluster"),
1018
    ("group", None, ht.TMaybeString, "Initial node group"),
1019
    ("master_capable", None, ht.TMaybeBool,
1020
     "Whether node can become master or master candidate"),
1021
    ("vm_capable", None, ht.TMaybeBool,
1022
     "Whether node can host instances"),
1023
    ("ndparams", None, ht.TMaybeDict, "Node parameters"),
1024
    ]
1025
  OP_RESULT = ht.TNone
1026

    
1027

    
1028
class OpNodeQuery(OpCode):
1029
  """Compute the list of nodes."""
1030
  OP_PARAMS = [
1031
    _POutputFields,
1032
    _PUseLocking,
1033
    ("names", ht.EmptyList, ht.TListOf(ht.TNonEmptyString),
1034
     "Empty list to query all nodes, node names otherwise"),
1035
    ]
1036
  OP_RESULT = _TOldQueryResult
1037

    
1038

    
1039
class OpNodeQueryvols(OpCode):
1040
  """Get list of volumes on node."""
1041
  OP_PARAMS = [
1042
    _POutputFields,
1043
    ("nodes", ht.EmptyList, ht.TListOf(ht.TNonEmptyString),
1044
     "Empty list to query all nodes, node names otherwise"),
1045
    ]
1046
  OP_RESULT = ht.TListOf(ht.TAny)
1047

    
1048

    
1049
class OpNodeQueryStorage(OpCode):
1050
  """Get information on storage for node(s)."""
1051
  OP_PARAMS = [
1052
    _POutputFields,
1053
    _PStorageType,
1054
    ("nodes", ht.EmptyList, ht.TListOf(ht.TNonEmptyString), "List of nodes"),
1055
    ("name", None, ht.TMaybeString, "Storage name"),
1056
    ]
1057
  OP_RESULT = _TOldQueryResult
1058

    
1059

    
1060
class OpNodeModifyStorage(OpCode):
1061
  """Modifies the properies of a storage unit"""
1062
  OP_PARAMS = [
1063
    _PNodeName,
1064
    _PStorageType,
1065
    _PStorageName,
1066
    ("changes", ht.NoDefault, ht.TDict, "Requested changes"),
1067
    ]
1068
  OP_RESULT = ht.TNone
1069

    
1070

    
1071
class OpRepairNodeStorage(OpCode):
1072
  """Repairs the volume group on a node."""
1073
  OP_DSC_FIELD = "node_name"
1074
  OP_PARAMS = [
1075
    _PNodeName,
1076
    _PStorageType,
1077
    _PStorageName,
1078
    _PIgnoreConsistency,
1079
    ]
1080
  OP_RESULT = ht.TNone
1081

    
1082

    
1083
class OpNodeSetParams(OpCode):
1084
  """Change the parameters of a node."""
1085
  OP_DSC_FIELD = "node_name"
1086
  OP_PARAMS = [
1087
    _PNodeName,
1088
    _PForce,
1089
    _PHvState,
1090
    _PDiskState,
1091
    ("master_candidate", None, ht.TMaybeBool,
1092
     "Whether the node should become a master candidate"),
1093
    ("offline", None, ht.TMaybeBool,
1094
     "Whether the node should be marked as offline"),
1095
    ("drained", None, ht.TMaybeBool,
1096
     "Whether the node should be marked as drained"),
1097
    ("auto_promote", False, ht.TBool,
1098
     "Whether node(s) should be promoted to master candidate if necessary"),
1099
    ("master_capable", None, ht.TMaybeBool,
1100
     "Denote whether node can become master or master candidate"),
1101
    ("vm_capable", None, ht.TMaybeBool,
1102
     "Denote whether node can host instances"),
1103
    ("secondary_ip", None, ht.TMaybeString,
1104
     "Change node's secondary IP address"),
1105
    ("ndparams", None, ht.TMaybeDict, "Set node parameters"),
1106
    ("powered", None, ht.TMaybeBool,
1107
     "Whether the node should be marked as powered"),
1108
    ]
1109
  OP_RESULT = _TSetParamsResult
1110

    
1111

    
1112
class OpNodePowercycle(OpCode):
1113
  """Tries to powercycle a node."""
1114
  OP_DSC_FIELD = "node_name"
1115
  OP_PARAMS = [
1116
    _PNodeName,
1117
    _PForce,
1118
    ]
1119
  OP_RESULT = ht.TMaybeString
1120

    
1121

    
1122
class OpNodeMigrate(OpCode):
1123
  """Migrate all instances from a node."""
1124
  OP_DSC_FIELD = "node_name"
1125
  OP_PARAMS = [
1126
    _PNodeName,
1127
    _PMigrationMode,
1128
    _PMigrationLive,
1129
    _PMigrationTargetNode,
1130
    _PAllowRuntimeChgs,
1131
    _PIgnoreIpolicy,
1132
    ("iallocator", None, ht.TMaybeString,
1133
     "Iallocator for deciding the target node for shared-storage instances"),
1134
    ]
1135
  OP_RESULT = TJobIdListOnly
1136

    
1137

    
1138
class OpNodeEvacuate(OpCode):
1139
  """Evacuate instances off a number of nodes."""
1140
  OP_DSC_FIELD = "node_name"
1141
  OP_PARAMS = [
1142
    _PEarlyRelease,
1143
    _PNodeName,
1144
    ("remote_node", None, ht.TMaybeString, "New secondary node"),
1145
    ("iallocator", None, ht.TMaybeString, "Iallocator for computing solution"),
1146
    ("mode", ht.NoDefault, ht.TElemOf(constants.NODE_EVAC_MODES),
1147
     "Node evacuation mode"),
1148
    ]
1149
  OP_RESULT = TJobIdListOnly
1150

    
1151

    
1152
# instance opcodes
1153

    
1154
class OpInstanceCreate(OpCode):
1155
  """Create an instance.
1156

1157
  @ivar instance_name: Instance name
1158
  @ivar mode: Instance creation mode (one of L{constants.INSTANCE_CREATE_MODES})
1159
  @ivar source_handshake: Signed handshake from source (remote import only)
1160
  @ivar source_x509_ca: Source X509 CA in PEM format (remote import only)
1161
  @ivar source_instance_name: Previous name of instance (remote import only)
1162
  @ivar source_shutdown_timeout: Shutdown timeout used for source instance
1163
    (remote import only)
1164

1165
  """
1166
  OP_DSC_FIELD = "instance_name"
1167
  OP_PARAMS = [
1168
    _PInstanceName,
1169
    _PForceVariant,
1170
    _PWaitForSync,
1171
    _PNameCheck,
1172
    _PIgnoreIpolicy,
1173
    ("beparams", ht.EmptyDict, ht.TDict, "Backend parameters for instance"),
1174
    ("disks", ht.NoDefault, ht.TListOf(_TDiskParams),
1175
     "Disk descriptions, for example ``[{\"%s\": 100}, {\"%s\": 5}]``;"
1176
     " each disk definition must contain a ``%s`` value and"
1177
     " can contain an optional ``%s`` value denoting the disk access mode"
1178
     " (%s)" %
1179
     (constants.IDISK_SIZE, constants.IDISK_SIZE, constants.IDISK_SIZE,
1180
      constants.IDISK_MODE,
1181
      " or ".join("``%s``" % i for i in sorted(constants.DISK_ACCESS_SET)))),
1182
    ("disk_template", ht.NoDefault, _BuildDiskTemplateCheck(True),
1183
     "Disk template"),
1184
    ("file_driver", None, ht.TOr(ht.TNone, ht.TElemOf(constants.FILE_DRIVER)),
1185
     "Driver for file-backed disks"),
1186
    ("file_storage_dir", None, ht.TMaybeString,
1187
     "Directory for storing file-backed disks"),
1188
    ("hvparams", ht.EmptyDict, ht.TDict,
1189
     "Hypervisor parameters for instance, hypervisor-dependent"),
1190
    ("hypervisor", None, ht.TMaybeString, "Hypervisor"),
1191
    ("iallocator", None, ht.TMaybeString,
1192
     "Iallocator for deciding which node(s) to use"),
1193
    ("identify_defaults", False, ht.TBool,
1194
     "Reset instance parameters to default if equal"),
1195
    ("ip_check", True, ht.TBool, _PIpCheckDoc),
1196
    ("mode", ht.NoDefault, ht.TElemOf(constants.INSTANCE_CREATE_MODES),
1197
     "Instance creation mode"),
1198
    ("nics", ht.NoDefault, ht.TListOf(_TestNicDef),
1199
     "List of NIC (network interface) definitions, for example"
1200
     " ``[{}, {}, {\"%s\": \"198.51.100.4\"}]``; each NIC definition can"
1201
     " contain the optional values %s" %
1202
     (constants.INIC_IP,
1203
      ", ".join("``%s``" % i for i in sorted(constants.INIC_PARAMS)))),
1204
    ("no_install", None, ht.TMaybeBool,
1205
     "Do not install the OS (will disable automatic start)"),
1206
    ("osparams", ht.EmptyDict, ht.TDict, "OS parameters for instance"),
1207
    ("os_type", None, ht.TMaybeString, "Operating system"),
1208
    ("pnode", None, ht.TMaybeString, "Primary node"),
1209
    ("snode", None, ht.TMaybeString, "Secondary node"),
1210
    ("source_handshake", None, ht.TOr(ht.TList, ht.TNone),
1211
     "Signed handshake from source (remote import only)"),
1212
    ("source_instance_name", None, ht.TMaybeString,
1213
     "Source instance name (remote import only)"),
1214
    ("source_shutdown_timeout", constants.DEFAULT_SHUTDOWN_TIMEOUT,
1215
     ht.TPositiveInt,
1216
     "How long source instance was given to shut down (remote import only)"),
1217
    ("source_x509_ca", None, ht.TMaybeString,
1218
     "Source X509 CA in PEM format (remote import only)"),
1219
    ("src_node", None, ht.TMaybeString, "Source node for import"),
1220
    ("src_path", None, ht.TMaybeString, "Source directory for import"),
1221
    ("start", True, ht.TBool, "Whether to start instance after creation"),
1222
    ("tags", ht.EmptyList, ht.TListOf(ht.TNonEmptyString), "Instance tags"),
1223
    ]
1224
  OP_RESULT = ht.Comment("instance nodes")(ht.TListOf(ht.TNonEmptyString))
1225

    
1226

    
1227
class OpInstanceReinstall(OpCode):
1228
  """Reinstall an instance's OS."""
1229
  OP_DSC_FIELD = "instance_name"
1230
  OP_PARAMS = [
1231
    _PInstanceName,
1232
    _PForceVariant,
1233
    ("os_type", None, ht.TMaybeString, "Instance operating system"),
1234
    ("osparams", None, ht.TMaybeDict, "Temporary OS parameters"),
1235
    ]
1236
  OP_RESULT = ht.TNone
1237

    
1238

    
1239
class OpInstanceRemove(OpCode):
1240
  """Remove an instance."""
1241
  OP_DSC_FIELD = "instance_name"
1242
  OP_PARAMS = [
1243
    _PInstanceName,
1244
    _PShutdownTimeout,
1245
    ("ignore_failures", False, ht.TBool,
1246
     "Whether to ignore failures during removal"),
1247
    ]
1248
  OP_RESULT = ht.TNone
1249

    
1250

    
1251
class OpInstanceRename(OpCode):
1252
  """Rename an instance."""
1253
  OP_PARAMS = [
1254
    _PInstanceName,
1255
    _PNameCheck,
1256
    ("new_name", ht.NoDefault, ht.TNonEmptyString, "New instance name"),
1257
    ("ip_check", False, ht.TBool, _PIpCheckDoc),
1258
    ]
1259
  OP_RESULT = ht.Comment("New instance name")(ht.TNonEmptyString)
1260

    
1261

    
1262
class OpInstanceStartup(OpCode):
1263
  """Startup an instance."""
1264
  OP_DSC_FIELD = "instance_name"
1265
  OP_PARAMS = [
1266
    _PInstanceName,
1267
    _PForce,
1268
    _PIgnoreOfflineNodes,
1269
    ("hvparams", ht.EmptyDict, ht.TDict,
1270
     "Temporary hypervisor parameters, hypervisor-dependent"),
1271
    ("beparams", ht.EmptyDict, ht.TDict, "Temporary backend parameters"),
1272
    _PNoRemember,
1273
    _PStartupPaused,
1274
    ]
1275
  OP_RESULT = ht.TNone
1276

    
1277

    
1278
class OpInstanceShutdown(OpCode):
1279
  """Shutdown an instance."""
1280
  OP_DSC_FIELD = "instance_name"
1281
  OP_PARAMS = [
1282
    _PInstanceName,
1283
    _PIgnoreOfflineNodes,
1284
    ("timeout", constants.DEFAULT_SHUTDOWN_TIMEOUT, ht.TPositiveInt,
1285
     "How long to wait for instance to shut down"),
1286
    _PNoRemember,
1287
    ]
1288
  OP_RESULT = ht.TNone
1289

    
1290

    
1291
class OpInstanceReboot(OpCode):
1292
  """Reboot an instance."""
1293
  OP_DSC_FIELD = "instance_name"
1294
  OP_PARAMS = [
1295
    _PInstanceName,
1296
    _PShutdownTimeout,
1297
    ("ignore_secondaries", False, ht.TBool,
1298
     "Whether to start the instance even if secondary disks are failing"),
1299
    ("reboot_type", ht.NoDefault, ht.TElemOf(constants.REBOOT_TYPES),
1300
     "How to reboot instance"),
1301
    ]
1302
  OP_RESULT = ht.TNone
1303

    
1304

    
1305
class OpInstanceReplaceDisks(OpCode):
1306
  """Replace the disks of an instance."""
1307
  OP_DSC_FIELD = "instance_name"
1308
  OP_PARAMS = [
1309
    _PInstanceName,
1310
    _PEarlyRelease,
1311
    _PIgnoreIpolicy,
1312
    ("mode", ht.NoDefault, ht.TElemOf(constants.REPLACE_MODES),
1313
     "Replacement mode"),
1314
    ("disks", ht.EmptyList, ht.TListOf(ht.TPositiveInt),
1315
     "Disk indexes"),
1316
    ("remote_node", None, ht.TMaybeString, "New secondary node"),
1317
    ("iallocator", None, ht.TMaybeString,
1318
     "Iallocator for deciding new secondary node"),
1319
    ]
1320
  OP_RESULT = ht.TNone
1321

    
1322

    
1323
class OpInstanceFailover(OpCode):
1324
  """Failover an instance."""
1325
  OP_DSC_FIELD = "instance_name"
1326
  OP_PARAMS = [
1327
    _PInstanceName,
1328
    _PShutdownTimeout,
1329
    _PIgnoreConsistency,
1330
    _PMigrationTargetNode,
1331
    _PIgnoreIpolicy,
1332
    ("iallocator", None, ht.TMaybeString,
1333
     "Iallocator for deciding the target node for shared-storage instances"),
1334
    ]
1335
  OP_RESULT = ht.TNone
1336

    
1337

    
1338
class OpInstanceMigrate(OpCode):
1339
  """Migrate an instance.
1340

1341
  This migrates (without shutting down an instance) to its secondary
1342
  node.
1343

1344
  @ivar instance_name: the name of the instance
1345
  @ivar mode: the migration mode (live, non-live or None for auto)
1346

1347
  """
1348
  OP_DSC_FIELD = "instance_name"
1349
  OP_PARAMS = [
1350
    _PInstanceName,
1351
    _PMigrationMode,
1352
    _PMigrationLive,
1353
    _PMigrationTargetNode,
1354
    _PAllowRuntimeChgs,
1355
    _PIgnoreIpolicy,
1356
    ("cleanup", False, ht.TBool,
1357
     "Whether a previously failed migration should be cleaned up"),
1358
    ("iallocator", None, ht.TMaybeString,
1359
     "Iallocator for deciding the target node for shared-storage instances"),
1360
    ("allow_failover", False, ht.TBool,
1361
     "Whether we can fallback to failover if migration is not possible"),
1362
    ]
1363
  OP_RESULT = ht.TNone
1364

    
1365

    
1366
class OpInstanceMove(OpCode):
1367
  """Move an instance.
1368

1369
  This move (with shutting down an instance and data copying) to an
1370
  arbitrary node.
1371

1372
  @ivar instance_name: the name of the instance
1373
  @ivar target_node: the destination node
1374

1375
  """
1376
  OP_DSC_FIELD = "instance_name"
1377
  OP_PARAMS = [
1378
    _PInstanceName,
1379
    _PShutdownTimeout,
1380
    _PIgnoreIpolicy,
1381
    ("target_node", ht.NoDefault, ht.TNonEmptyString, "Target node"),
1382
    _PIgnoreConsistency,
1383
    ]
1384
  OP_RESULT = ht.TNone
1385

    
1386

    
1387
class OpInstanceConsole(OpCode):
1388
  """Connect to an instance's console."""
1389
  OP_DSC_FIELD = "instance_name"
1390
  OP_PARAMS = [
1391
    _PInstanceName
1392
    ]
1393
  OP_RESULT = ht.TDict
1394

    
1395

    
1396
class OpInstanceActivateDisks(OpCode):
1397
  """Activate an instance's disks."""
1398
  OP_DSC_FIELD = "instance_name"
1399
  OP_PARAMS = [
1400
    _PInstanceName,
1401
    ("ignore_size", False, ht.TBool, "Whether to ignore recorded size"),
1402
    ]
1403
  OP_RESULT = ht.TListOf(ht.TAnd(ht.TIsLength(3),
1404
                                 ht.TItems([ht.TNonEmptyString,
1405
                                            ht.TNonEmptyString,
1406
                                            ht.TNonEmptyString])))
1407

    
1408

    
1409
class OpInstanceDeactivateDisks(OpCode):
1410
  """Deactivate an instance's disks."""
1411
  OP_DSC_FIELD = "instance_name"
1412
  OP_PARAMS = [
1413
    _PInstanceName,
1414
    _PForce,
1415
    ]
1416
  OP_RESULT = ht.TNone
1417

    
1418

    
1419
class OpInstanceRecreateDisks(OpCode):
1420
  """Recreate an instance's disks."""
1421
  _TDiskChanges = \
1422
    ht.TAnd(ht.TIsLength(2),
1423
            ht.TItems([ht.Comment("Disk index")(ht.TPositiveInt),
1424
                       ht.Comment("Parameters")(_TDiskParams)]))
1425

    
1426
  OP_DSC_FIELD = "instance_name"
1427
  OP_PARAMS = [
1428
    _PInstanceName,
1429
    ("disks", ht.EmptyList,
1430
     ht.TOr(ht.TListOf(ht.TPositiveInt), ht.TListOf(_TDiskChanges)),
1431
     "List of disk indexes (deprecated) or a list of tuples containing a disk"
1432
     " index and a possibly empty dictionary with disk parameter changes"),
1433
    ("nodes", ht.EmptyList, ht.TListOf(ht.TNonEmptyString),
1434
     "New instance nodes, if relocation is desired"),
1435
    ]
1436
  OP_RESULT = ht.TNone
1437

    
1438

    
1439
class OpInstanceQuery(OpCode):
1440
  """Compute the list of instances."""
1441
  OP_PARAMS = [
1442
    _POutputFields,
1443
    _PUseLocking,
1444
    ("names", ht.EmptyList, ht.TListOf(ht.TNonEmptyString),
1445
     "Empty list to query all instances, instance names otherwise"),
1446
    ]
1447
  OP_RESULT = _TOldQueryResult
1448

    
1449

    
1450
class OpInstanceQueryData(OpCode):
1451
  """Compute the run-time status of instances."""
1452
  OP_PARAMS = [
1453
    _PUseLocking,
1454
    ("instances", ht.EmptyList, ht.TListOf(ht.TNonEmptyString),
1455
     "Instance names"),
1456
    ("static", False, ht.TBool,
1457
     "Whether to only return configuration data without querying"
1458
     " nodes"),
1459
    ]
1460
  OP_RESULT = ht.TDictOf(ht.TNonEmptyString, ht.TDict)
1461

    
1462

    
1463
def _TestInstSetParamsModList(fn):
1464
  """Generates a check for modification lists.
1465

1466
  """
1467
  # Old format
1468
  # TODO: Remove in version 2.8 including support in LUInstanceSetParams
1469
  old_mod_item_fn = \
1470
    ht.TAnd(ht.TIsLength(2), ht.TItems([
1471
      ht.TOr(ht.TElemOf(constants.DDMS_VALUES), ht.TPositiveInt),
1472
      fn,
1473
      ]))
1474

    
1475
  # New format, supporting adding/removing disks/NICs at arbitrary indices
1476
  mod_item_fn = \
1477
    ht.TAnd(ht.TIsLength(3), ht.TItems([
1478
      ht.TElemOf(constants.DDMS_VALUES_WITH_MODIFY),
1479
      ht.Comment("Disk index, can be negative, e.g. -1 for last disk")(ht.TInt),
1480
      fn,
1481
      ]))
1482

    
1483
  return ht.TOr(ht.Comment("Recommended")(ht.TListOf(mod_item_fn)),
1484
                ht.Comment("Deprecated")(ht.TListOf(old_mod_item_fn)))
1485

    
1486

    
1487
class OpInstanceSetParams(OpCode):
1488
  """Change the parameters of an instance.
1489

1490
  """
1491
  TestNicModifications = _TestInstSetParamsModList(_TestNicDef)
1492
  TestDiskModifications = _TestInstSetParamsModList(_TDiskParams)
1493

    
1494
  OP_DSC_FIELD = "instance_name"
1495
  OP_PARAMS = [
1496
    _PInstanceName,
1497
    _PForce,
1498
    _PForceVariant,
1499
    _PIgnoreIpolicy,
1500
    ("nics", ht.EmptyList, TestNicModifications,
1501
     "List of NIC changes. Each item is of the form ``(op, index, settings)``."
1502
     " ``op`` is one of ``%s``, ``%s`` or ``%s``. ``index`` can be either -1 to"
1503
     " refer to the last position, or a zero-based index number. A deprecated"
1504
     " version of this parameter used the form ``(op, settings)``, where "
1505
     " ``op`` can be ``%s`` to add a new NIC with the specified settings,"
1506
     " ``%s`` to remove the last NIC or a number to modify the settings"
1507
     " of the NIC with that index." %
1508
     (constants.DDM_ADD, constants.DDM_MODIFY, constants.DDM_REMOVE,
1509
      constants.DDM_ADD, constants.DDM_REMOVE)),
1510
    ("disks", ht.EmptyList, TestDiskModifications,
1511
     "List of disk changes. See ``nics``."),
1512
    ("beparams", ht.EmptyDict, ht.TDict, "Per-instance backend parameters"),
1513
    ("runtime_mem", None, ht.TMaybeStrictPositiveInt, "New runtime memory"),
1514
    ("hvparams", ht.EmptyDict, ht.TDict,
1515
     "Per-instance hypervisor parameters, hypervisor-dependent"),
1516
    ("disk_template", None, ht.TOr(ht.TNone, _BuildDiskTemplateCheck(False)),
1517
     "Disk template for instance"),
1518
    ("remote_node", None, ht.TMaybeString,
1519
     "Secondary node (used when changing disk template)"),
1520
    ("os_name", None, ht.TMaybeString,
1521
     "Change instance's OS name. Does not reinstall the instance."),
1522
    ("osparams", None, ht.TMaybeDict, "Per-instance OS parameters"),
1523
    ("wait_for_sync", True, ht.TBool,
1524
     "Whether to wait for the disk to synchronize, when changing template"),
1525
    ("offline", None, ht.TMaybeBool, "Whether to mark instance as offline"),
1526
    ]
1527
  OP_RESULT = _TSetParamsResult
1528

    
1529

    
1530
class OpInstanceGrowDisk(OpCode):
1531
  """Grow a disk of an instance."""
1532
  OP_DSC_FIELD = "instance_name"
1533
  OP_PARAMS = [
1534
    _PInstanceName,
1535
    _PWaitForSync,
1536
    ("disk", ht.NoDefault, ht.TInt, "Disk index"),
1537
    ("amount", ht.NoDefault, ht.TInt,
1538
     "Amount of disk space to add (megabytes)"),
1539
    ]
1540
  OP_RESULT = ht.TNone
1541

    
1542

    
1543
class OpInstanceChangeGroup(OpCode):
1544
  """Moves an instance to another node group."""
1545
  OP_DSC_FIELD = "instance_name"
1546
  OP_PARAMS = [
1547
    _PInstanceName,
1548
    _PEarlyRelease,
1549
    ("iallocator", None, ht.TMaybeString, "Iallocator for computing solution"),
1550
    ("target_groups", None, ht.TMaybeListOf(ht.TNonEmptyString),
1551
     "Destination group names or UUIDs (defaults to \"all but current group\""),
1552
    ]
1553
  OP_RESULT = TJobIdListOnly
1554

    
1555

    
1556
# Node group opcodes
1557

    
1558
class OpGroupAdd(OpCode):
1559
  """Add a node group to the cluster."""
1560
  OP_DSC_FIELD = "group_name"
1561
  OP_PARAMS = [
1562
    _PGroupName,
1563
    _PNodeGroupAllocPolicy,
1564
    _PGroupNodeParams,
1565
    _PDiskParams,
1566
    _PHvState,
1567
    _PDiskState,
1568
    ("ipolicy", None, ht.TMaybeDict,
1569
     "Group-wide :ref:`instance policy <rapi-ipolicy>` specs"),
1570
    ]
1571
  OP_RESULT = ht.TNone
1572

    
1573

    
1574
class OpGroupAssignNodes(OpCode):
1575
  """Assign nodes to a node group."""
1576
  OP_DSC_FIELD = "group_name"
1577
  OP_PARAMS = [
1578
    _PGroupName,
1579
    _PForce,
1580
    ("nodes", ht.NoDefault, ht.TListOf(ht.TNonEmptyString),
1581
     "List of nodes to assign"),
1582
    ]
1583
  OP_RESULT = ht.TNone
1584

    
1585

    
1586
class OpGroupQuery(OpCode):
1587
  """Compute the list of node groups."""
1588
  OP_PARAMS = [
1589
    _POutputFields,
1590
    ("names", ht.EmptyList, ht.TListOf(ht.TNonEmptyString),
1591
     "Empty list to query all groups, group names otherwise"),
1592
    ]
1593
  OP_RESULT = _TOldQueryResult
1594

    
1595

    
1596
class OpGroupSetParams(OpCode):
1597
  """Change the parameters of a node group."""
1598
  OP_DSC_FIELD = "group_name"
1599
  OP_PARAMS = [
1600
    _PGroupName,
1601
    _PNodeGroupAllocPolicy,
1602
    _PGroupNodeParams,
1603
    _PDiskParams,
1604
    _PHvState,
1605
    _PDiskState,
1606
    ("ipolicy", None, ht.TMaybeDict, "Group-wide instance policy specs"),
1607
    ]
1608
  OP_RESULT = _TSetParamsResult
1609

    
1610

    
1611
class OpGroupRemove(OpCode):
1612
  """Remove a node group from the cluster."""
1613
  OP_DSC_FIELD = "group_name"
1614
  OP_PARAMS = [
1615
    _PGroupName,
1616
    ]
1617
  OP_RESULT = ht.TNone
1618

    
1619

    
1620
class OpGroupRename(OpCode):
1621
  """Rename a node group in the cluster."""
1622
  OP_PARAMS = [
1623
    _PGroupName,
1624
    ("new_name", ht.NoDefault, ht.TNonEmptyString, "New group name"),
1625
    ]
1626
  OP_RESULT = ht.Comment("New group name")(ht.TNonEmptyString)
1627

    
1628

    
1629
class OpGroupEvacuate(OpCode):
1630
  """Evacuate a node group in the cluster."""
1631
  OP_DSC_FIELD = "group_name"
1632
  OP_PARAMS = [
1633
    _PGroupName,
1634
    _PEarlyRelease,
1635
    ("iallocator", None, ht.TMaybeString, "Iallocator for computing solution"),
1636
    ("target_groups", None, ht.TMaybeListOf(ht.TNonEmptyString),
1637
     "Destination group names or UUIDs"),
1638
    ]
1639
  OP_RESULT = TJobIdListOnly
1640

    
1641

    
1642
# OS opcodes
1643
class OpOsDiagnose(OpCode):
1644
  """Compute the list of guest operating systems."""
1645
  OP_PARAMS = [
1646
    _POutputFields,
1647
    ("names", ht.EmptyList, ht.TListOf(ht.TNonEmptyString),
1648
     "Which operating systems to diagnose"),
1649
    ]
1650
  OP_RESULT = _TOldQueryResult
1651

    
1652

    
1653
# Exports opcodes
1654
class OpBackupQuery(OpCode):
1655
  """Compute the list of exported images."""
1656
  OP_PARAMS = [
1657
    _PUseLocking,
1658
    ("nodes", ht.EmptyList, ht.TListOf(ht.TNonEmptyString),
1659
     "Empty list to query all nodes, node names otherwise"),
1660
    ]
1661
  OP_RESULT = ht.TDictOf(ht.TNonEmptyString,
1662
                         ht.TOr(ht.Comment("False on error")(ht.TBool),
1663
                                ht.TListOf(ht.TNonEmptyString)))
1664

    
1665

    
1666
class OpBackupPrepare(OpCode):
1667
  """Prepares an instance export.
1668

1669
  @ivar instance_name: Instance name
1670
  @ivar mode: Export mode (one of L{constants.EXPORT_MODES})
1671

1672
  """
1673
  OP_DSC_FIELD = "instance_name"
1674
  OP_PARAMS = [
1675
    _PInstanceName,
1676
    ("mode", ht.NoDefault, ht.TElemOf(constants.EXPORT_MODES),
1677
     "Export mode"),
1678
    ]
1679
  OP_RESULT = ht.TOr(ht.TNone, ht.TDict)
1680

    
1681

    
1682
class OpBackupExport(OpCode):
1683
  """Export an instance.
1684

1685
  For local exports, the export destination is the node name. For remote
1686
  exports, the export destination is a list of tuples, each consisting of
1687
  hostname/IP address, port, HMAC and HMAC salt. The HMAC is calculated using
1688
  the cluster domain secret over the value "${index}:${hostname}:${port}". The
1689
  destination X509 CA must be a signed certificate.
1690

1691
  @ivar mode: Export mode (one of L{constants.EXPORT_MODES})
1692
  @ivar target_node: Export destination
1693
  @ivar x509_key_name: X509 key to use (remote export only)
1694
  @ivar destination_x509_ca: Destination X509 CA in PEM format (remote export
1695
                             only)
1696

1697
  """
1698
  OP_DSC_FIELD = "instance_name"
1699
  OP_PARAMS = [
1700
    _PInstanceName,
1701
    _PShutdownTimeout,
1702
    # TODO: Rename target_node as it changes meaning for different export modes
1703
    # (e.g. "destination")
1704
    ("target_node", ht.NoDefault, ht.TOr(ht.TNonEmptyString, ht.TList),
1705
     "Destination information, depends on export mode"),
1706
    ("shutdown", True, ht.TBool, "Whether to shutdown instance before export"),
1707
    ("remove_instance", False, ht.TBool,
1708
     "Whether to remove instance after export"),
1709
    ("ignore_remove_failures", False, ht.TBool,
1710
     "Whether to ignore failures while removing instances"),
1711
    ("mode", constants.EXPORT_MODE_LOCAL, ht.TElemOf(constants.EXPORT_MODES),
1712
     "Export mode"),
1713
    ("x509_key_name", None, ht.TOr(ht.TList, ht.TNone),
1714
     "Name of X509 key (remote export only)"),
1715
    ("destination_x509_ca", None, ht.TMaybeString,
1716
     "Destination X509 CA (remote export only)"),
1717
    ]
1718
  OP_RESULT = \
1719
    ht.TAnd(ht.TIsLength(2), ht.TItems([
1720
      ht.Comment("Finalizing status")(ht.TBool),
1721
      ht.Comment("Status for every exported disk")(ht.TListOf(ht.TBool)),
1722
      ]))
1723

    
1724

    
1725
class OpBackupRemove(OpCode):
1726
  """Remove an instance's export."""
1727
  OP_DSC_FIELD = "instance_name"
1728
  OP_PARAMS = [
1729
    _PInstanceName,
1730
    ]
1731
  OP_RESULT = ht.TNone
1732

    
1733

    
1734
# Tags opcodes
1735
class OpTagsGet(OpCode):
1736
  """Returns the tags of the given object."""
1737
  OP_DSC_FIELD = "name"
1738
  OP_PARAMS = [
1739
    _PTagKind,
1740
    # Not using _PUseLocking as the default is different for historical reasons
1741
    ("use_locking", True, ht.TBool, "Whether to use synchronization"),
1742
    # Name is only meaningful for nodes and instances
1743
    ("name", ht.NoDefault, ht.TMaybeString, None),
1744
    ]
1745
  OP_RESULT = ht.TListOf(ht.TNonEmptyString)
1746

    
1747

    
1748
class OpTagsSearch(OpCode):
1749
  """Searches the tags in the cluster for a given pattern."""
1750
  OP_DSC_FIELD = "pattern"
1751
  OP_PARAMS = [
1752
    ("pattern", ht.NoDefault, ht.TNonEmptyString, None),
1753
    ]
1754
  OP_RESULT = ht.TListOf(ht.TAnd(ht.TIsLength(2), ht.TItems([
1755
    ht.TNonEmptyString,
1756
    ht.TNonEmptyString,
1757
    ])))
1758

    
1759

    
1760
class OpTagsSet(OpCode):
1761
  """Add a list of tags on a given object."""
1762
  OP_PARAMS = [
1763
    _PTagKind,
1764
    _PTags,
1765
    # Name is only meaningful for nodes and instances
1766
    ("name", ht.NoDefault, ht.TMaybeString, None),
1767
    ]
1768
  OP_RESULT = ht.TNone
1769

    
1770

    
1771
class OpTagsDel(OpCode):
1772
  """Remove a list of tags from a given object."""
1773
  OP_PARAMS = [
1774
    _PTagKind,
1775
    _PTags,
1776
    # Name is only meaningful for nodes and instances
1777
    ("name", ht.NoDefault, ht.TMaybeString, None),
1778
    ]
1779
  OP_RESULT = ht.TNone
1780

    
1781

    
1782
# Test opcodes
1783
class OpTestDelay(OpCode):
1784
  """Sleeps for a configured amount of time.
1785

1786
  This is used just for debugging and testing.
1787

1788
  Parameters:
1789
    - duration: the time to sleep
1790
    - on_master: if true, sleep on the master
1791
    - on_nodes: list of nodes in which to sleep
1792

1793
  If the on_master parameter is true, it will execute a sleep on the
1794
  master (before any node sleep).
1795

1796
  If the on_nodes list is not empty, it will sleep on those nodes
1797
  (after the sleep on the master, if that is enabled).
1798

1799
  As an additional feature, the case of duration < 0 will be reported
1800
  as an execution error, so this opcode can be used as a failure
1801
  generator. The case of duration == 0 will not be treated specially.
1802

1803
  """
1804
  OP_DSC_FIELD = "duration"
1805
  OP_PARAMS = [
1806
    ("duration", ht.NoDefault, ht.TNumber, None),
1807
    ("on_master", True, ht.TBool, None),
1808
    ("on_nodes", ht.EmptyList, ht.TListOf(ht.TNonEmptyString), None),
1809
    ("repeat", 0, ht.TPositiveInt, None),
1810
    ]
1811

    
1812

    
1813
class OpTestAllocator(OpCode):
1814
  """Allocator framework testing.
1815

1816
  This opcode has two modes:
1817
    - gather and return allocator input for a given mode (allocate new
1818
      or replace secondary) and a given instance definition (direction
1819
      'in')
1820
    - run a selected allocator for a given operation (as above) and
1821
      return the allocator output (direction 'out')
1822

1823
  """
1824
  OP_DSC_FIELD = "allocator"
1825
  OP_PARAMS = [
1826
    ("direction", ht.NoDefault,
1827
     ht.TElemOf(constants.VALID_IALLOCATOR_DIRECTIONS), None),
1828
    ("mode", ht.NoDefault, ht.TElemOf(constants.VALID_IALLOCATOR_MODES), None),
1829
    ("name", ht.NoDefault, ht.TNonEmptyString, None),
1830
    ("nics", ht.NoDefault,
1831
     ht.TMaybeListOf(ht.TDictOf(ht.TElemOf([constants.INIC_MAC,
1832
                                            constants.INIC_IP,
1833
                                            "bridge"]),
1834
                                ht.TOr(ht.TNone, ht.TNonEmptyString))),
1835
     None),
1836
    ("disks", ht.NoDefault, ht.TOr(ht.TNone, ht.TList), None),
1837
    ("hypervisor", None, ht.TMaybeString, None),
1838
    ("allocator", None, ht.TMaybeString, None),
1839
    ("tags", ht.EmptyList, ht.TListOf(ht.TNonEmptyString), None),
1840
    ("memory", None, ht.TOr(ht.TNone, ht.TPositiveInt), None),
1841
    ("vcpus", None, ht.TOr(ht.TNone, ht.TPositiveInt), None),
1842
    ("os", None, ht.TMaybeString, None),
1843
    ("disk_template", None, ht.TMaybeString, None),
1844
    ("instances", None, ht.TMaybeListOf(ht.TNonEmptyString), None),
1845
    ("evac_mode", None,
1846
     ht.TOr(ht.TNone, ht.TElemOf(constants.IALLOCATOR_NEVAC_MODES)), None),
1847
    ("target_groups", None, ht.TMaybeListOf(ht.TNonEmptyString), None),
1848
    ]
1849

    
1850

    
1851
class OpTestJqueue(OpCode):
1852
  """Utility opcode to test some aspects of the job queue.
1853

1854
  """
1855
  OP_PARAMS = [
1856
    ("notify_waitlock", False, ht.TBool, None),
1857
    ("notify_exec", False, ht.TBool, None),
1858
    ("log_messages", ht.EmptyList, ht.TListOf(ht.TString), None),
1859
    ("fail", False, ht.TBool, None),
1860
    ]
1861

    
1862

    
1863
class OpTestDummy(OpCode):
1864
  """Utility opcode used by unittests.
1865

1866
  """
1867
  OP_PARAMS = [
1868
    ("result", ht.NoDefault, ht.NoType, None),
1869
    ("messages", ht.NoDefault, ht.NoType, None),
1870
    ("fail", ht.NoDefault, ht.NoType, None),
1871
    ("submit_jobs", None, ht.NoType, None),
1872
    ]
1873
  WITH_LU = False
1874

    
1875

    
1876
def _GetOpList():
1877
  """Returns list of all defined opcodes.
1878

1879
  Does not eliminate duplicates by C{OP_ID}.
1880

1881
  """
1882
  return [v for v in globals().values()
1883
          if (isinstance(v, type) and issubclass(v, OpCode) and
1884
              hasattr(v, "OP_ID") and v is not OpCode)]
1885

    
1886

    
1887
OP_MAPPING = dict((v.OP_ID, v) for v in _GetOpList())