Statistics
| Branch: | Tag: | Revision:

root / lib / opcodes.py @ ee844e20

History | View | Annotate | Download (18.7 kB)

1
#
2
#
3

    
4
# Copyright (C) 2006, 2007 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-msg=R0903
35

    
36

    
37
class BaseOpCode(object):
38
  """A simple serializable object.
39

40
  This object serves as a parent class for OpCode without any custom
41
  field handling.
42

43
  """
44
  __slots__ = []
45

    
46
  def __init__(self, **kwargs):
47
    """Constructor for BaseOpCode.
48

49
    The constructor takes only keyword arguments and will set
50
    attributes on this object based on the passed arguments. As such,
51
    it means that you should not pass arguments which are not in the
52
    __slots__ attribute for this class.
53

54
    """
55
    slots = self._all_slots()
56
    for key in kwargs:
57
      if key not in slots:
58
        raise TypeError("Object %s doesn't support the parameter '%s'" %
59
                        (self.__class__.__name__, key))
60
      setattr(self, key, kwargs[key])
61

    
62
  def __getstate__(self):
63
    """Generic serializer.
64

65
    This method just returns the contents of the instance as a
66
    dictionary.
67

68
    @rtype:  C{dict}
69
    @return: the instance attributes and their values
70

71
    """
72
    state = {}
73
    for name in self._all_slots():
74
      if hasattr(self, name):
75
        state[name] = getattr(self, name)
76
    return state
77

    
78
  def __setstate__(self, state):
79
    """Generic unserializer.
80

81
    This method just restores from the serialized state the attributes
82
    of the current instance.
83

84
    @param state: the serialized opcode data
85
    @type state:  C{dict}
86

87
    """
88
    if not isinstance(state, dict):
89
      raise ValueError("Invalid data to __setstate__: expected dict, got %s" %
90
                       type(state))
91

    
92
    for name in self._all_slots():
93
      if name not in state:
94
        delattr(self, name)
95

    
96
    for name in state:
97
      setattr(self, name, state[name])
98

    
99
  @classmethod
100
  def _all_slots(cls):
101
    """Compute the list of all declared slots for a class.
102

103
    """
104
    slots = []
105
    for parent in cls.__mro__:
106
      slots.extend(getattr(parent, "__slots__", []))
107
    return slots
108

    
109

    
110
class OpCode(BaseOpCode):
111
  """Abstract OpCode.
112

113
  This is the root of the actual OpCode hierarchy. All clases derived
114
  from this class should override OP_ID.
115

116
  @cvar OP_ID: The ID of this opcode. This should be unique amongst all
117
               children of this class.
118
  @ivar dry_run: Whether the LU should be run in dry-run mode, i.e. just
119
                 the check steps
120

121
  """
122
  OP_ID = "OP_ABSTRACT"
123
  __slots__ = ["dry_run", "debug_level"]
124

    
125
  def __getstate__(self):
126
    """Specialized getstate for opcodes.
127

128
    This method adds to the state dictionary the OP_ID of the class,
129
    so that on unload we can identify the correct class for
130
    instantiating the opcode.
131

132
    @rtype:   C{dict}
133
    @return:  the state as a dictionary
134

135
    """
136
    data = BaseOpCode.__getstate__(self)
137
    data["OP_ID"] = self.OP_ID
138
    return data
139

    
140
  @classmethod
141
  def LoadOpCode(cls, data):
142
    """Generic load opcode method.
143

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

148
    @type data:  C{dict}
149
    @param data: the serialized opcode
150

151
    """
152
    if not isinstance(data, dict):
153
      raise ValueError("Invalid data to LoadOpCode (%s)" % type(data))
154
    if "OP_ID" not in data:
155
      raise ValueError("Invalid data to LoadOpcode, missing OP_ID")
156
    op_id = data["OP_ID"]
157
    op_class = None
158
    if op_id in OP_MAPPING:
159
      op_class = OP_MAPPING[op_id]
160
    else:
161
      raise ValueError("Invalid data to LoadOpCode: OP_ID %s unsupported" %
162
                       op_id)
163
    op = op_class()
164
    new_data = data.copy()
165
    del new_data["OP_ID"]
166
    op.__setstate__(new_data)
167
    return op
168

    
169
  def Summary(self):
170
    """Generates a summary description of this opcode.
171

172
    """
173
    # all OP_ID start with OP_, we remove that
174
    txt = self.OP_ID[3:]
175
    field_name = getattr(self, "OP_DSC_FIELD", None)
176
    if field_name:
177
      field_value = getattr(self, field_name, None)
178
      txt = "%s(%s)" % (txt, field_value)
179
    return txt
180

    
181

    
182
# cluster opcodes
183

    
184
class OpPostInitCluster(OpCode):
185
  """Post cluster initialization.
186

187
  This opcode does not touch the cluster at all. Its purpose is to run hooks
188
  after the cluster has been initialized.
189

190
  """
191
  OP_ID = "OP_CLUSTER_POST_INIT"
192
  __slots__ = []
193

    
194

    
195
class OpDestroyCluster(OpCode):
196
  """Destroy the cluster.
197

198
  This opcode has no other parameters. All the state is irreversibly
199
  lost after the execution of this opcode.
200

201
  """
202
  OP_ID = "OP_CLUSTER_DESTROY"
203
  __slots__ = []
204

    
205

    
206
class OpQueryClusterInfo(OpCode):
207
  """Query cluster information."""
208
  OP_ID = "OP_CLUSTER_QUERY"
209
  __slots__ = []
210

    
211

    
212
class OpVerifyCluster(OpCode):
213
  """Verify the cluster state.
214

215
  @type skip_checks: C{list}
216
  @ivar skip_checks: steps to be skipped from the verify process; this
217
                     needs to be a subset of
218
                     L{constants.VERIFY_OPTIONAL_CHECKS}; currently
219
                     only L{constants.VERIFY_NPLUSONE_MEM} can be passed
220

221
  """
222
  OP_ID = "OP_CLUSTER_VERIFY"
223
  __slots__ = ["skip_checks", "verbose", "error_codes",
224
               "debug_simulate_errors"]
225

    
226

    
227
class OpVerifyDisks(OpCode):
228
  """Verify the cluster disks.
229

230
  Parameters: none
231

232
  Result: a tuple of four elements:
233
    - list of node names with bad data returned (unreachable, etc.)
234
    - dict of node names with broken volume groups (values: error msg)
235
    - list of instances with degraded disks (that should be activated)
236
    - dict of instances with missing logical volumes (values: (node, vol)
237
      pairs with details about the missing volumes)
238

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

244
  Note that only instances that are drbd-based are taken into
245
  consideration. This might need to be revisited in the future.
246

247
  """
248
  OP_ID = "OP_CLUSTER_VERIFY_DISKS"
249
  __slots__ = []
250

    
251

    
252
class OpRepairDiskSizes(OpCode):
253
  """Verify the disk sizes of the instances and fixes configuration
254
  mimatches.
255

256
  Parameters: optional instances list, in case we want to restrict the
257
  checks to only a subset of the instances.
258

259
  Result: a list of tuples, (instance, disk, new-size) for changed
260
  configurations.
261

262
  In normal operation, the list should be empty.
263

264
  @type instances: list
265
  @ivar instances: the list of instances to check, or empty for all instances
266

267
  """
268
  OP_ID = "OP_CLUSTER_REPAIR_DISK_SIZES"
269
  __slots__ = ["instances"]
270

    
271

    
272
class OpQueryConfigValues(OpCode):
273
  """Query cluster configuration values."""
274
  OP_ID = "OP_CLUSTER_CONFIG_QUERY"
275
  __slots__ = ["output_fields"]
276

    
277

    
278
class OpRenameCluster(OpCode):
279
  """Rename the cluster.
280

281
  @type name: C{str}
282
  @ivar name: The new name of the cluster. The name and/or the master IP
283
              address will be changed to match the new name and its IP
284
              address.
285

286
  """
287
  OP_ID = "OP_CLUSTER_RENAME"
288
  OP_DSC_FIELD = "name"
289
  __slots__ = ["name"]
290

    
291

    
292
class OpSetClusterParams(OpCode):
293
  """Change the parameters of the cluster.
294

295
  @type vg_name: C{str} or C{None}
296
  @ivar vg_name: The new volume group name or None to disable LVM usage.
297

298
  """
299
  OP_ID = "OP_CLUSTER_SET_PARAMS"
300
  __slots__ = [
301
    "vg_name",
302
    "enabled_hypervisors",
303
    "hvparams",
304
    "beparams",
305
    "nicparams",
306
    "candidate_pool_size",
307
    ]
308

    
309

    
310
class OpRedistributeConfig(OpCode):
311
  """Force a full push of the cluster configuration.
312

313
  """
314
  OP_ID = "OP_CLUSTER_REDIST_CONF"
315
  __slots__ = []
316

    
317
# node opcodes
318

    
319
class OpRemoveNode(OpCode):
320
  """Remove a node.
321

322
  @type node_name: C{str}
323
  @ivar node_name: The name of the node to remove. If the node still has
324
                   instances on it, the operation will fail.
325

326
  """
327
  OP_ID = "OP_NODE_REMOVE"
328
  OP_DSC_FIELD = "node_name"
329
  __slots__ = ["node_name"]
330

    
331

    
332
class OpAddNode(OpCode):
333
  """Add a node to the cluster.
334

335
  @type node_name: C{str}
336
  @ivar node_name: The name of the node to add. This can be a short name,
337
                   but it will be expanded to the FQDN.
338
  @type primary_ip: IP address
339
  @ivar primary_ip: The primary IP of the node. This will be ignored when the
340
                    opcode is submitted, but will be filled during the node
341
                    add (so it will be visible in the job query).
342
  @type secondary_ip: IP address
343
  @ivar secondary_ip: The secondary IP of the node. This needs to be passed
344
                      if the cluster has been initialized in 'dual-network'
345
                      mode, otherwise it must not be given.
346
  @type readd: C{bool}
347
  @ivar readd: Whether to re-add an existing node to the cluster. If
348
               this is not passed, then the operation will abort if the node
349
               name is already in the cluster; use this parameter to 'repair'
350
               a node that had its configuration broken, or was reinstalled
351
               without removal from the cluster.
352

353
  """
354
  OP_ID = "OP_NODE_ADD"
355
  OP_DSC_FIELD = "node_name"
356
  __slots__ = ["node_name", "primary_ip", "secondary_ip", "readd"]
357

    
358

    
359
class OpQueryNodes(OpCode):
360
  """Compute the list of nodes."""
361
  OP_ID = "OP_NODE_QUERY"
362
  __slots__ = ["output_fields", "names", "use_locking"]
363

    
364

    
365
class OpQueryNodeVolumes(OpCode):
366
  """Get list of volumes on node."""
367
  OP_ID = "OP_NODE_QUERYVOLS"
368
  __slots__ = ["nodes", "output_fields"]
369

    
370

    
371
class OpQueryNodeStorage(OpCode):
372
  """Get information on storage for node(s)."""
373
  OP_ID = "OP_NODE_QUERY_STORAGE"
374
  __slots__ = [
375
    "nodes",
376
    "storage_type",
377
    "name",
378
    "output_fields",
379
    ]
380

    
381

    
382
class OpModifyNodeStorage(OpCode):
383
  """Modifies the properies of a storage unit"""
384
  OP_ID = "OP_NODE_MODIFY_STORAGE"
385
  __slots__ = [
386
    "node_name",
387
    "storage_type",
388
    "name",
389
    "changes",
390
    ]
391

    
392

    
393
class OpRepairNodeStorage(OpCode):
394
  """Repairs the volume group on a node."""
395
  OP_ID = "OP_REPAIR_NODE_STORAGE"
396
  OP_DSC_FIELD = "node_name"
397
  __slots__ = [
398
    "node_name",
399
    "storage_type",
400
    "name",
401
    "ignore_consistency",
402
    ]
403

    
404

    
405
class OpSetNodeParams(OpCode):
406
  """Change the parameters of a node."""
407
  OP_ID = "OP_NODE_SET_PARAMS"
408
  OP_DSC_FIELD = "node_name"
409
  __slots__ = [
410
    "node_name",
411
    "force",
412
    "master_candidate",
413
    "offline",
414
    "drained",
415
    ]
416

    
417

    
418
class OpPowercycleNode(OpCode):
419
  """Tries to powercycle a node."""
420
  OP_ID = "OP_NODE_POWERCYCLE"
421
  OP_DSC_FIELD = "node_name"
422
  __slots__ = [
423
    "node_name",
424
    "force",
425
    ]
426

    
427

    
428
class OpEvacuateNode(OpCode):
429
  """Relocate secondary instances from a node."""
430
  OP_ID = "OP_NODE_EVACUATE"
431
  OP_DSC_FIELD = "node_name"
432
  __slots__ = [
433
    "node_name", "remote_node", "iallocator", "early_release",
434
    ]
435

    
436

    
437
class OpMigrateNode(OpCode):
438
  """Migrate all instances from a node."""
439
  OP_ID = "OP_NODE_MIGRATE"
440
  OP_DSC_FIELD = "node_name"
441
  __slots__ = [
442
    "node_name",
443
    "live",
444
    ]
445

    
446

    
447
# instance opcodes
448

    
449
class OpCreateInstance(OpCode):
450
  """Create an instance."""
451
  OP_ID = "OP_INSTANCE_CREATE"
452
  OP_DSC_FIELD = "instance_name"
453
  __slots__ = [
454
    "instance_name", "os_type", "force_variant",
455
    "pnode", "disk_template", "snode", "mode",
456
    "disks", "nics",
457
    "src_node", "src_path", "start",
458
    "wait_for_sync", "ip_check", "name_check",
459
    "file_storage_dir", "file_driver",
460
    "iallocator",
461
    "hypervisor", "hvparams", "beparams",
462
    "dry_run",
463
    ]
464

    
465

    
466
class OpReinstallInstance(OpCode):
467
  """Reinstall an instance's OS."""
468
  OP_ID = "OP_INSTANCE_REINSTALL"
469
  OP_DSC_FIELD = "instance_name"
470
  __slots__ = ["instance_name", "os_type", "force_variant"]
471

    
472

    
473
class OpRemoveInstance(OpCode):
474
  """Remove an instance."""
475
  OP_ID = "OP_INSTANCE_REMOVE"
476
  OP_DSC_FIELD = "instance_name"
477
  __slots__ = [
478
    "instance_name",
479
    "ignore_failures",
480
    "shutdown_timeout",
481
    ]
482

    
483

    
484
class OpRenameInstance(OpCode):
485
  """Rename an instance."""
486
  OP_ID = "OP_INSTANCE_RENAME"
487
  __slots__ = [
488
    "instance_name", "ignore_ip", "new_name",
489
    ]
490

    
491

    
492
class OpStartupInstance(OpCode):
493
  """Startup an instance."""
494
  OP_ID = "OP_INSTANCE_STARTUP"
495
  OP_DSC_FIELD = "instance_name"
496
  __slots__ = [
497
    "instance_name", "force", "hvparams", "beparams",
498
    ]
499

    
500

    
501
class OpShutdownInstance(OpCode):
502
  """Shutdown an instance."""
503
  OP_ID = "OP_INSTANCE_SHUTDOWN"
504
  OP_DSC_FIELD = "instance_name"
505
  __slots__ = ["instance_name", "timeout"]
506

    
507

    
508
class OpRebootInstance(OpCode):
509
  """Reboot an instance."""
510
  OP_ID = "OP_INSTANCE_REBOOT"
511
  OP_DSC_FIELD = "instance_name"
512
  __slots__ = [
513
    "instance_name", "reboot_type", "ignore_secondaries", "shutdown_timeout",
514
    ]
515

    
516

    
517
class OpReplaceDisks(OpCode):
518
  """Replace the disks of an instance."""
519
  OP_ID = "OP_INSTANCE_REPLACE_DISKS"
520
  OP_DSC_FIELD = "instance_name"
521
  __slots__ = [
522
    "instance_name", "remote_node", "mode", "disks", "iallocator",
523
    "early_release",
524
    ]
525

    
526

    
527
class OpFailoverInstance(OpCode):
528
  """Failover an instance."""
529
  OP_ID = "OP_INSTANCE_FAILOVER"
530
  OP_DSC_FIELD = "instance_name"
531
  __slots__ = [
532
    "instance_name", "ignore_consistency", "shutdown_timeout",
533
    ]
534

    
535

    
536
class OpMigrateInstance(OpCode):
537
  """Migrate an instance.
538

539
  This migrates (without shutting down an instance) to its secondary
540
  node.
541

542
  @ivar instance_name: the name of the instance
543

544
  """
545
  OP_ID = "OP_INSTANCE_MIGRATE"
546
  OP_DSC_FIELD = "instance_name"
547
  __slots__ = ["instance_name", "live", "cleanup"]
548

    
549

    
550
class OpMoveInstance(OpCode):
551
  """Move an instance.
552

553
  This move (with shutting down an instance and data copying) to an
554
  arbitrary node.
555

556
  @ivar instance_name: the name of the instance
557
  @ivar target_node: the destination node
558

559
  """
560
  OP_ID = "OP_INSTANCE_MOVE"
561
  OP_DSC_FIELD = "instance_name"
562
  __slots__ = [
563
    "instance_name", "target_node", "shutdown_timeout",
564
    ]
565

    
566

    
567
class OpConnectConsole(OpCode):
568
  """Connect to an instance's console."""
569
  OP_ID = "OP_INSTANCE_CONSOLE"
570
  OP_DSC_FIELD = "instance_name"
571
  __slots__ = ["instance_name"]
572

    
573

    
574
class OpActivateInstanceDisks(OpCode):
575
  """Activate an instance's disks."""
576
  OP_ID = "OP_INSTANCE_ACTIVATE_DISKS"
577
  OP_DSC_FIELD = "instance_name"
578
  __slots__ = ["instance_name", "ignore_size"]
579

    
580

    
581
class OpDeactivateInstanceDisks(OpCode):
582
  """Deactivate an instance's disks."""
583
  OP_ID = "OP_INSTANCE_DEACTIVATE_DISKS"
584
  OP_DSC_FIELD = "instance_name"
585
  __slots__ = ["instance_name"]
586

    
587

    
588
class OpRecreateInstanceDisks(OpCode):
589
  """Deactivate an instance's disks."""
590
  OP_ID = "OP_INSTANCE_RECREATE_DISKS"
591
  OP_DSC_FIELD = "instance_name"
592
  __slots__ = ["instance_name", "disks"]
593

    
594

    
595
class OpQueryInstances(OpCode):
596
  """Compute the list of instances."""
597
  OP_ID = "OP_INSTANCE_QUERY"
598
  __slots__ = ["output_fields", "names", "use_locking"]
599

    
600

    
601
class OpQueryInstanceData(OpCode):
602
  """Compute the run-time status of instances."""
603
  OP_ID = "OP_INSTANCE_QUERY_DATA"
604
  __slots__ = ["instances", "static"]
605

    
606

    
607
class OpSetInstanceParams(OpCode):
608
  """Change the parameters of an instance."""
609
  OP_ID = "OP_INSTANCE_SET_PARAMS"
610
  OP_DSC_FIELD = "instance_name"
611
  __slots__ = [
612
    "instance_name",
613
    "hvparams", "beparams", "force",
614
    "nics", "disks",
615
    ]
616

    
617

    
618
class OpGrowDisk(OpCode):
619
  """Grow a disk of an instance."""
620
  OP_ID = "OP_INSTANCE_GROW_DISK"
621
  OP_DSC_FIELD = "instance_name"
622
  __slots__ = [
623
    "instance_name", "disk", "amount", "wait_for_sync",
624
    ]
625

    
626

    
627
# OS opcodes
628
class OpDiagnoseOS(OpCode):
629
  """Compute the list of guest operating systems."""
630
  OP_ID = "OP_OS_DIAGNOSE"
631
  __slots__ = ["output_fields", "names"]
632

    
633

    
634
# Exports opcodes
635
class OpQueryExports(OpCode):
636
  """Compute the list of exported images."""
637
  OP_ID = "OP_BACKUP_QUERY"
638
  __slots__ = ["nodes", "use_locking"]
639

    
640

    
641
class OpExportInstance(OpCode):
642
  """Export an instance."""
643
  OP_ID = "OP_BACKUP_EXPORT"
644
  OP_DSC_FIELD = "instance_name"
645
  __slots__ = [
646
    "instance_name", "target_node", "shutdown", "shutdown_timeout",
647
    ]
648

    
649

    
650
class OpRemoveExport(OpCode):
651
  """Remove an instance's export."""
652
  OP_ID = "OP_BACKUP_REMOVE"
653
  OP_DSC_FIELD = "instance_name"
654
  __slots__ = ["instance_name"]
655

    
656

    
657
# Tags opcodes
658
class OpGetTags(OpCode):
659
  """Returns the tags of the given object."""
660
  OP_ID = "OP_TAGS_GET"
661
  OP_DSC_FIELD = "name"
662
  __slots__ = ["kind", "name"]
663

    
664

    
665
class OpSearchTags(OpCode):
666
  """Searches the tags in the cluster for a given pattern."""
667
  OP_ID = "OP_TAGS_SEARCH"
668
  OP_DSC_FIELD = "pattern"
669
  __slots__ = ["pattern"]
670

    
671

    
672
class OpAddTags(OpCode):
673
  """Add a list of tags on a given object."""
674
  OP_ID = "OP_TAGS_SET"
675
  __slots__ = ["kind", "name", "tags"]
676

    
677

    
678
class OpDelTags(OpCode):
679
  """Remove a list of tags from a given object."""
680
  OP_ID = "OP_TAGS_DEL"
681
  __slots__ = ["kind", "name", "tags"]
682

    
683

    
684
# Test opcodes
685
class OpTestDelay(OpCode):
686
  """Sleeps for a configured amount of time.
687

688
  This is used just for debugging and testing.
689

690
  Parameters:
691
    - duration: the time to sleep
692
    - on_master: if true, sleep on the master
693
    - on_nodes: list of nodes in which to sleep
694

695
  If the on_master parameter is true, it will execute a sleep on the
696
  master (before any node sleep).
697

698
  If the on_nodes list is not empty, it will sleep on those nodes
699
  (after the sleep on the master, if that is enabled).
700

701
  As an additional feature, the case of duration < 0 will be reported
702
  as an execution error, so this opcode can be used as a failure
703
  generator. The case of duration == 0 will not be treated specially.
704

705
  """
706
  OP_ID = "OP_TEST_DELAY"
707
  OP_DSC_FIELD = "duration"
708
  __slots__ = ["duration", "on_master", "on_nodes"]
709

    
710

    
711
class OpTestAllocator(OpCode):
712
  """Allocator framework testing.
713

714
  This opcode has two modes:
715
    - gather and return allocator input for a given mode (allocate new
716
      or replace secondary) and a given instance definition (direction
717
      'in')
718
    - run a selected allocator for a given operation (as above) and
719
      return the allocator output (direction 'out')
720

721
  """
722
  OP_ID = "OP_TEST_ALLOCATOR"
723
  OP_DSC_FIELD = "allocator"
724
  __slots__ = [
725
    "direction", "mode", "allocator", "name",
726
    "mem_size", "disks", "disk_template",
727
    "os", "tags", "nics", "vcpus", "hypervisor",
728
    ]
729

    
730

    
731
OP_MAPPING = dict([(v.OP_ID, v) for v in globals().values()
732
                   if (isinstance(v, type) and issubclass(v, OpCode) and
733
                       hasattr(v, "OP_ID"))])