Statistics
| Branch: | Tag: | Revision:

root / lib / opcodes.py @ 69c88fb1

History | View | Annotate | Download (66.5 kB)

1
#
2
#
3

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

    
40
from ganeti import constants
41
from ganeti import errors
42
from ganeti import ht
43
from ganeti import objects
44
from ganeti import outils
45

    
46

    
47
# Common opcode attributes
48

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

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

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

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

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

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

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

    
75
#: Migration type (live/non-live)
76
_PMigrationMode = ("mode", None,
77
                   ht.TMaybe(ht.TElemOf(constants.HT_MIGRATION_MODES)),
78
                   "Migration mode")
79

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

    
84
#: Tag type
85
_PTagKind = ("kind", ht.NoDefault, ht.TElemOf(constants.VALID_TAG_TYPES),
86
             "Tag kind")
87

    
88
#: List of tag strings
89
_PTags = ("tags", ht.NoDefault, ht.TListOf(ht.TNonEmptyString),
90
          "List of tag names")
91

    
92
_PForceVariant = ("force_variant", False, ht.TBool,
93
                  "Whether to force an unknown OS variant")
94

    
95
_PWaitForSync = ("wait_for_sync", True, ht.TBool,
96
                 "Whether to wait for the disk to synchronize")
97

    
98
_PWaitForSyncFalse = ("wait_for_sync", False, ht.TBool,
99
                      "Whether to wait for the disk to synchronize"
100
                      " (defaults to false)")
101

    
102
_PIgnoreConsistency = ("ignore_consistency", False, ht.TBool,
103
                       "Whether to ignore disk consistency")
104

    
105
_PStorageName = ("name", ht.NoDefault, ht.TMaybeString, "Storage name")
106

    
107
_PUseLocking = ("use_locking", False, ht.TBool,
108
                "Whether to use synchronization")
109

    
110
_PNameCheck = ("name_check", True, ht.TBool, "Whether to check name")
111

    
112
_PNodeGroupAllocPolicy = \
113
  ("alloc_policy", None,
114
   ht.TMaybe(ht.TElemOf(constants.VALID_ALLOC_POLICIES)),
115
   "Instance allocation policy")
116

    
117
_PGroupNodeParams = ("ndparams", None, ht.TMaybeDict,
118
                     "Default node parameters for group")
119

    
120
_PQueryWhat = ("what", ht.NoDefault, ht.TElemOf(constants.QR_VIA_OP),
121
               "Resource(s) to query for")
122

    
123
_PEarlyRelease = ("early_release", False, ht.TBool,
124
                  "Whether to release locks as soon as possible")
125

    
126
_PIpCheckDoc = "Whether to ensure instance's IP address is inactive"
127

    
128
#: Do not remember instance state changes
129
_PNoRemember = ("no_remember", False, ht.TBool,
130
                "Do not remember the state change")
131

    
132
#: Target node for instance migration/failover
133
_PMigrationTargetNode = ("target_node", None, ht.TMaybeString,
134
                         "Target node for shared-storage instances")
135

    
136
_PStartupPaused = ("startup_paused", False, ht.TBool,
137
                   "Pause instance at startup")
138

    
139
_PVerbose = ("verbose", False, ht.TBool, "Verbose mode")
140

    
141
# Parameters for cluster verification
142
_PDebugSimulateErrors = ("debug_simulate_errors", False, ht.TBool,
143
                         "Whether to simulate errors (useful for debugging)")
144
_PErrorCodes = ("error_codes", False, ht.TBool, "Error codes")
145
_PSkipChecks = ("skip_checks", ht.EmptyList,
146
                ht.TListOf(ht.TElemOf(constants.VERIFY_OPTIONAL_CHECKS)),
147
                "Which checks to skip")
148
_PIgnoreErrors = ("ignore_errors", ht.EmptyList,
149
                  ht.TListOf(ht.TElemOf(constants.CV_ALL_ECODES_STRINGS)),
150
                  "List of error codes that should be treated as warnings")
151

    
152
# Disk parameters
153
_PDiskParams = \
154
  ("diskparams", None,
155
   ht.TMaybe(ht.TDictOf(ht.TElemOf(constants.DISK_TEMPLATES), ht.TDict)),
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
#: Opportunistic locking
163
_POpportunisticLocking = \
164
  ("opportunistic_locking", False, ht.TBool,
165
   ("Whether to employ opportunistic locking for nodes, meaning nodes"
166
    " already locked by another opcode won't be considered for instance"
167
    " allocation (only when an iallocator is used)"))
168

    
169
_PIgnoreIpolicy = ("ignore_ipolicy", False, ht.TBool,
170
                   "Whether to ignore ipolicy violations")
171

    
172
# Allow runtime changes while migrating
173
_PAllowRuntimeChgs = ("allow_runtime_changes", True, ht.TBool,
174
                      "Allow runtime changes (eg. memory ballooning)")
175

    
176
#: IAllocator field builder
177
_PIAllocFromDesc = lambda desc: ("iallocator", None, ht.TMaybeString, desc)
178

    
179
#: a required network name
180
_PNetworkName = ("network_name", ht.NoDefault, ht.TNonEmptyString,
181
                 "Set network name")
182

    
183
_PTargetGroups = \
184
  ("target_groups", None, ht.TMaybeListOf(ht.TNonEmptyString),
185
   "Destination group names or UUIDs (defaults to \"all but current group\")")
186

    
187
# The reason for a state change of an instance
188
_PReason = \
189
  ("reason", (constants.INSTANCE_REASON_SOURCE_UNKNOWN, None),
190
   ht.TAnd(ht.TIsLength(2),
191
           ht.TItems([
192
             ht.TElemOf(constants.INSTANCE_REASON_SOURCES),
193
             ht.TMaybeString,
194
           ])),
195
   "The reason why the reboot is happening")
196

    
197
#: OP_ID conversion regular expression
198
_OPID_RE = re.compile("([a-z])([A-Z])")
199

    
200
#: Utility function for L{OpClusterSetParams}
201
_TestClusterOsListItem = \
202
  ht.TAnd(ht.TIsLength(2), ht.TItems([
203
    ht.TElemOf(constants.DDMS_VALUES),
204
    ht.TNonEmptyString,
205
    ]))
206

    
207
_TestClusterOsList = ht.TMaybeListOf(_TestClusterOsListItem)
208

    
209
# TODO: Generate check from constants.INIC_PARAMS_TYPES
210
#: Utility function for testing NIC definitions
211
_TestNicDef = \
212
  ht.Comment("NIC parameters")(ht.TDictOf(ht.TElemOf(constants.INIC_PARAMS),
213
                                          ht.TMaybeString))
214

    
215
_TSetParamsResultItemItems = [
216
  ht.Comment("name of changed parameter")(ht.TNonEmptyString),
217
  ht.Comment("new value")(ht.TAny),
218
  ]
219

    
220
_TSetParamsResult = \
221
  ht.TListOf(ht.TAnd(ht.TIsLength(len(_TSetParamsResultItemItems)),
222
                     ht.TItems(_TSetParamsResultItemItems)))
223

    
224
# In the disks option we can provide arbitrary parameters too, which
225
# we may not be able to validate at this level, so we just check the
226
# format of the dict here and the checks concerning IDISK_PARAMS will
227
# happen at the LU level
228
_TDiskParams = \
229
  ht.Comment("Disk parameters")(ht.TDictOf(ht.TNonEmptyString,
230
                                           ht.TOr(ht.TNonEmptyString, ht.TInt)))
231

    
232
_TQueryRow = \
233
  ht.TListOf(ht.TAnd(ht.TIsLength(2),
234
                     ht.TItems([ht.TElemOf(constants.RS_ALL),
235
                                ht.TAny])))
236

    
237
_TQueryResult = ht.TListOf(_TQueryRow)
238

    
239
_TOldQueryRow = ht.TListOf(ht.TAny)
240

    
241
_TOldQueryResult = ht.TListOf(_TOldQueryRow)
242

    
243

    
244
_SUMMARY_PREFIX = {
245
  "CLUSTER_": "C_",
246
  "GROUP_": "G_",
247
  "NODE_": "N_",
248
  "INSTANCE_": "I_",
249
  }
250

    
251
#: Attribute name for dependencies
252
DEPEND_ATTR = "depends"
253

    
254
#: Attribute name for comment
255
COMMENT_ATTR = "comment"
256

    
257

    
258
def _NameToId(name):
259
  """Convert an opcode class name to an OP_ID.
260

261
  @type name: string
262
  @param name: the class name, as OpXxxYyy
263
  @rtype: string
264
  @return: the name in the OP_XXXX_YYYY format
265

266
  """
267
  if not name.startswith("Op"):
268
    return None
269
  # Note: (?<=[a-z])(?=[A-Z]) would be ideal, since it wouldn't
270
  # consume any input, and hence we would just have all the elements
271
  # in the list, one by one; but it seems that split doesn't work on
272
  # non-consuming input, hence we have to process the input string a
273
  # bit
274
  name = _OPID_RE.sub(r"\1,\2", name)
275
  elems = name.split(",")
276
  return "_".join(n.upper() for n in elems)
277

    
278

    
279
def _GenerateObjectTypeCheck(obj, fields_types):
280
  """Helper to generate type checks for objects.
281

282
  @param obj: The object to generate type checks
283
  @param fields_types: The fields and their types as a dict
284
  @return: A ht type check function
285

286
  """
287
  assert set(obj.GetAllSlots()) == set(fields_types.keys()), \
288
    "%s != %s" % (set(obj.GetAllSlots()), set(fields_types.keys()))
289
  return ht.TStrictDict(True, True, fields_types)
290

    
291

    
292
_TQueryFieldDef = \
293
  _GenerateObjectTypeCheck(objects.QueryFieldDefinition, {
294
    "name": ht.TNonEmptyString,
295
    "title": ht.TNonEmptyString,
296
    "kind": ht.TElemOf(constants.QFT_ALL),
297
    "doc": ht.TNonEmptyString,
298
    })
299

    
300

    
301
def RequireFileStorage():
302
  """Checks that file storage is enabled.
303

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

307
  @raise errors.OpPrereqError: when file storage is disabled
308

309
  """
310
  if not constants.ENABLE_FILE_STORAGE:
311
    raise errors.OpPrereqError("File storage disabled at configure time",
312
                               errors.ECODE_INVAL)
313

    
314

    
315
def RequireSharedFileStorage():
316
  """Checks that shared file storage is enabled.
317

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

321
  @raise errors.OpPrereqError: when shared file storage is disabled
322

323
  """
324
  if not constants.ENABLE_SHARED_FILE_STORAGE:
325
    raise errors.OpPrereqError("Shared file storage disabled at"
326
                               " configure time", errors.ECODE_INVAL)
327

    
328

    
329
@ht.WithDesc("CheckFileStorage")
330
def _CheckFileStorage(value):
331
  """Ensures file storage is enabled if used.
332

333
  """
334
  if value == constants.DT_FILE:
335
    RequireFileStorage()
336
  elif value == constants.DT_SHARED_FILE:
337
    RequireSharedFileStorage()
338
  return True
339

    
340

    
341
def _BuildDiskTemplateCheck(accept_none):
342
  """Builds check for disk template.
343

344
  @type accept_none: bool
345
  @param accept_none: whether to accept None as a correct value
346
  @rtype: callable
347

348
  """
349
  template_check = ht.TElemOf(constants.DISK_TEMPLATES)
350

    
351
  if accept_none:
352
    template_check = ht.TMaybe(template_check)
353

    
354
  return ht.TAnd(template_check, _CheckFileStorage)
355

    
356

    
357
def _CheckStorageType(storage_type):
358
  """Ensure a given storage type is valid.
359

360
  """
361
  if storage_type not in constants.VALID_STORAGE_TYPES:
362
    raise errors.OpPrereqError("Unknown storage type: %s" % storage_type,
363
                               errors.ECODE_INVAL)
364
  if storage_type == constants.ST_FILE:
365
    # TODO: What about shared file storage?
366
    RequireFileStorage()
367
  return True
368

    
369

    
370
#: Storage type parameter
371
_PStorageType = ("storage_type", ht.NoDefault, _CheckStorageType,
372
                 "Storage type")
373

    
374

    
375
@ht.WithDesc("IPv4 network")
376
def _CheckCIDRNetNotation(value):
377
  """Ensure a given CIDR notation type is valid.
378

379
  """
380
  try:
381
    ipaddr.IPv4Network(value)
382
  except ipaddr.AddressValueError:
383
    return False
384
  return True
385

    
386

    
387
@ht.WithDesc("IPv4 address")
388
def _CheckCIDRAddrNotation(value):
389
  """Ensure a given CIDR notation type is valid.
390

391
  """
392
  try:
393
    ipaddr.IPv4Address(value)
394
  except ipaddr.AddressValueError:
395
    return False
396
  return True
397

    
398

    
399
@ht.WithDesc("IPv6 address")
400
def _CheckCIDR6AddrNotation(value):
401
  """Ensure a given CIDR notation type is valid.
402

403
  """
404
  try:
405
    ipaddr.IPv6Address(value)
406
  except ipaddr.AddressValueError:
407
    return False
408
  return True
409

    
410

    
411
@ht.WithDesc("IPv6 network")
412
def _CheckCIDR6NetNotation(value):
413
  """Ensure a given CIDR notation type is valid.
414

415
  """
416
  try:
417
    ipaddr.IPv6Network(value)
418
  except ipaddr.AddressValueError:
419
    return False
420
  return True
421

    
422

    
423
_TIpAddress4 = ht.TAnd(ht.TString, _CheckCIDRAddrNotation)
424
_TIpAddress6 = ht.TAnd(ht.TString, _CheckCIDR6AddrNotation)
425
_TIpNetwork4 = ht.TAnd(ht.TString, _CheckCIDRNetNotation)
426
_TIpNetwork6 = ht.TAnd(ht.TString, _CheckCIDR6NetNotation)
427
_TMaybeAddr4List = ht.TMaybe(ht.TListOf(_TIpAddress4))
428

    
429

    
430
class _AutoOpParamSlots(outils.AutoSlots):
431
  """Meta class for opcode definitions.
432

433
  """
434
  def __new__(mcs, name, bases, attrs):
435
    """Called when a class should be created.
436

437
    @param mcs: The meta class
438
    @param name: Name of created class
439
    @param bases: Base classes
440
    @type attrs: dict
441
    @param attrs: Class attributes
442

443
    """
444
    assert "OP_ID" not in attrs, "Class '%s' defining OP_ID" % name
445

    
446
    slots = mcs._GetSlots(attrs)
447
    assert "OP_DSC_FIELD" not in attrs or attrs["OP_DSC_FIELD"] in slots, \
448
      "Class '%s' uses unknown field in OP_DSC_FIELD" % name
449
    assert ("OP_DSC_FORMATTER" not in attrs or
450
            callable(attrs["OP_DSC_FORMATTER"])), \
451
      ("Class '%s' uses non-callable in OP_DSC_FORMATTER (%s)" %
452
       (name, type(attrs["OP_DSC_FORMATTER"])))
453

    
454
    attrs["OP_ID"] = _NameToId(name)
455

    
456
    return outils.AutoSlots.__new__(mcs, name, bases, attrs)
457

    
458
  @classmethod
459
  def _GetSlots(mcs, attrs):
460
    """Build the slots out of OP_PARAMS.
461

462
    """
463
    # Always set OP_PARAMS to avoid duplicates in BaseOpCode.GetAllParams
464
    params = attrs.setdefault("OP_PARAMS", [])
465

    
466
    # Use parameter names as slots
467
    return [pname for (pname, _, _, _) in params]
468

    
469

    
470
class BaseOpCode(outils.ValidatedSlots):
471
  """A simple serializable object.
472

473
  This object serves as a parent class for OpCode without any custom
474
  field handling.
475

476
  """
477
  # pylint: disable=E1101
478
  # as OP_ID is dynamically defined
479
  __metaclass__ = _AutoOpParamSlots
480

    
481
  def __getstate__(self):
482
    """Generic serializer.
483

484
    This method just returns the contents of the instance as a
485
    dictionary.
486

487
    @rtype:  C{dict}
488
    @return: the instance attributes and their values
489

490
    """
491
    state = {}
492
    for name in self.GetAllSlots():
493
      if hasattr(self, name):
494
        state[name] = getattr(self, name)
495
    return state
496

    
497
  def __setstate__(self, state):
498
    """Generic unserializer.
499

500
    This method just restores from the serialized state the attributes
501
    of the current instance.
502

503
    @param state: the serialized opcode data
504
    @type state:  C{dict}
505

506
    """
507
    if not isinstance(state, dict):
508
      raise ValueError("Invalid data to __setstate__: expected dict, got %s" %
509
                       type(state))
510

    
511
    for name in self.GetAllSlots():
512
      if name not in state and hasattr(self, name):
513
        delattr(self, name)
514

    
515
    for name in state:
516
      setattr(self, name, state[name])
517

    
518
  @classmethod
519
  def GetAllParams(cls):
520
    """Compute list of all parameters for an opcode.
521

522
    """
523
    slots = []
524
    for parent in cls.__mro__:
525
      slots.extend(getattr(parent, "OP_PARAMS", []))
526
    return slots
527

    
528
  def Validate(self, set_defaults): # pylint: disable=W0221
529
    """Validate opcode parameters, optionally setting default values.
530

531
    @type set_defaults: bool
532
    @param set_defaults: Whether to set default values
533
    @raise errors.OpPrereqError: When a parameter value doesn't match
534
                                 requirements
535

536
    """
537
    for (attr_name, default, test, _) in self.GetAllParams():
538
      assert test == ht.NoType or callable(test)
539

    
540
      if not hasattr(self, attr_name):
541
        if default == ht.NoDefault:
542
          raise errors.OpPrereqError("Required parameter '%s.%s' missing" %
543
                                     (self.OP_ID, attr_name),
544
                                     errors.ECODE_INVAL)
545
        elif set_defaults:
546
          if callable(default):
547
            dval = default()
548
          else:
549
            dval = default
550
          setattr(self, attr_name, dval)
551

    
552
      if test == ht.NoType:
553
        # no tests here
554
        continue
555

    
556
      if set_defaults or hasattr(self, attr_name):
557
        attr_val = getattr(self, attr_name)
558
        if not test(attr_val):
559
          logging.error("OpCode %s, parameter %s, has invalid type %s/value"
560
                        " '%s' expecting type %s",
561
                        self.OP_ID, attr_name, type(attr_val), attr_val, test)
562
          raise errors.OpPrereqError("Parameter '%s.%s' fails validation" %
563
                                     (self.OP_ID, attr_name),
564
                                     errors.ECODE_INVAL)
565

    
566

    
567
def _BuildJobDepCheck(relative):
568
  """Builds check for job dependencies (L{DEPEND_ATTR}).
569

570
  @type relative: bool
571
  @param relative: Whether to accept relative job IDs (negative)
572
  @rtype: callable
573

574
  """
575
  if relative:
576
    job_id = ht.TOr(ht.TJobId, ht.TRelativeJobId)
577
  else:
578
    job_id = ht.TJobId
579

    
580
  job_dep = \
581
    ht.TAnd(ht.TOr(ht.TList, ht.TTuple),
582
            ht.TIsLength(2),
583
            ht.TItems([job_id,
584
                       ht.TListOf(ht.TElemOf(constants.JOBS_FINALIZED))]))
585

    
586
  return ht.TMaybeListOf(job_dep)
587

    
588

    
589
TNoRelativeJobDependencies = _BuildJobDepCheck(False)
590

    
591
#: List of submission status and job ID as returned by C{SubmitManyJobs}
592
_TJobIdListItem = \
593
  ht.TAnd(ht.TIsLength(2),
594
          ht.TItems([ht.Comment("success")(ht.TBool),
595
                     ht.Comment("Job ID if successful, error message"
596
                                " otherwise")(ht.TOr(ht.TString,
597
                                                     ht.TJobId))]))
598
TJobIdList = ht.TListOf(_TJobIdListItem)
599

    
600
#: Result containing only list of submitted jobs
601
TJobIdListOnly = ht.TStrictDict(True, True, {
602
  constants.JOB_IDS_KEY: ht.Comment("List of submitted jobs")(TJobIdList),
603
  })
604

    
605

    
606
class OpCode(BaseOpCode):
607
  """Abstract OpCode.
608

609
  This is the root of the actual OpCode hierarchy. All clases derived
610
  from this class should override OP_ID.
611

612
  @cvar OP_ID: The ID of this opcode. This should be unique amongst all
613
               children of this class.
614
  @cvar OP_DSC_FIELD: The name of a field whose value will be included in the
615
                      string returned by Summary(); see the docstring of that
616
                      method for details).
617
  @cvar OP_DSC_FORMATTER: A callable that should format the OP_DSC_FIELD; if
618
                          not present, then the field will be simply converted
619
                          to string
620
  @cvar OP_PARAMS: List of opcode attributes, the default values they should
621
                   get if not already defined, and types they must match.
622
  @cvar OP_RESULT: Callable to verify opcode result
623
  @cvar WITH_LU: Boolean that specifies whether this should be included in
624
      mcpu's dispatch table
625
  @ivar dry_run: Whether the LU should be run in dry-run mode, i.e. just
626
                 the check steps
627
  @ivar priority: Opcode priority for queue
628

629
  """
630
  # pylint: disable=E1101
631
  # as OP_ID is dynamically defined
632
  WITH_LU = True
633
  OP_PARAMS = [
634
    ("dry_run", None, ht.TMaybeBool, "Run checks only, don't execute"),
635
    ("debug_level", None, ht.TMaybe(ht.TNonNegativeInt), "Debug level"),
636
    ("priority", constants.OP_PRIO_DEFAULT,
637
     ht.TElemOf(constants.OP_PRIO_SUBMIT_VALID), "Opcode priority"),
638
    (DEPEND_ATTR, None, _BuildJobDepCheck(True),
639
     "Job dependencies; if used through ``SubmitManyJobs`` relative (negative)"
640
     " job IDs can be used; see :doc:`design document <design-chained-jobs>`"
641
     " for details"),
642
    (COMMENT_ATTR, None, ht.TMaybeString,
643
     "Comment describing the purpose of the opcode"),
644
    ]
645
  OP_RESULT = None
646

    
647
  def __getstate__(self):
648
    """Specialized getstate for opcodes.
649

650
    This method adds to the state dictionary the OP_ID of the class,
651
    so that on unload we can identify the correct class for
652
    instantiating the opcode.
653

654
    @rtype:   C{dict}
655
    @return:  the state as a dictionary
656

657
    """
658
    data = BaseOpCode.__getstate__(self)
659
    data["OP_ID"] = self.OP_ID
660
    return data
661

    
662
  @classmethod
663
  def LoadOpCode(cls, data):
664
    """Generic load opcode method.
665

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

670
    @type data:  C{dict}
671
    @param data: the serialized opcode
672

673
    """
674
    if not isinstance(data, dict):
675
      raise ValueError("Invalid data to LoadOpCode (%s)" % type(data))
676
    if "OP_ID" not in data:
677
      raise ValueError("Invalid data to LoadOpcode, missing OP_ID")
678
    op_id = data["OP_ID"]
679
    op_class = None
680
    if op_id in OP_MAPPING:
681
      op_class = OP_MAPPING[op_id]
682
    else:
683
      raise ValueError("Invalid data to LoadOpCode: OP_ID %s unsupported" %
684
                       op_id)
685
    op = op_class()
686
    new_data = data.copy()
687
    del new_data["OP_ID"]
688
    op.__setstate__(new_data)
689
    return op
690

    
691
  def Summary(self):
692
    """Generates a summary description of this opcode.
693

694
    The summary is the value of the OP_ID attribute (without the "OP_"
695
    prefix), plus the value of the OP_DSC_FIELD attribute, if one was
696
    defined; this field should allow to easily identify the operation
697
    (for an instance creation job, e.g., it would be the instance
698
    name).
699

700
    """
701
    assert self.OP_ID is not None and len(self.OP_ID) > 3
702
    # all OP_ID start with OP_, we remove that
703
    txt = self.OP_ID[3:]
704
    field_name = getattr(self, "OP_DSC_FIELD", None)
705
    if field_name:
706
      field_value = getattr(self, field_name, None)
707
      field_formatter = getattr(self, "OP_DSC_FORMATTER", None)
708
      if callable(field_formatter):
709
        field_value = field_formatter(field_value)
710
      elif isinstance(field_value, (list, tuple)):
711
        field_value = ",".join(str(i) for i in field_value)
712
      txt = "%s(%s)" % (txt, field_value)
713
    return txt
714

    
715
  def TinySummary(self):
716
    """Generates a compact summary description of the opcode.
717

718
    """
719
    assert self.OP_ID.startswith("OP_")
720

    
721
    text = self.OP_ID[3:]
722

    
723
    for (prefix, supplement) in _SUMMARY_PREFIX.items():
724
      if text.startswith(prefix):
725
        return supplement + text[len(prefix):]
726

    
727
    return text
728

    
729

    
730
# cluster opcodes
731

    
732
class OpClusterPostInit(OpCode):
733
  """Post cluster initialization.
734

735
  This opcode does not touch the cluster at all. Its purpose is to run hooks
736
  after the cluster has been initialized.
737

738
  """
739
  OP_RESULT = ht.TBool
740

    
741

    
742
class OpClusterDestroy(OpCode):
743
  """Destroy the cluster.
744

745
  This opcode has no other parameters. All the state is irreversibly
746
  lost after the execution of this opcode.
747

748
  """
749
  OP_RESULT = ht.TNonEmptyString
750

    
751

    
752
class OpClusterQuery(OpCode):
753
  """Query cluster information."""
754
  OP_RESULT = ht.TDictOf(ht.TNonEmptyString, ht.TAny)
755

    
756

    
757
class OpClusterVerify(OpCode):
758
  """Submits all jobs necessary to verify the cluster.
759

760
  """
761
  OP_PARAMS = [
762
    _PDebugSimulateErrors,
763
    _PErrorCodes,
764
    _PSkipChecks,
765
    _PIgnoreErrors,
766
    _PVerbose,
767
    ("group_name", None, ht.TMaybeString, "Group to verify"),
768
    ]
769
  OP_RESULT = TJobIdListOnly
770

    
771

    
772
class OpClusterVerifyConfig(OpCode):
773
  """Verify the cluster config.
774

775
  """
776
  OP_PARAMS = [
777
    _PDebugSimulateErrors,
778
    _PErrorCodes,
779
    _PIgnoreErrors,
780
    _PVerbose,
781
    ]
782
  OP_RESULT = ht.TBool
783

    
784

    
785
class OpClusterVerifyGroup(OpCode):
786
  """Run verify on a node group from the cluster.
787

788
  @type skip_checks: C{list}
789
  @ivar skip_checks: steps to be skipped from the verify process; this
790
                     needs to be a subset of
791
                     L{constants.VERIFY_OPTIONAL_CHECKS}; currently
792
                     only L{constants.VERIFY_NPLUSONE_MEM} can be passed
793

794
  """
795
  OP_DSC_FIELD = "group_name"
796
  OP_PARAMS = [
797
    _PGroupName,
798
    _PDebugSimulateErrors,
799
    _PErrorCodes,
800
    _PSkipChecks,
801
    _PIgnoreErrors,
802
    _PVerbose,
803
    ]
804
  OP_RESULT = ht.TBool
805

    
806

    
807
class OpClusterVerifyDisks(OpCode):
808
  """Verify the cluster disks.
809

810
  """
811
  OP_RESULT = TJobIdListOnly
812

    
813

    
814
class OpGroupVerifyDisks(OpCode):
815
  """Verifies the status of all disks in a node group.
816

817
  Result: a tuple of three elements:
818
    - dict of node names with issues (values: error msg)
819
    - list of instances with degraded disks (that should be activated)
820
    - dict of instances with missing logical volumes (values: (node, vol)
821
      pairs with details about the missing volumes)
822

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

828
  Note that only instances that are drbd-based are taken into
829
  consideration. This might need to be revisited in the future.
830

831
  """
832
  OP_DSC_FIELD = "group_name"
833
  OP_PARAMS = [
834
    _PGroupName,
835
    ]
836
  OP_RESULT = \
837
    ht.TAnd(ht.TIsLength(3),
838
            ht.TItems([ht.TDictOf(ht.TString, ht.TString),
839
                       ht.TListOf(ht.TString),
840
                       ht.TDictOf(ht.TString,
841
                                  ht.TListOf(ht.TListOf(ht.TString)))]))
842

    
843

    
844
class OpClusterRepairDiskSizes(OpCode):
845
  """Verify the disk sizes of the instances and fixes configuration
846
  mimatches.
847

848
  Parameters: optional instances list, in case we want to restrict the
849
  checks to only a subset of the instances.
850

851
  Result: a list of tuples, (instance, disk, new-size) for changed
852
  configurations.
853

854
  In normal operation, the list should be empty.
855

856
  @type instances: list
857
  @ivar instances: the list of instances to check, or empty for all instances
858

859
  """
860
  OP_PARAMS = [
861
    ("instances", ht.EmptyList, ht.TListOf(ht.TNonEmptyString), None),
862
    ]
863
  OP_RESULT = ht.TListOf(ht.TAnd(ht.TIsLength(3),
864
                                 ht.TItems([ht.TNonEmptyString,
865
                                            ht.TNonNegativeInt,
866
                                            ht.TNonNegativeInt])))
867

    
868

    
869
class OpClusterConfigQuery(OpCode):
870
  """Query cluster configuration values."""
871
  OP_PARAMS = [
872
    _POutputFields,
873
    ]
874
  OP_RESULT = ht.TListOf(ht.TAny)
875

    
876

    
877
class OpClusterRename(OpCode):
878
  """Rename the cluster.
879

880
  @type name: C{str}
881
  @ivar name: The new name of the cluster. The name and/or the master IP
882
              address will be changed to match the new name and its IP
883
              address.
884

885
  """
886
  OP_DSC_FIELD = "name"
887
  OP_PARAMS = [
888
    ("name", ht.NoDefault, ht.TNonEmptyString, None),
889
    ]
890
  OP_RESULT = ht.TNonEmptyString
891

    
892

    
893
class OpClusterSetParams(OpCode):
894
  """Change the parameters of the cluster.
895

896
  @type vg_name: C{str} or C{None}
897
  @ivar vg_name: The new volume group name or None to disable LVM usage.
898

899
  """
900
  OP_PARAMS = [
901
    _PHvState,
902
    _PDiskState,
903
    ("vg_name", None, ht.TMaybe(ht.TString), "Volume group name"),
904
    ("enabled_hypervisors", None,
905
     ht.TMaybe(ht.TAnd(ht.TListOf(ht.TElemOf(constants.HYPER_TYPES)),
906
                       ht.TTrue)),
907
     "List of enabled hypervisors"),
908
    ("hvparams", None,
909
     ht.TMaybe(ht.TDictOf(ht.TNonEmptyString, ht.TDict)),
910
     "Cluster-wide hypervisor parameter defaults, hypervisor-dependent"),
911
    ("beparams", None, ht.TMaybeDict,
912
     "Cluster-wide backend parameter defaults"),
913
    ("os_hvp", None, ht.TMaybe(ht.TDictOf(ht.TNonEmptyString, ht.TDict)),
914
     "Cluster-wide per-OS hypervisor parameter defaults"),
915
    ("osparams", None,
916
     ht.TMaybe(ht.TDictOf(ht.TNonEmptyString, ht.TDict)),
917
     "Cluster-wide OS parameter defaults"),
918
    _PDiskParams,
919
    ("candidate_pool_size", None, ht.TMaybe(ht.TPositiveInt),
920
     "Master candidate pool size"),
921
    ("uid_pool", None, ht.NoType,
922
     "Set UID pool, must be list of lists describing UID ranges (two items,"
923
     " start and end inclusive)"),
924
    ("add_uids", None, ht.NoType,
925
     "Extend UID pool, must be list of lists describing UID ranges (two"
926
     " items, start and end inclusive) to be added"),
927
    ("remove_uids", None, ht.NoType,
928
     "Shrink UID pool, must be list of lists describing UID ranges (two"
929
     " items, start and end inclusive) to be removed"),
930
    ("maintain_node_health", None, ht.TMaybeBool,
931
     "Whether to automatically maintain node health"),
932
    ("prealloc_wipe_disks", None, ht.TMaybeBool,
933
     "Whether to wipe disks before allocating them to instances"),
934
    ("nicparams", None, ht.TMaybeDict, "Cluster-wide NIC parameter defaults"),
935
    ("ndparams", None, ht.TMaybeDict, "Cluster-wide node parameter defaults"),
936
    ("ipolicy", None, ht.TMaybeDict,
937
     "Cluster-wide :ref:`instance policy <rapi-ipolicy>` specs"),
938
    ("drbd_helper", None, ht.TMaybe(ht.TString), "DRBD helper program"),
939
    ("default_iallocator", None, ht.TMaybe(ht.TString),
940
     "Default iallocator for cluster"),
941
    ("master_netdev", None, ht.TMaybe(ht.TString),
942
     "Master network device"),
943
    ("master_netmask", None, ht.TMaybe(ht.TNonNegativeInt),
944
     "Netmask of the master IP"),
945
    ("reserved_lvs", None, ht.TMaybeListOf(ht.TNonEmptyString),
946
     "List of reserved LVs"),
947
    ("hidden_os", None, _TestClusterOsList,
948
     "Modify list of hidden operating systems: each modification must have"
949
     " two items, the operation and the OS name; the operation can be"
950
     " ``%s`` or ``%s``" % (constants.DDM_ADD, constants.DDM_REMOVE)),
951
    ("blacklisted_os", None, _TestClusterOsList,
952
     "Modify list of blacklisted operating systems: each modification must"
953
     " have two items, the operation and the OS name; the operation can be"
954
     " ``%s`` or ``%s``" % (constants.DDM_ADD, constants.DDM_REMOVE)),
955
    ("use_external_mip_script", None, ht.TMaybeBool,
956
     "Whether to use an external master IP address setup script"),
957
    ]
958
  OP_RESULT = ht.TNone
959

    
960

    
961
class OpClusterRedistConf(OpCode):
962
  """Force a full push of the cluster configuration.
963

964
  """
965
  OP_RESULT = ht.TNone
966

    
967

    
968
class OpClusterActivateMasterIp(OpCode):
969
  """Activate the master IP on the master node.
970

971
  """
972
  OP_RESULT = ht.TNone
973

    
974

    
975
class OpClusterDeactivateMasterIp(OpCode):
976
  """Deactivate the master IP on the master node.
977

978
  """
979
  OP_RESULT = ht.TNone
980

    
981

    
982
class OpQuery(OpCode):
983
  """Query for resources/items.
984

985
  @ivar what: Resources to query for, must be one of L{constants.QR_VIA_OP}
986
  @ivar fields: List of fields to retrieve
987
  @ivar qfilter: Query filter
988

989
  """
990
  OP_DSC_FIELD = "what"
991
  OP_PARAMS = [
992
    _PQueryWhat,
993
    _PUseLocking,
994
    ("fields", ht.NoDefault, ht.TListOf(ht.TNonEmptyString),
995
     "Requested fields"),
996
    ("qfilter", None, ht.TMaybe(ht.TList),
997
     "Query filter"),
998
    ]
999
  OP_RESULT = \
1000
    _GenerateObjectTypeCheck(objects.QueryResponse, {
1001
      "fields": ht.TListOf(_TQueryFieldDef),
1002
      "data": _TQueryResult,
1003
      })
1004

    
1005

    
1006
class OpQueryFields(OpCode):
1007
  """Query for available resource/item fields.
1008

1009
  @ivar what: Resources to query for, must be one of L{constants.QR_VIA_OP}
1010
  @ivar fields: List of fields to retrieve
1011

1012
  """
1013
  OP_DSC_FIELD = "what"
1014
  OP_PARAMS = [
1015
    _PQueryWhat,
1016
    ("fields", None, ht.TMaybeListOf(ht.TNonEmptyString),
1017
     "Requested fields; if not given, all are returned"),
1018
    ]
1019
  OP_RESULT = \
1020
    _GenerateObjectTypeCheck(objects.QueryFieldsResponse, {
1021
      "fields": ht.TListOf(_TQueryFieldDef),
1022
      })
1023

    
1024

    
1025
class OpOobCommand(OpCode):
1026
  """Interact with OOB."""
1027
  OP_PARAMS = [
1028
    ("node_names", ht.EmptyList, ht.TListOf(ht.TNonEmptyString),
1029
     "List of nodes to run the OOB command against"),
1030
    ("command", ht.NoDefault, ht.TElemOf(constants.OOB_COMMANDS),
1031
     "OOB command to be run"),
1032
    ("timeout", constants.OOB_TIMEOUT, ht.TInt,
1033
     "Timeout before the OOB helper will be terminated"),
1034
    ("ignore_status", False, ht.TBool,
1035
     "Ignores the node offline status for power off"),
1036
    ("power_delay", constants.OOB_POWER_DELAY, ht.TNonNegativeFloat,
1037
     "Time in seconds to wait between powering on nodes"),
1038
    ]
1039
  # Fixme: Make it more specific with all the special cases in LUOobCommand
1040
  OP_RESULT = _TQueryResult
1041

    
1042

    
1043
class OpRestrictedCommand(OpCode):
1044
  """Runs a restricted command on node(s).
1045

1046
  """
1047
  OP_PARAMS = [
1048
    _PUseLocking,
1049
    ("nodes", ht.NoDefault, ht.TListOf(ht.TNonEmptyString),
1050
     "Nodes on which the command should be run (at least one)"),
1051
    ("command", ht.NoDefault, ht.TNonEmptyString,
1052
     "Command name (no parameters)"),
1053
    ]
1054

    
1055
  _RESULT_ITEMS = [
1056
    ht.Comment("success")(ht.TBool),
1057
    ht.Comment("output or error message")(ht.TString),
1058
    ]
1059

    
1060
  OP_RESULT = \
1061
    ht.TListOf(ht.TAnd(ht.TIsLength(len(_RESULT_ITEMS)),
1062
                       ht.TItems(_RESULT_ITEMS)))
1063

    
1064

    
1065
# node opcodes
1066

    
1067
class OpNodeRemove(OpCode):
1068
  """Remove a node.
1069

1070
  @type node_name: C{str}
1071
  @ivar node_name: The name of the node to remove. If the node still has
1072
                   instances on it, the operation will fail.
1073

1074
  """
1075
  OP_DSC_FIELD = "node_name"
1076
  OP_PARAMS = [
1077
    _PNodeName,
1078
    ]
1079
  OP_RESULT = ht.TNone
1080

    
1081

    
1082
class OpNodeAdd(OpCode):
1083
  """Add a node to the cluster.
1084

1085
  @type node_name: C{str}
1086
  @ivar node_name: The name of the node to add. This can be a short name,
1087
                   but it will be expanded to the FQDN.
1088
  @type primary_ip: IP address
1089
  @ivar primary_ip: The primary IP of the node. This will be ignored when the
1090
                    opcode is submitted, but will be filled during the node
1091
                    add (so it will be visible in the job query).
1092
  @type secondary_ip: IP address
1093
  @ivar secondary_ip: The secondary IP of the node. This needs to be passed
1094
                      if the cluster has been initialized in 'dual-network'
1095
                      mode, otherwise it must not be given.
1096
  @type readd: C{bool}
1097
  @ivar readd: Whether to re-add an existing node to the cluster. If
1098
               this is not passed, then the operation will abort if the node
1099
               name is already in the cluster; use this parameter to 'repair'
1100
               a node that had its configuration broken, or was reinstalled
1101
               without removal from the cluster.
1102
  @type group: C{str}
1103
  @ivar group: The node group to which this node will belong.
1104
  @type vm_capable: C{bool}
1105
  @ivar vm_capable: The vm_capable node attribute
1106
  @type master_capable: C{bool}
1107
  @ivar master_capable: The master_capable node attribute
1108

1109
  """
1110
  OP_DSC_FIELD = "node_name"
1111
  OP_PARAMS = [
1112
    _PNodeName,
1113
    _PHvState,
1114
    _PDiskState,
1115
    ("primary_ip", None, ht.NoType, "Primary IP address"),
1116
    ("secondary_ip", None, ht.TMaybeString, "Secondary IP address"),
1117
    ("readd", False, ht.TBool, "Whether node is re-added to cluster"),
1118
    ("group", None, ht.TMaybeString, "Initial node group"),
1119
    ("master_capable", None, ht.TMaybeBool,
1120
     "Whether node can become master or master candidate"),
1121
    ("vm_capable", None, ht.TMaybeBool,
1122
     "Whether node can host instances"),
1123
    ("ndparams", None, ht.TMaybeDict, "Node parameters"),
1124
    ]
1125
  OP_RESULT = ht.TNone
1126

    
1127

    
1128
class OpNodeQuery(OpCode):
1129
  """Compute the list of nodes."""
1130
  OP_PARAMS = [
1131
    _POutputFields,
1132
    _PUseLocking,
1133
    ("names", ht.EmptyList, ht.TListOf(ht.TNonEmptyString),
1134
     "Empty list to query all nodes, node names otherwise"),
1135
    ]
1136
  OP_RESULT = _TOldQueryResult
1137

    
1138

    
1139
class OpNodeQueryvols(OpCode):
1140
  """Get list of volumes on node."""
1141
  OP_PARAMS = [
1142
    _POutputFields,
1143
    ("nodes", ht.EmptyList, ht.TListOf(ht.TNonEmptyString),
1144
     "Empty list to query all nodes, node names otherwise"),
1145
    ]
1146
  OP_RESULT = ht.TListOf(ht.TAny)
1147

    
1148

    
1149
class OpNodeQueryStorage(OpCode):
1150
  """Get information on storage for node(s)."""
1151
  OP_PARAMS = [
1152
    _POutputFields,
1153
    _PStorageType,
1154
    ("nodes", ht.EmptyList, ht.TListOf(ht.TNonEmptyString), "List of nodes"),
1155
    ("name", None, ht.TMaybeString, "Storage name"),
1156
    ]
1157
  OP_RESULT = _TOldQueryResult
1158

    
1159

    
1160
class OpNodeModifyStorage(OpCode):
1161
  """Modifies the properies of a storage unit"""
1162
  OP_DSC_FIELD = "node_name"
1163
  OP_PARAMS = [
1164
    _PNodeName,
1165
    _PStorageType,
1166
    _PStorageName,
1167
    ("changes", ht.NoDefault, ht.TDict, "Requested changes"),
1168
    ]
1169
  OP_RESULT = ht.TNone
1170

    
1171

    
1172
class OpRepairNodeStorage(OpCode):
1173
  """Repairs the volume group on a node."""
1174
  OP_DSC_FIELD = "node_name"
1175
  OP_PARAMS = [
1176
    _PNodeName,
1177
    _PStorageType,
1178
    _PStorageName,
1179
    _PIgnoreConsistency,
1180
    ]
1181
  OP_RESULT = ht.TNone
1182

    
1183

    
1184
class OpNodeSetParams(OpCode):
1185
  """Change the parameters of a node."""
1186
  OP_DSC_FIELD = "node_name"
1187
  OP_PARAMS = [
1188
    _PNodeName,
1189
    _PForce,
1190
    _PHvState,
1191
    _PDiskState,
1192
    ("master_candidate", None, ht.TMaybeBool,
1193
     "Whether the node should become a master candidate"),
1194
    ("offline", None, ht.TMaybeBool,
1195
     "Whether the node should be marked as offline"),
1196
    ("drained", None, ht.TMaybeBool,
1197
     "Whether the node should be marked as drained"),
1198
    ("auto_promote", False, ht.TBool,
1199
     "Whether node(s) should be promoted to master candidate if necessary"),
1200
    ("master_capable", None, ht.TMaybeBool,
1201
     "Denote whether node can become master or master candidate"),
1202
    ("vm_capable", None, ht.TMaybeBool,
1203
     "Denote whether node can host instances"),
1204
    ("secondary_ip", None, ht.TMaybeString,
1205
     "Change node's secondary IP address"),
1206
    ("ndparams", None, ht.TMaybeDict, "Set node parameters"),
1207
    ("powered", None, ht.TMaybeBool,
1208
     "Whether the node should be marked as powered"),
1209
    ]
1210
  OP_RESULT = _TSetParamsResult
1211

    
1212

    
1213
class OpNodePowercycle(OpCode):
1214
  """Tries to powercycle a node."""
1215
  OP_DSC_FIELD = "node_name"
1216
  OP_PARAMS = [
1217
    _PNodeName,
1218
    _PForce,
1219
    ]
1220
  OP_RESULT = ht.TMaybeString
1221

    
1222

    
1223
class OpNodeMigrate(OpCode):
1224
  """Migrate all instances from a node."""
1225
  OP_DSC_FIELD = "node_name"
1226
  OP_PARAMS = [
1227
    _PNodeName,
1228
    _PMigrationMode,
1229
    _PMigrationLive,
1230
    _PMigrationTargetNode,
1231
    _PAllowRuntimeChgs,
1232
    _PIgnoreIpolicy,
1233
    _PIAllocFromDesc("Iallocator for deciding the target node"
1234
                     " for shared-storage instances"),
1235
    ]
1236
  OP_RESULT = TJobIdListOnly
1237

    
1238

    
1239
class OpNodeEvacuate(OpCode):
1240
  """Evacuate instances off a number of nodes."""
1241
  OP_DSC_FIELD = "node_name"
1242
  OP_PARAMS = [
1243
    _PEarlyRelease,
1244
    _PNodeName,
1245
    ("remote_node", None, ht.TMaybeString, "New secondary node"),
1246
    _PIAllocFromDesc("Iallocator for computing solution"),
1247
    ("mode", ht.NoDefault, ht.TElemOf(constants.NODE_EVAC_MODES),
1248
     "Node evacuation mode"),
1249
    ]
1250
  OP_RESULT = TJobIdListOnly
1251

    
1252

    
1253
# instance opcodes
1254

    
1255
class OpInstanceCreate(OpCode):
1256
  """Create an instance.
1257

1258
  @ivar instance_name: Instance name
1259
  @ivar mode: Instance creation mode (one of L{constants.INSTANCE_CREATE_MODES})
1260
  @ivar source_handshake: Signed handshake from source (remote import only)
1261
  @ivar source_x509_ca: Source X509 CA in PEM format (remote import only)
1262
  @ivar source_instance_name: Previous name of instance (remote import only)
1263
  @ivar source_shutdown_timeout: Shutdown timeout used for source instance
1264
    (remote import only)
1265

1266
  """
1267
  OP_DSC_FIELD = "instance_name"
1268
  OP_PARAMS = [
1269
    _PInstanceName,
1270
    _PForceVariant,
1271
    _PWaitForSync,
1272
    _PNameCheck,
1273
    _PIgnoreIpolicy,
1274
    _POpportunisticLocking,
1275
    ("beparams", ht.EmptyDict, ht.TDict, "Backend parameters for instance"),
1276
    ("disks", ht.NoDefault, ht.TListOf(_TDiskParams),
1277
     "Disk descriptions, for example ``[{\"%s\": 100}, {\"%s\": 5}]``;"
1278
     " each disk definition must contain a ``%s`` value and"
1279
     " can contain an optional ``%s`` value denoting the disk access mode"
1280
     " (%s)" %
1281
     (constants.IDISK_SIZE, constants.IDISK_SIZE, constants.IDISK_SIZE,
1282
      constants.IDISK_MODE,
1283
      " or ".join("``%s``" % i for i in sorted(constants.DISK_ACCESS_SET)))),
1284
    ("disk_template", ht.NoDefault, _BuildDiskTemplateCheck(True),
1285
     "Disk template"),
1286
    ("file_driver", None, ht.TMaybe(ht.TElemOf(constants.FILE_DRIVER)),
1287
     "Driver for file-backed disks"),
1288
    ("file_storage_dir", None, ht.TMaybeString,
1289
     "Directory for storing file-backed disks"),
1290
    ("hvparams", ht.EmptyDict, ht.TDict,
1291
     "Hypervisor parameters for instance, hypervisor-dependent"),
1292
    ("hypervisor", None, ht.TMaybeString, "Hypervisor"),
1293
    _PIAllocFromDesc("Iallocator for deciding which node(s) to use"),
1294
    ("identify_defaults", False, ht.TBool,
1295
     "Reset instance parameters to default if equal"),
1296
    ("ip_check", True, ht.TBool, _PIpCheckDoc),
1297
    ("conflicts_check", True, ht.TBool, "Check for conflicting IPs"),
1298
    ("mode", ht.NoDefault, ht.TElemOf(constants.INSTANCE_CREATE_MODES),
1299
     "Instance creation mode"),
1300
    ("nics", ht.NoDefault, ht.TListOf(_TestNicDef),
1301
     "List of NIC (network interface) definitions, for example"
1302
     " ``[{}, {}, {\"%s\": \"198.51.100.4\"}]``; each NIC definition can"
1303
     " contain the optional values %s" %
1304
     (constants.INIC_IP,
1305
      ", ".join("``%s``" % i for i in sorted(constants.INIC_PARAMS)))),
1306
    ("no_install", None, ht.TMaybeBool,
1307
     "Do not install the OS (will disable automatic start)"),
1308
    ("osparams", ht.EmptyDict, ht.TDict, "OS parameters for instance"),
1309
    ("os_type", None, ht.TMaybeString, "Operating system"),
1310
    ("pnode", None, ht.TMaybeString, "Primary node"),
1311
    ("snode", None, ht.TMaybeString, "Secondary node"),
1312
    ("source_handshake", None, ht.TMaybe(ht.TList),
1313
     "Signed handshake from source (remote import only)"),
1314
    ("source_instance_name", None, ht.TMaybeString,
1315
     "Source instance name (remote import only)"),
1316
    ("source_shutdown_timeout", constants.DEFAULT_SHUTDOWN_TIMEOUT,
1317
     ht.TNonNegativeInt,
1318
     "How long source instance was given to shut down (remote import only)"),
1319
    ("source_x509_ca", None, ht.TMaybeString,
1320
     "Source X509 CA in PEM format (remote import only)"),
1321
    ("src_node", None, ht.TMaybeString, "Source node for import"),
1322
    ("src_path", None, ht.TMaybeString, "Source directory for import"),
1323
    ("start", True, ht.TBool, "Whether to start instance after creation"),
1324
    ("tags", ht.EmptyList, ht.TListOf(ht.TNonEmptyString), "Instance tags"),
1325
    ]
1326
  OP_RESULT = ht.Comment("instance nodes")(ht.TListOf(ht.TNonEmptyString))
1327

    
1328

    
1329
class OpInstanceMultiAlloc(OpCode):
1330
  """Allocates multiple instances.
1331

1332
  """
1333
  OP_PARAMS = [
1334
    _POpportunisticLocking,
1335
    _PIAllocFromDesc("Iallocator used to allocate all the instances"),
1336
    ("instances", ht.EmptyList, ht.TListOf(ht.TInstanceOf(OpInstanceCreate)),
1337
     "List of instance create opcodes describing the instances to allocate"),
1338
    ]
1339
  _JOB_LIST = ht.Comment("List of submitted jobs")(TJobIdList)
1340
  ALLOCATABLE_KEY = "allocatable"
1341
  FAILED_KEY = "allocatable"
1342
  OP_RESULT = ht.TStrictDict(True, True, {
1343
    constants.JOB_IDS_KEY: _JOB_LIST,
1344
    ALLOCATABLE_KEY: ht.TListOf(ht.TNonEmptyString),
1345
    FAILED_KEY: ht.TListOf(ht.TNonEmptyString),
1346
    })
1347

    
1348
  def __getstate__(self):
1349
    """Generic serializer.
1350

1351
    """
1352
    state = OpCode.__getstate__(self)
1353
    if hasattr(self, "instances"):
1354
      # pylint: disable=E1101
1355
      state["instances"] = [inst.__getstate__() for inst in self.instances]
1356
    return state
1357

    
1358
  def __setstate__(self, state):
1359
    """Generic unserializer.
1360

1361
    This method just restores from the serialized state the attributes
1362
    of the current instance.
1363

1364
    @param state: the serialized opcode data
1365
    @type state: C{dict}
1366

1367
    """
1368
    if not isinstance(state, dict):
1369
      raise ValueError("Invalid data to __setstate__: expected dict, got %s" %
1370
                       type(state))
1371

    
1372
    if "instances" in state:
1373
      state["instances"] = map(OpCode.LoadOpCode, state["instances"])
1374

    
1375
    return OpCode.__setstate__(self, state)
1376

    
1377
  def Validate(self, set_defaults):
1378
    """Validates this opcode.
1379

1380
    We do this recursively.
1381

1382
    """
1383
    OpCode.Validate(self, set_defaults)
1384

    
1385
    for inst in self.instances: # pylint: disable=E1101
1386
      inst.Validate(set_defaults)
1387

    
1388

    
1389
class OpInstanceReinstall(OpCode):
1390
  """Reinstall an instance's OS."""
1391
  OP_DSC_FIELD = "instance_name"
1392
  OP_PARAMS = [
1393
    _PInstanceName,
1394
    _PForceVariant,
1395
    ("os_type", None, ht.TMaybeString, "Instance operating system"),
1396
    ("osparams", None, ht.TMaybeDict, "Temporary OS parameters"),
1397
    ]
1398
  OP_RESULT = ht.TNone
1399

    
1400

    
1401
class OpInstanceRemove(OpCode):
1402
  """Remove an instance."""
1403
  OP_DSC_FIELD = "instance_name"
1404
  OP_PARAMS = [
1405
    _PInstanceName,
1406
    _PShutdownTimeout,
1407
    ("ignore_failures", False, ht.TBool,
1408
     "Whether to ignore failures during removal"),
1409
    ]
1410
  OP_RESULT = ht.TNone
1411

    
1412

    
1413
class OpInstanceRename(OpCode):
1414
  """Rename an instance."""
1415
  OP_PARAMS = [
1416
    _PInstanceName,
1417
    _PNameCheck,
1418
    ("new_name", ht.NoDefault, ht.TNonEmptyString, "New instance name"),
1419
    ("ip_check", False, ht.TBool, _PIpCheckDoc),
1420
    ]
1421
  OP_RESULT = ht.Comment("New instance name")(ht.TNonEmptyString)
1422

    
1423

    
1424
class OpInstanceStartup(OpCode):
1425
  """Startup an instance."""
1426
  OP_DSC_FIELD = "instance_name"
1427
  OP_PARAMS = [
1428
    _PInstanceName,
1429
    _PForce,
1430
    _PIgnoreOfflineNodes,
1431
    ("hvparams", ht.EmptyDict, ht.TDict,
1432
     "Temporary hypervisor parameters, hypervisor-dependent"),
1433
    ("beparams", ht.EmptyDict, ht.TDict, "Temporary backend parameters"),
1434
    _PNoRemember,
1435
    _PStartupPaused,
1436
    ]
1437
  OP_RESULT = ht.TNone
1438

    
1439

    
1440
class OpInstanceShutdown(OpCode):
1441
  """Shutdown an instance."""
1442
  OP_DSC_FIELD = "instance_name"
1443
  OP_PARAMS = [
1444
    _PInstanceName,
1445
    _PForce,
1446
    _PIgnoreOfflineNodes,
1447
    ("timeout", constants.DEFAULT_SHUTDOWN_TIMEOUT, ht.TNonNegativeInt,
1448
     "How long to wait for instance to shut down"),
1449
    _PNoRemember,
1450
    ]
1451
  OP_RESULT = ht.TNone
1452

    
1453

    
1454
class OpInstanceReboot(OpCode):
1455
  """Reboot an instance."""
1456
  OP_DSC_FIELD = "instance_name"
1457
  OP_PARAMS = [
1458
    _PInstanceName,
1459
    _PShutdownTimeout,
1460
    ("ignore_secondaries", False, ht.TBool,
1461
     "Whether to start the instance even if secondary disks are failing"),
1462
    ("reboot_type", ht.NoDefault, ht.TElemOf(constants.REBOOT_TYPES),
1463
     "How to reboot instance"),
1464
    _PReason,
1465
    ]
1466
  OP_RESULT = ht.TNone
1467

    
1468

    
1469
class OpInstanceReplaceDisks(OpCode):
1470
  """Replace the disks of an instance."""
1471
  OP_DSC_FIELD = "instance_name"
1472
  OP_PARAMS = [
1473
    _PInstanceName,
1474
    _PEarlyRelease,
1475
    _PIgnoreIpolicy,
1476
    ("mode", ht.NoDefault, ht.TElemOf(constants.REPLACE_MODES),
1477
     "Replacement mode"),
1478
    ("disks", ht.EmptyList, ht.TListOf(ht.TNonNegativeInt),
1479
     "Disk indexes"),
1480
    ("remote_node", None, ht.TMaybeString, "New secondary node"),
1481
    _PIAllocFromDesc("Iallocator for deciding new secondary node"),
1482
    ]
1483
  OP_RESULT = ht.TNone
1484

    
1485

    
1486
class OpInstanceFailover(OpCode):
1487
  """Failover an instance."""
1488
  OP_DSC_FIELD = "instance_name"
1489
  OP_PARAMS = [
1490
    _PInstanceName,
1491
    _PShutdownTimeout,
1492
    _PIgnoreConsistency,
1493
    _PMigrationTargetNode,
1494
    _PIgnoreIpolicy,
1495
    _PIAllocFromDesc("Iallocator for deciding the target node for"
1496
                     " shared-storage instances"),
1497
    ]
1498
  OP_RESULT = ht.TNone
1499

    
1500

    
1501
class OpInstanceMigrate(OpCode):
1502
  """Migrate an instance.
1503

1504
  This migrates (without shutting down an instance) to its secondary
1505
  node.
1506

1507
  @ivar instance_name: the name of the instance
1508
  @ivar mode: the migration mode (live, non-live or None for auto)
1509

1510
  """
1511
  OP_DSC_FIELD = "instance_name"
1512
  OP_PARAMS = [
1513
    _PInstanceName,
1514
    _PMigrationMode,
1515
    _PMigrationLive,
1516
    _PMigrationTargetNode,
1517
    _PAllowRuntimeChgs,
1518
    _PIgnoreIpolicy,
1519
    ("cleanup", False, ht.TBool,
1520
     "Whether a previously failed migration should be cleaned up"),
1521
    _PIAllocFromDesc("Iallocator for deciding the target node for"
1522
                     " shared-storage instances"),
1523
    ("allow_failover", False, ht.TBool,
1524
     "Whether we can fallback to failover if migration is not possible"),
1525
    ]
1526
  OP_RESULT = ht.TNone
1527

    
1528

    
1529
class OpInstanceMove(OpCode):
1530
  """Move an instance.
1531

1532
  This move (with shutting down an instance and data copying) to an
1533
  arbitrary node.
1534

1535
  @ivar instance_name: the name of the instance
1536
  @ivar target_node: the destination node
1537

1538
  """
1539
  OP_DSC_FIELD = "instance_name"
1540
  OP_PARAMS = [
1541
    _PInstanceName,
1542
    _PShutdownTimeout,
1543
    _PIgnoreIpolicy,
1544
    ("target_node", ht.NoDefault, ht.TNonEmptyString, "Target node"),
1545
    _PIgnoreConsistency,
1546
    ]
1547
  OP_RESULT = ht.TNone
1548

    
1549

    
1550
class OpInstanceConsole(OpCode):
1551
  """Connect to an instance's console."""
1552
  OP_DSC_FIELD = "instance_name"
1553
  OP_PARAMS = [
1554
    _PInstanceName,
1555
    ]
1556
  OP_RESULT = ht.TDict
1557

    
1558

    
1559
class OpInstanceActivateDisks(OpCode):
1560
  """Activate an instance's disks."""
1561
  OP_DSC_FIELD = "instance_name"
1562
  OP_PARAMS = [
1563
    _PInstanceName,
1564
    ("ignore_size", False, ht.TBool, "Whether to ignore recorded size"),
1565
    _PWaitForSyncFalse,
1566
    ]
1567
  OP_RESULT = ht.TListOf(ht.TAnd(ht.TIsLength(3),
1568
                                 ht.TItems([ht.TNonEmptyString,
1569
                                            ht.TNonEmptyString,
1570
                                            ht.TNonEmptyString])))
1571

    
1572

    
1573
class OpInstanceDeactivateDisks(OpCode):
1574
  """Deactivate an instance's disks."""
1575
  OP_DSC_FIELD = "instance_name"
1576
  OP_PARAMS = [
1577
    _PInstanceName,
1578
    _PForce,
1579
    ]
1580
  OP_RESULT = ht.TNone
1581

    
1582

    
1583
class OpInstanceRecreateDisks(OpCode):
1584
  """Recreate an instance's disks."""
1585
  _TDiskChanges = \
1586
    ht.TAnd(ht.TIsLength(2),
1587
            ht.TItems([ht.Comment("Disk index")(ht.TNonNegativeInt),
1588
                       ht.Comment("Parameters")(_TDiskParams)]))
1589

    
1590
  OP_DSC_FIELD = "instance_name"
1591
  OP_PARAMS = [
1592
    _PInstanceName,
1593
    ("disks", ht.EmptyList,
1594
     ht.TOr(ht.TListOf(ht.TNonNegativeInt), ht.TListOf(_TDiskChanges)),
1595
     "List of disk indexes (deprecated) or a list of tuples containing a disk"
1596
     " index and a possibly empty dictionary with disk parameter changes"),
1597
    ("nodes", ht.EmptyList, ht.TListOf(ht.TNonEmptyString),
1598
     "New instance nodes, if relocation is desired"),
1599
    _PIAllocFromDesc("Iallocator for deciding new nodes"),
1600
    ]
1601
  OP_RESULT = ht.TNone
1602

    
1603

    
1604
class OpInstanceQuery(OpCode):
1605
  """Compute the list of instances."""
1606
  OP_PARAMS = [
1607
    _POutputFields,
1608
    _PUseLocking,
1609
    ("names", ht.EmptyList, ht.TListOf(ht.TNonEmptyString),
1610
     "Empty list to query all instances, instance names otherwise"),
1611
    ]
1612
  OP_RESULT = _TOldQueryResult
1613

    
1614

    
1615
class OpInstanceQueryData(OpCode):
1616
  """Compute the run-time status of instances."""
1617
  OP_PARAMS = [
1618
    _PUseLocking,
1619
    ("instances", ht.EmptyList, ht.TListOf(ht.TNonEmptyString),
1620
     "Instance names"),
1621
    ("static", False, ht.TBool,
1622
     "Whether to only return configuration data without querying"
1623
     " nodes"),
1624
    ]
1625
  OP_RESULT = ht.TDictOf(ht.TNonEmptyString, ht.TDict)
1626

    
1627

    
1628
def _TestInstSetParamsModList(fn):
1629
  """Generates a check for modification lists.
1630

1631
  """
1632
  # Old format
1633
  # TODO: Remove in version 2.8 including support in LUInstanceSetParams
1634
  old_mod_item_fn = \
1635
    ht.TAnd(ht.TIsLength(2), ht.TItems([
1636
      ht.TOr(ht.TElemOf(constants.DDMS_VALUES), ht.TNonNegativeInt),
1637
      fn,
1638
      ]))
1639

    
1640
  # New format, supporting adding/removing disks/NICs at arbitrary indices
1641
  mod_item_fn = \
1642
    ht.TAnd(ht.TIsLength(3), ht.TItems([
1643
      ht.TElemOf(constants.DDMS_VALUES_WITH_MODIFY),
1644
      ht.Comment("Disk index, can be negative, e.g. -1 for last disk")(ht.TInt),
1645
      fn,
1646
      ]))
1647

    
1648
  return ht.TOr(ht.Comment("Recommended")(ht.TListOf(mod_item_fn)),
1649
                ht.Comment("Deprecated")(ht.TListOf(old_mod_item_fn)))
1650

    
1651

    
1652
class OpInstanceSetParams(OpCode):
1653
  """Change the parameters of an instance.
1654

1655
  """
1656
  TestNicModifications = _TestInstSetParamsModList(_TestNicDef)
1657
  TestDiskModifications = _TestInstSetParamsModList(_TDiskParams)
1658

    
1659
  OP_DSC_FIELD = "instance_name"
1660
  OP_PARAMS = [
1661
    _PInstanceName,
1662
    _PForce,
1663
    _PForceVariant,
1664
    _PIgnoreIpolicy,
1665
    ("nics", ht.EmptyList, TestNicModifications,
1666
     "List of NIC changes: each item is of the form ``(op, index, settings)``,"
1667
     " ``op`` is one of ``%s``, ``%s`` or ``%s``, ``index`` can be either -1"
1668
     " to refer to the last position, or a zero-based index number; a"
1669
     " deprecated version of this parameter used the form ``(op, settings)``,"
1670
     " where ``op`` can be ``%s`` to add a new NIC with the specified"
1671
     " settings, ``%s`` to remove the last NIC or a number to modify the"
1672
     " settings of the NIC with that index" %
1673
     (constants.DDM_ADD, constants.DDM_MODIFY, constants.DDM_REMOVE,
1674
      constants.DDM_ADD, constants.DDM_REMOVE)),
1675
    ("disks", ht.EmptyList, TestDiskModifications,
1676
     "List of disk changes; see ``nics``"),
1677
    ("beparams", ht.EmptyDict, ht.TDict, "Per-instance backend parameters"),
1678
    ("runtime_mem", None, ht.TMaybePositiveInt, "New runtime memory"),
1679
    ("hvparams", ht.EmptyDict, ht.TDict,
1680
     "Per-instance hypervisor parameters, hypervisor-dependent"),
1681
    ("disk_template", None, ht.TMaybe(_BuildDiskTemplateCheck(False)),
1682
     "Disk template for instance"),
1683
    ("remote_node", None, ht.TMaybeString,
1684
     "Secondary node (used when changing disk template)"),
1685
    ("os_name", None, ht.TMaybeString,
1686
     "Change the instance's OS without reinstalling the instance"),
1687
    ("osparams", None, ht.TMaybeDict, "Per-instance OS parameters"),
1688
    ("wait_for_sync", True, ht.TBool,
1689
     "Whether to wait for the disk to synchronize, when changing template"),
1690
    ("offline", None, ht.TMaybeBool, "Whether to mark instance as offline"),
1691
    ("conflicts_check", True, ht.TBool, "Check for conflicting IPs"),
1692
    ]
1693
  OP_RESULT = _TSetParamsResult
1694

    
1695

    
1696
class OpInstanceGrowDisk(OpCode):
1697
  """Grow a disk of an instance."""
1698
  OP_DSC_FIELD = "instance_name"
1699
  OP_PARAMS = [
1700
    _PInstanceName,
1701
    _PWaitForSync,
1702
    ("disk", ht.NoDefault, ht.TInt, "Disk index"),
1703
    ("amount", ht.NoDefault, ht.TNonNegativeInt,
1704
     "Amount of disk space to add (megabytes)"),
1705
    ("absolute", False, ht.TBool,
1706
     "Whether the amount parameter is an absolute target or a relative one"),
1707
    ]
1708
  OP_RESULT = ht.TNone
1709

    
1710

    
1711
class OpInstanceChangeGroup(OpCode):
1712
  """Moves an instance to another node group."""
1713
  OP_DSC_FIELD = "instance_name"
1714
  OP_PARAMS = [
1715
    _PInstanceName,
1716
    _PEarlyRelease,
1717
    _PIAllocFromDesc("Iallocator for computing solution"),
1718
    _PTargetGroups,
1719
    ]
1720
  OP_RESULT = TJobIdListOnly
1721

    
1722

    
1723
# Node group opcodes
1724

    
1725
class OpGroupAdd(OpCode):
1726
  """Add a node group to the cluster."""
1727
  OP_DSC_FIELD = "group_name"
1728
  OP_PARAMS = [
1729
    _PGroupName,
1730
    _PNodeGroupAllocPolicy,
1731
    _PGroupNodeParams,
1732
    _PDiskParams,
1733
    _PHvState,
1734
    _PDiskState,
1735
    ("ipolicy", None, ht.TMaybeDict,
1736
     "Group-wide :ref:`instance policy <rapi-ipolicy>` specs"),
1737
    ]
1738
  OP_RESULT = ht.TNone
1739

    
1740

    
1741
class OpGroupAssignNodes(OpCode):
1742
  """Assign nodes to a node group."""
1743
  OP_DSC_FIELD = "group_name"
1744
  OP_PARAMS = [
1745
    _PGroupName,
1746
    _PForce,
1747
    ("nodes", ht.NoDefault, ht.TListOf(ht.TNonEmptyString),
1748
     "List of nodes to assign"),
1749
    ]
1750
  OP_RESULT = ht.TNone
1751

    
1752

    
1753
class OpGroupQuery(OpCode):
1754
  """Compute the list of node groups."""
1755
  OP_PARAMS = [
1756
    _POutputFields,
1757
    ("names", ht.EmptyList, ht.TListOf(ht.TNonEmptyString),
1758
     "Empty list to query all groups, group names otherwise"),
1759
    ]
1760
  OP_RESULT = _TOldQueryResult
1761

    
1762

    
1763
class OpGroupSetParams(OpCode):
1764
  """Change the parameters of a node group."""
1765
  OP_DSC_FIELD = "group_name"
1766
  OP_PARAMS = [
1767
    _PGroupName,
1768
    _PNodeGroupAllocPolicy,
1769
    _PGroupNodeParams,
1770
    _PDiskParams,
1771
    _PHvState,
1772
    _PDiskState,
1773
    ("ipolicy", None, ht.TMaybeDict, "Group-wide instance policy specs"),
1774
    ]
1775
  OP_RESULT = _TSetParamsResult
1776

    
1777

    
1778
class OpGroupRemove(OpCode):
1779
  """Remove a node group from the cluster."""
1780
  OP_DSC_FIELD = "group_name"
1781
  OP_PARAMS = [
1782
    _PGroupName,
1783
    ]
1784
  OP_RESULT = ht.TNone
1785

    
1786

    
1787
class OpGroupRename(OpCode):
1788
  """Rename a node group in the cluster."""
1789
  OP_PARAMS = [
1790
    _PGroupName,
1791
    ("new_name", ht.NoDefault, ht.TNonEmptyString, "New group name"),
1792
    ]
1793
  OP_RESULT = ht.Comment("New group name")(ht.TNonEmptyString)
1794

    
1795

    
1796
class OpGroupEvacuate(OpCode):
1797
  """Evacuate a node group in the cluster."""
1798
  OP_DSC_FIELD = "group_name"
1799
  OP_PARAMS = [
1800
    _PGroupName,
1801
    _PEarlyRelease,
1802
    _PIAllocFromDesc("Iallocator for computing solution"),
1803
    _PTargetGroups,
1804
    ]
1805
  OP_RESULT = TJobIdListOnly
1806

    
1807

    
1808
# OS opcodes
1809
class OpOsDiagnose(OpCode):
1810
  """Compute the list of guest operating systems."""
1811
  OP_PARAMS = [
1812
    _POutputFields,
1813
    ("names", ht.EmptyList, ht.TListOf(ht.TNonEmptyString),
1814
     "Which operating systems to diagnose"),
1815
    ]
1816
  OP_RESULT = _TOldQueryResult
1817

    
1818

    
1819
# ExtStorage opcodes
1820
class OpExtStorageDiagnose(OpCode):
1821
  """Compute the list of external storage providers."""
1822
  OP_PARAMS = [
1823
    _POutputFields,
1824
    ("names", ht.EmptyList, ht.TListOf(ht.TNonEmptyString),
1825
     "Which ExtStorage Provider to diagnose"),
1826
    ]
1827
  OP_RESULT = _TOldQueryResult
1828

    
1829

    
1830
# Exports opcodes
1831
class OpBackupQuery(OpCode):
1832
  """Compute the list of exported images."""
1833
  OP_PARAMS = [
1834
    _PUseLocking,
1835
    ("nodes", ht.EmptyList, ht.TListOf(ht.TNonEmptyString),
1836
     "Empty list to query all nodes, node names otherwise"),
1837
    ]
1838
  OP_RESULT = ht.TDictOf(ht.TNonEmptyString,
1839
                         ht.TOr(ht.Comment("False on error")(ht.TBool),
1840
                                ht.TListOf(ht.TNonEmptyString)))
1841

    
1842

    
1843
class OpBackupPrepare(OpCode):
1844
  """Prepares an instance export.
1845

1846
  @ivar instance_name: Instance name
1847
  @ivar mode: Export mode (one of L{constants.EXPORT_MODES})
1848

1849
  """
1850
  OP_DSC_FIELD = "instance_name"
1851
  OP_PARAMS = [
1852
    _PInstanceName,
1853
    ("mode", ht.NoDefault, ht.TElemOf(constants.EXPORT_MODES),
1854
     "Export mode"),
1855
    ]
1856
  OP_RESULT = ht.TMaybeDict
1857

    
1858

    
1859
class OpBackupExport(OpCode):
1860
  """Export an instance.
1861

1862
  For local exports, the export destination is the node name. For
1863
  remote exports, the export destination is a list of tuples, each
1864
  consisting of hostname/IP address, port, magic, HMAC and HMAC
1865
  salt. The HMAC is calculated using the cluster domain secret over
1866
  the value "${index}:${hostname}:${port}". The destination X509 CA
1867
  must be a signed certificate.
1868

1869
  @ivar mode: Export mode (one of L{constants.EXPORT_MODES})
1870
  @ivar target_node: Export destination
1871
  @ivar x509_key_name: X509 key to use (remote export only)
1872
  @ivar destination_x509_ca: Destination X509 CA in PEM format (remote export
1873
                             only)
1874

1875
  """
1876
  OP_DSC_FIELD = "instance_name"
1877
  OP_PARAMS = [
1878
    _PInstanceName,
1879
    _PShutdownTimeout,
1880
    # TODO: Rename target_node as it changes meaning for different export modes
1881
    # (e.g. "destination")
1882
    ("target_node", ht.NoDefault, ht.TOr(ht.TNonEmptyString, ht.TList),
1883
     "Destination information, depends on export mode"),
1884
    ("shutdown", True, ht.TBool, "Whether to shutdown instance before export"),
1885
    ("remove_instance", False, ht.TBool,
1886
     "Whether to remove instance after export"),
1887
    ("ignore_remove_failures", False, ht.TBool,
1888
     "Whether to ignore failures while removing instances"),
1889
    ("mode", constants.EXPORT_MODE_LOCAL, ht.TElemOf(constants.EXPORT_MODES),
1890
     "Export mode"),
1891
    ("x509_key_name", None, ht.TMaybe(ht.TList),
1892
     "Name of X509 key (remote export only)"),
1893
    ("destination_x509_ca", None, ht.TMaybeString,
1894
     "Destination X509 CA (remote export only)"),
1895
    ]
1896
  OP_RESULT = \
1897
    ht.TAnd(ht.TIsLength(2), ht.TItems([
1898
      ht.Comment("Finalizing status")(ht.TBool),
1899
      ht.Comment("Status for every exported disk")(ht.TListOf(ht.TBool)),
1900
      ]))
1901

    
1902

    
1903
class OpBackupRemove(OpCode):
1904
  """Remove an instance's export."""
1905
  OP_DSC_FIELD = "instance_name"
1906
  OP_PARAMS = [
1907
    _PInstanceName,
1908
    ]
1909
  OP_RESULT = ht.TNone
1910

    
1911

    
1912
# Tags opcodes
1913
class OpTagsGet(OpCode):
1914
  """Returns the tags of the given object."""
1915
  OP_DSC_FIELD = "name"
1916
  OP_PARAMS = [
1917
    _PTagKind,
1918
    # Not using _PUseLocking as the default is different for historical reasons
1919
    ("use_locking", True, ht.TBool, "Whether to use synchronization"),
1920
    # Name is only meaningful for nodes and instances
1921
    ("name", ht.NoDefault, ht.TMaybeString,
1922
     "Name of object to retrieve tags from"),
1923
    ]
1924
  OP_RESULT = ht.TListOf(ht.TNonEmptyString)
1925

    
1926

    
1927
class OpTagsSearch(OpCode):
1928
  """Searches the tags in the cluster for a given pattern."""
1929
  OP_DSC_FIELD = "pattern"
1930
  OP_PARAMS = [
1931
    ("pattern", ht.NoDefault, ht.TNonEmptyString,
1932
     "Search pattern (regular expression)"),
1933
    ]
1934
  OP_RESULT = ht.TListOf(ht.TAnd(ht.TIsLength(2), ht.TItems([
1935
    ht.TNonEmptyString,
1936
    ht.TNonEmptyString,
1937
    ])))
1938

    
1939

    
1940
class OpTagsSet(OpCode):
1941
  """Add a list of tags on a given object."""
1942
  OP_PARAMS = [
1943
    _PTagKind,
1944
    _PTags,
1945
    # Name is only meaningful for groups, nodes and instances
1946
    ("name", ht.NoDefault, ht.TMaybeString,
1947
     "Name of object where tag(s) should be added"),
1948
    ]
1949
  OP_RESULT = ht.TNone
1950

    
1951

    
1952
class OpTagsDel(OpCode):
1953
  """Remove a list of tags from a given object."""
1954
  OP_PARAMS = [
1955
    _PTagKind,
1956
    _PTags,
1957
    # Name is only meaningful for groups, nodes and instances
1958
    ("name", ht.NoDefault, ht.TMaybeString,
1959
     "Name of object where tag(s) should be deleted"),
1960
    ]
1961
  OP_RESULT = ht.TNone
1962

    
1963

    
1964
# Test opcodes
1965
class OpTestDelay(OpCode):
1966
  """Sleeps for a configured amount of time.
1967

1968
  This is used just for debugging and testing.
1969

1970
  Parameters:
1971
    - duration: the time to sleep, in seconds
1972
    - on_master: if true, sleep on the master
1973
    - on_nodes: list of nodes in which to sleep
1974

1975
  If the on_master parameter is true, it will execute a sleep on the
1976
  master (before any node sleep).
1977

1978
  If the on_nodes list is not empty, it will sleep on those nodes
1979
  (after the sleep on the master, if that is enabled).
1980

1981
  As an additional feature, the case of duration < 0 will be reported
1982
  as an execution error, so this opcode can be used as a failure
1983
  generator. The case of duration == 0 will not be treated specially.
1984

1985
  """
1986
  OP_DSC_FIELD = "duration"
1987
  OP_PARAMS = [
1988
    ("duration", ht.NoDefault, ht.TNumber, None),
1989
    ("on_master", True, ht.TBool, None),
1990
    ("on_nodes", ht.EmptyList, ht.TListOf(ht.TNonEmptyString), None),
1991
    ("repeat", 0, ht.TNonNegativeInt, None),
1992
    ]
1993

    
1994
  def OP_DSC_FORMATTER(self, value): # pylint: disable=C0103,R0201
1995
    """Custom formatter for duration.
1996

1997
    """
1998
    try:
1999
      v = float(value)
2000
    except TypeError:
2001
      v = value
2002
    return str(v)
2003

    
2004

    
2005
class OpTestAllocator(OpCode):
2006
  """Allocator framework testing.
2007

2008
  This opcode has two modes:
2009
    - gather and return allocator input for a given mode (allocate new
2010
      or replace secondary) and a given instance definition (direction
2011
      'in')
2012
    - run a selected allocator for a given operation (as above) and
2013
      return the allocator output (direction 'out')
2014

2015
  """
2016
  OP_DSC_FIELD = "iallocator"
2017
  OP_PARAMS = [
2018
    ("direction", ht.NoDefault,
2019
     ht.TElemOf(constants.VALID_IALLOCATOR_DIRECTIONS), None),
2020
    ("mode", ht.NoDefault, ht.TElemOf(constants.VALID_IALLOCATOR_MODES), None),
2021
    ("name", ht.NoDefault, ht.TNonEmptyString, None),
2022
    ("nics", ht.NoDefault,
2023
     ht.TMaybeListOf(ht.TDictOf(ht.TElemOf([constants.INIC_MAC,
2024
                                            constants.INIC_IP,
2025
                                            "bridge"]),
2026
                                ht.TMaybeString)),
2027
     None),
2028
    ("disks", ht.NoDefault, ht.TMaybe(ht.TList), None),
2029
    ("hypervisor", None, ht.TMaybeString, None),
2030
    _PIAllocFromDesc(None),
2031
    ("tags", ht.EmptyList, ht.TListOf(ht.TNonEmptyString), None),
2032
    ("memory", None, ht.TMaybe(ht.TNonNegativeInt), None),
2033
    ("vcpus", None, ht.TMaybe(ht.TNonNegativeInt), None),
2034
    ("os", None, ht.TMaybeString, None),
2035
    ("disk_template", None, ht.TMaybeString, None),
2036
    ("instances", None, ht.TMaybeListOf(ht.TNonEmptyString), None),
2037
    ("evac_mode", None,
2038
     ht.TMaybe(ht.TElemOf(constants.IALLOCATOR_NEVAC_MODES)), None),
2039
    ("target_groups", None, ht.TMaybeListOf(ht.TNonEmptyString), None),
2040
    ("spindle_use", 1, ht.TNonNegativeInt, None),
2041
    ("count", 1, ht.TNonNegativeInt, None),
2042
    ]
2043

    
2044

    
2045
class OpTestJqueue(OpCode):
2046
  """Utility opcode to test some aspects of the job queue.
2047

2048
  """
2049
  OP_PARAMS = [
2050
    ("notify_waitlock", False, ht.TBool, None),
2051
    ("notify_exec", False, ht.TBool, None),
2052
    ("log_messages", ht.EmptyList, ht.TListOf(ht.TString), None),
2053
    ("fail", False, ht.TBool, None),
2054
    ]
2055

    
2056

    
2057
class OpTestDummy(OpCode):
2058
  """Utility opcode used by unittests.
2059

2060
  """
2061
  OP_PARAMS = [
2062
    ("result", ht.NoDefault, ht.NoType, None),
2063
    ("messages", ht.NoDefault, ht.NoType, None),
2064
    ("fail", ht.NoDefault, ht.NoType, None),
2065
    ("submit_jobs", None, ht.NoType, None),
2066
    ]
2067
  WITH_LU = False
2068

    
2069

    
2070
# Network opcodes
2071
# Add a new network in the cluster
2072
class OpNetworkAdd(OpCode):
2073
  """Add an IP network to the cluster."""
2074
  OP_DSC_FIELD = "network_name"
2075
  OP_PARAMS = [
2076
    _PNetworkName,
2077
    ("network", ht.NoDefault, _TIpNetwork4, "IPv4 subnet"),
2078
    ("gateway", None, ht.TMaybe(_TIpAddress4), "IPv4 gateway"),
2079
    ("network6", None, ht.TMaybe(_TIpNetwork6), "IPv6 subnet"),
2080
    ("gateway6", None, ht.TMaybe(_TIpAddress6), "IPv6 gateway"),
2081
    ("mac_prefix", None, ht.TMaybeString,
2082
     "MAC address prefix that overrides cluster one"),
2083
    ("add_reserved_ips", None, _TMaybeAddr4List,
2084
     "Which IP addresses to reserve"),
2085
    ("conflicts_check", True, ht.TBool,
2086
     "Whether to check for conflicting IP addresses"),
2087
    ("tags", ht.EmptyList, ht.TListOf(ht.TNonEmptyString), "Network tags"),
2088
    ]
2089
  OP_RESULT = ht.TNone
2090

    
2091

    
2092
class OpNetworkRemove(OpCode):
2093
  """Remove an existing network from the cluster.
2094
     Must not be connected to any nodegroup.
2095

2096
  """
2097
  OP_DSC_FIELD = "network_name"
2098
  OP_PARAMS = [
2099
    _PNetworkName,
2100
    _PForce,
2101
    ]
2102
  OP_RESULT = ht.TNone
2103

    
2104

    
2105
class OpNetworkSetParams(OpCode):
2106
  """Modify Network's parameters except for IPv4 subnet"""
2107
  OP_DSC_FIELD = "network_name"
2108
  OP_PARAMS = [
2109
    _PNetworkName,
2110
    ("gateway", None, ht.TMaybeValueNone(_TIpAddress4), "IPv4 gateway"),
2111
    ("network6", None, ht.TMaybeValueNone(_TIpNetwork6), "IPv6 subnet"),
2112
    ("gateway6", None, ht.TMaybeValueNone(_TIpAddress6), "IPv6 gateway"),
2113
    ("mac_prefix", None, ht.TMaybeValueNone(ht.TString),
2114
     "MAC address prefix that overrides cluster one"),
2115
    ("add_reserved_ips", None, _TMaybeAddr4List,
2116
     "Which external IP addresses to reserve"),
2117
    ("remove_reserved_ips", None, _TMaybeAddr4List,
2118
     "Which external IP addresses to release"),
2119
    ]
2120
  OP_RESULT = ht.TNone
2121

    
2122

    
2123
class OpNetworkConnect(OpCode):
2124
  """Connect a Network to a specific Nodegroup with the defined netparams
2125
     (mode, link). Nics in this Network will inherit those params.
2126
     Produce errors if a NIC (that its not already assigned to a network)
2127
     has an IP that is contained in the Network this will produce error unless
2128
     --no-conflicts-check is passed.
2129

2130
  """
2131
  OP_DSC_FIELD = "network_name"
2132
  OP_PARAMS = [
2133
    _PGroupName,
2134
    _PNetworkName,
2135
    ("network_mode", ht.NoDefault, ht.TElemOf(constants.NIC_VALID_MODES),
2136
     "Connectivity mode"),
2137
    ("network_link", ht.NoDefault, ht.TString, "Connectivity link"),
2138
    ("conflicts_check", True, ht.TBool, "Whether to check for conflicting IPs"),
2139
    ]
2140
  OP_RESULT = ht.TNone
2141

    
2142

    
2143
class OpNetworkDisconnect(OpCode):
2144
  """Disconnect a Network from a Nodegroup. Produce errors if NICs are
2145
     present in the Network unless --no-conficts-check option is passed.
2146

2147
  """
2148
  OP_DSC_FIELD = "network_name"
2149
  OP_PARAMS = [
2150
    _PGroupName,
2151
    _PNetworkName,
2152
    ]
2153
  OP_RESULT = ht.TNone
2154

    
2155

    
2156
class OpNetworkQuery(OpCode):
2157
  """Compute the list of networks."""
2158
  OP_PARAMS = [
2159
    _POutputFields,
2160
    _PUseLocking,
2161
    ("names", ht.EmptyList, ht.TListOf(ht.TNonEmptyString),
2162
     "Empty list to query all groups, group names otherwise"),
2163
    ]
2164
  OP_RESULT = _TOldQueryResult
2165

    
2166

    
2167
def _GetOpList():
2168
  """Returns list of all defined opcodes.
2169

2170
  Does not eliminate duplicates by C{OP_ID}.
2171

2172
  """
2173
  return [v for v in globals().values()
2174
          if (isinstance(v, type) and issubclass(v, OpCode) and
2175
              hasattr(v, "OP_ID") and v is not OpCode)]
2176

    
2177

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