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