Statistics
| Branch: | Tag: | Revision:

root / lib / opcodes.py @ 099c52ad

History | View | Annotate | Download (19.3 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
    for key in kwargs:
56
      if key not in self.__slots__:
57
        raise TypeError("Object %s doesn't support the parameter '%s'" %
58
                        (self.__class__.__name__, key))
59
      setattr(self, key, kwargs[key])
60

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

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

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

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

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

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

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

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

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

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

    
98

    
99
class OpCode(BaseOpCode):
100
  """Abstract OpCode.
101

102
  This is the root of the actual OpCode hierarchy. All clases derived
103
  from this class should override OP_ID.
104

105
  @cvar OP_ID: The ID of this opcode. This should be unique amongst all
106
               children of this class.
107
  @ivar dry_run: Whether the LU should be run in dry-run mode, i.e. just
108
                 the check steps
109

110
  """
111
  OP_ID = "OP_ABSTRACT"
112
  __slots__ = BaseOpCode.__slots__ + ["dry_run"]
113

    
114
  def __getstate__(self):
115
    """Specialized getstate for opcodes.
116

117
    This method adds to the state dictionary the OP_ID of the class,
118
    so that on unload we can identify the correct class for
119
    instantiating the opcode.
120

121
    @rtype:   C{dict}
122
    @return:  the state as a dictionary
123

124
    """
125
    data = BaseOpCode.__getstate__(self)
126
    data["OP_ID"] = self.OP_ID
127
    return data
128

    
129
  @classmethod
130
  def LoadOpCode(cls, data):
131
    """Generic load opcode method.
132

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

137
    @type data:  C{dict}
138
    @param data: the serialized opcode
139

140
    """
141
    if not isinstance(data, dict):
142
      raise ValueError("Invalid data to LoadOpCode (%s)" % type(data))
143
    if "OP_ID" not in data:
144
      raise ValueError("Invalid data to LoadOpcode, missing OP_ID")
145
    op_id = data["OP_ID"]
146
    op_class = None
147
    if op_id in OP_MAPPING:
148
      op_class = OP_MAPPING[op_id]
149
    else:
150
      raise ValueError("Invalid data to LoadOpCode: OP_ID %s unsupported" %
151
                       op_id)
152
    op = op_class()
153
    new_data = data.copy()
154
    del new_data["OP_ID"]
155
    op.__setstate__(new_data)
156
    return op
157

    
158
  def Summary(self):
159
    """Generates a summary description of this opcode.
160

161
    """
162
    # all OP_ID start with OP_, we remove that
163
    txt = self.OP_ID[3:]
164
    field_name = getattr(self, "OP_DSC_FIELD", None)
165
    if field_name:
166
      field_value = getattr(self, field_name, None)
167
      txt = "%s(%s)" % (txt, field_value)
168
    return txt
169

    
170

    
171
# cluster opcodes
172

    
173
class OpPostInitCluster(OpCode):
174
  """Post cluster initialization.
175

176
  This opcode does not touch the cluster at all. Its purpose is to run hooks
177
  after the cluster has been initialized.
178

179
  """
180
  OP_ID = "OP_CLUSTER_POST_INIT"
181
  __slots__ = OpCode.__slots__ + []
182

    
183

    
184
class OpDestroyCluster(OpCode):
185
  """Destroy the cluster.
186

187
  This opcode has no other parameters. All the state is irreversibly
188
  lost after the execution of this opcode.
189

190
  """
191
  OP_ID = "OP_CLUSTER_DESTROY"
192
  __slots__ = OpCode.__slots__ + []
193

    
194

    
195
class OpQueryClusterInfo(OpCode):
196
  """Query cluster information."""
197
  OP_ID = "OP_CLUSTER_QUERY"
198
  __slots__ = OpCode.__slots__ + []
199

    
200

    
201
class OpVerifyCluster(OpCode):
202
  """Verify the cluster state.
203

204
  @type skip_checks: C{list}
205
  @ivar skip_checks: steps to be skipped from the verify process; this
206
                     needs to be a subset of
207
                     L{constants.VERIFY_OPTIONAL_CHECKS}; currently
208
                     only L{constants.VERIFY_NPLUSONE_MEM} can be passed
209

210
  """
211
  OP_ID = "OP_CLUSTER_VERIFY"
212
  __slots__ = OpCode.__slots__ + ["skip_checks", "verbose", "error_codes",
213
                                  "debug_simulate_errors"]
214

    
215

    
216
class OpVerifyDisks(OpCode):
217
  """Verify the cluster disks.
218

219
  Parameters: none
220

221
  Result: a tuple of four elements:
222
    - list of node names with bad data returned (unreachable, etc.)
223
    - dict of node names with broken volume groups (values: error msg)
224
    - list of instances with degraded disks (that should be activated)
225
    - dict of instances with missing logical volumes (values: (node, vol)
226
      pairs with details about the missing volumes)
227

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

233
  Note that only instances that are drbd-based are taken into
234
  consideration. This might need to be revisited in the future.
235

236
  """
237
  OP_ID = "OP_CLUSTER_VERIFY_DISKS"
238
  __slots__ = OpCode.__slots__ + []
239

    
240

    
241
class OpRepairDiskSizes(OpCode):
242
  """Verify the disk sizes of the instances and fixes configuration
243
  mimatches.
244

245
  Parameters: optional instances list, in case we want to restrict the
246
  checks to only a subset of the instances.
247

248
  Result: a list of tuples, (instance, disk, new-size) for changed
249
  configurations.
250

251
  In normal operation, the list should be empty.
252

253
  @type instances: list
254
  @ivar instances: the list of instances to check, or empty for all instances
255

256
  """
257
  OP_ID = "OP_CLUSTER_REPAIR_DISK_SIZES"
258
  __slots__ = ["instances"]
259

    
260

    
261
class OpQueryConfigValues(OpCode):
262
  """Query cluster configuration values."""
263
  OP_ID = "OP_CLUSTER_CONFIG_QUERY"
264
  __slots__ = OpCode.__slots__ + ["output_fields"]
265

    
266

    
267
class OpRenameCluster(OpCode):
268
  """Rename the cluster.
269

270
  @type name: C{str}
271
  @ivar name: The new name of the cluster. The name and/or the master IP
272
              address will be changed to match the new name and its IP
273
              address.
274

275
  """
276
  OP_ID = "OP_CLUSTER_RENAME"
277
  OP_DSC_FIELD = "name"
278
  __slots__ = OpCode.__slots__ + ["name"]
279

    
280

    
281
class OpSetClusterParams(OpCode):
282
  """Change the parameters of the cluster.
283

284
  @type vg_name: C{str} or C{None}
285
  @ivar vg_name: The new volume group name or None to disable LVM usage.
286

287
  """
288
  OP_ID = "OP_CLUSTER_SET_PARAMS"
289
  __slots__ = OpCode.__slots__ + [
290
    "vg_name",
291
    "enabled_hypervisors",
292
    "hvparams",
293
    "beparams",
294
    "nicparams",
295
    "candidate_pool_size",
296
    ]
297

    
298

    
299
class OpRedistributeConfig(OpCode):
300
  """Force a full push of the cluster configuration.
301

302
  """
303
  OP_ID = "OP_CLUSTER_REDIST_CONF"
304
  __slots__ = OpCode.__slots__ + [
305
    ]
306

    
307
# node opcodes
308

    
309
class OpRemoveNode(OpCode):
310
  """Remove a node.
311

312
  @type node_name: C{str}
313
  @ivar node_name: The name of the node to remove. If the node still has
314
                   instances on it, the operation will fail.
315

316
  """
317
  OP_ID = "OP_NODE_REMOVE"
318
  OP_DSC_FIELD = "node_name"
319
  __slots__ = OpCode.__slots__ + ["node_name"]
320

    
321

    
322
class OpAddNode(OpCode):
323
  """Add a node to the cluster.
324

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

343
  """
344
  OP_ID = "OP_NODE_ADD"
345
  OP_DSC_FIELD = "node_name"
346
  __slots__ = OpCode.__slots__ + [
347
    "node_name", "primary_ip", "secondary_ip", "readd",
348
    ]
349

    
350

    
351
class OpQueryNodes(OpCode):
352
  """Compute the list of nodes."""
353
  OP_ID = "OP_NODE_QUERY"
354
  __slots__ = OpCode.__slots__ + ["output_fields", "names", "use_locking"]
355

    
356

    
357
class OpQueryNodeVolumes(OpCode):
358
  """Get list of volumes on node."""
359
  OP_ID = "OP_NODE_QUERYVOLS"
360
  __slots__ = OpCode.__slots__ + ["nodes", "output_fields"]
361

    
362

    
363
class OpQueryNodeStorage(OpCode):
364
  """Get information on storage for node(s)."""
365
  OP_ID = "OP_NODE_QUERY_STORAGE"
366
  __slots__ = OpCode.__slots__ + [
367
    "nodes",
368
    "storage_type",
369
    "name",
370
    "output_fields",
371
    ]
372

    
373

    
374
class OpModifyNodeStorage(OpCode):
375
  """Modifies the properies of a storage unit"""
376
  OP_ID = "OP_NODE_MODIFY_STORAGE"
377
  __slots__ = OpCode.__slots__ + [
378
    "node_name",
379
    "storage_type",
380
    "name",
381
    "changes",
382
    ]
383

    
384

    
385
class OpRepairNodeStorage(OpCode):
386
  """Repairs the volume group on a node."""
387
  OP_ID = "OP_REPAIR_NODE_STORAGE"
388
  OP_DSC_FIELD = "node_name"
389
  __slots__ = OpCode.__slots__ + [
390
    "node_name",
391
    "storage_type",
392
    "name",
393
    "ignore_consistency",
394
    ]
395

    
396

    
397
class OpSetNodeParams(OpCode):
398
  """Change the parameters of a node."""
399
  OP_ID = "OP_NODE_SET_PARAMS"
400
  OP_DSC_FIELD = "node_name"
401
  __slots__ = OpCode.__slots__ + [
402
    "node_name",
403
    "force",
404
    "master_candidate",
405
    "offline",
406
    "drained",
407
    ]
408

    
409

    
410
class OpPowercycleNode(OpCode):
411
  """Tries to powercycle a node."""
412
  OP_ID = "OP_NODE_POWERCYCLE"
413
  OP_DSC_FIELD = "node_name"
414
  __slots__ = OpCode.__slots__ + [
415
    "node_name",
416
    "force",
417
    ]
418

    
419

    
420
class OpEvacuateNode(OpCode):
421
  """Relocate secondary instances from a node."""
422
  OP_ID = "OP_NODE_EVACUATE"
423
  OP_DSC_FIELD = "node_name"
424
  __slots__ = OpCode.__slots__ + [
425
    "node_name", "remote_node", "iallocator",
426
    ]
427

    
428

    
429
class OpMigrateNode(OpCode):
430
  """Migrate all instances from a node."""
431
  OP_ID = "OP_NODE_MIGRATE"
432
  OP_DSC_FIELD = "node_name"
433
  __slots__ = OpCode.__slots__ + [
434
    "node_name",
435
    "live",
436
    ]
437

    
438

    
439
# instance opcodes
440

    
441
class OpCreateInstance(OpCode):
442
  """Create an instance."""
443
  OP_ID = "OP_INSTANCE_CREATE"
444
  OP_DSC_FIELD = "instance_name"
445
  __slots__ = OpCode.__slots__ + [
446
    "instance_name", "os_type", "force_variant",
447
    "pnode", "disk_template", "snode", "mode",
448
    "disks", "nics",
449
    "src_node", "src_path", "start",
450
    "wait_for_sync", "ip_check",
451
    "file_storage_dir", "file_driver",
452
    "iallocator",
453
    "hypervisor", "hvparams", "beparams",
454
    "dry_run",
455
    ]
456

    
457

    
458
class OpReinstallInstance(OpCode):
459
  """Reinstall an instance's OS."""
460
  OP_ID = "OP_INSTANCE_REINSTALL"
461
  OP_DSC_FIELD = "instance_name"
462
  __slots__ = OpCode.__slots__ + ["instance_name", "os_type", "force_variant"]
463

    
464

    
465
class OpRemoveInstance(OpCode):
466
  """Remove an instance."""
467
  OP_ID = "OP_INSTANCE_REMOVE"
468
  OP_DSC_FIELD = "instance_name"
469
  __slots__ = OpCode.__slots__ + [
470
    "instance_name",
471
    "ignore_failures",
472
    "shutdown_timeout",
473
    ]
474

    
475

    
476
class OpRenameInstance(OpCode):
477
  """Rename an instance."""
478
  OP_ID = "OP_INSTANCE_RENAME"
479
  __slots__ = OpCode.__slots__ + [
480
    "instance_name", "ignore_ip", "new_name",
481
    ]
482

    
483

    
484
class OpStartupInstance(OpCode):
485
  """Startup an instance."""
486
  OP_ID = "OP_INSTANCE_STARTUP"
487
  OP_DSC_FIELD = "instance_name"
488
  __slots__ = OpCode.__slots__ + [
489
    "instance_name", "force", "hvparams", "beparams",
490
    ]
491

    
492

    
493
class OpShutdownInstance(OpCode):
494
  """Shutdown an instance."""
495
  OP_ID = "OP_INSTANCE_SHUTDOWN"
496
  OP_DSC_FIELD = "instance_name"
497
  __slots__ = OpCode.__slots__ + ["instance_name", "timeout"]
498

    
499

    
500
class OpRebootInstance(OpCode):
501
  """Reboot an instance."""
502
  OP_ID = "OP_INSTANCE_REBOOT"
503
  OP_DSC_FIELD = "instance_name"
504
  __slots__ = OpCode.__slots__ + [
505
    "instance_name", "reboot_type", "ignore_secondaries", "shutdown_timeout",
506
    ]
507

    
508

    
509
class OpReplaceDisks(OpCode):
510
  """Replace the disks of an instance."""
511
  OP_ID = "OP_INSTANCE_REPLACE_DISKS"
512
  OP_DSC_FIELD = "instance_name"
513
  __slots__ = OpCode.__slots__ + [
514
    "instance_name", "remote_node", "mode", "disks", "iallocator",
515
    ]
516

    
517

    
518
class OpFailoverInstance(OpCode):
519
  """Failover an instance."""
520
  OP_ID = "OP_INSTANCE_FAILOVER"
521
  OP_DSC_FIELD = "instance_name"
522
  __slots__ = OpCode.__slots__ + [
523
    "instance_name", "ignore_consistency", "shutdown_timeout",
524
    ]
525

    
526

    
527
class OpMigrateInstance(OpCode):
528
  """Migrate an instance.
529

530
  This migrates (without shutting down an instance) to its secondary
531
  node.
532

533
  @ivar instance_name: the name of the instance
534

535
  """
536
  OP_ID = "OP_INSTANCE_MIGRATE"
537
  OP_DSC_FIELD = "instance_name"
538
  __slots__ = OpCode.__slots__ + ["instance_name", "live", "cleanup"]
539

    
540

    
541
class OpMoveInstance(OpCode):
542
  """Move an instance.
543

544
  This move (with shutting down an instance and data copying) to an
545
  arbitrary node.
546

547
  @ivar instance_name: the name of the instance
548
  @ivar target_node: the destination node
549

550
  """
551
  OP_ID = "OP_INSTANCE_MOVE"
552
  OP_DSC_FIELD = "instance_name"
553
  __slots__ = OpCode.__slots__ + [
554
    "instance_name", "target_node", "shutdown_timeout",
555
  ]
556

    
557

    
558
class OpConnectConsole(OpCode):
559
  """Connect to an instance's console."""
560
  OP_ID = "OP_INSTANCE_CONSOLE"
561
  OP_DSC_FIELD = "instance_name"
562
  __slots__ = OpCode.__slots__ + ["instance_name"]
563

    
564

    
565
class OpActivateInstanceDisks(OpCode):
566
  """Activate an instance's disks."""
567
  OP_ID = "OP_INSTANCE_ACTIVATE_DISKS"
568
  OP_DSC_FIELD = "instance_name"
569
  __slots__ = OpCode.__slots__ + ["instance_name", "ignore_size"]
570

    
571

    
572
class OpDeactivateInstanceDisks(OpCode):
573
  """Deactivate an instance's disks."""
574
  OP_ID = "OP_INSTANCE_DEACTIVATE_DISKS"
575
  OP_DSC_FIELD = "instance_name"
576
  __slots__ = OpCode.__slots__ + ["instance_name"]
577

    
578

    
579
class OpRecreateInstanceDisks(OpCode):
580
  """Deactivate an instance's disks."""
581
  OP_ID = "OP_INSTANCE_RECREATE_DISKS"
582
  OP_DSC_FIELD = "instance_name"
583
  __slots__ = OpCode.__slots__ + ["instance_name", "disks"]
584

    
585

    
586
class OpQueryInstances(OpCode):
587
  """Compute the list of instances."""
588
  OP_ID = "OP_INSTANCE_QUERY"
589
  __slots__ = OpCode.__slots__ + ["output_fields", "names", "use_locking"]
590

    
591

    
592
class OpQueryInstanceData(OpCode):
593
  """Compute the run-time status of instances."""
594
  OP_ID = "OP_INSTANCE_QUERY_DATA"
595
  __slots__ = OpCode.__slots__ + ["instances", "static"]
596

    
597

    
598
class OpSetInstanceParams(OpCode):
599
  """Change the parameters of an instance."""
600
  OP_ID = "OP_INSTANCE_SET_PARAMS"
601
  OP_DSC_FIELD = "instance_name"
602
  __slots__ = OpCode.__slots__ + [
603
    "instance_name",
604
    "hvparams", "beparams", "force",
605
    "nics", "disks",
606
    ]
607

    
608

    
609
class OpGrowDisk(OpCode):
610
  """Grow a disk of an instance."""
611
  OP_ID = "OP_INSTANCE_GROW_DISK"
612
  OP_DSC_FIELD = "instance_name"
613
  __slots__ = OpCode.__slots__ + [
614
    "instance_name", "disk", "amount", "wait_for_sync",
615
    ]
616

    
617

    
618
# OS opcodes
619
class OpDiagnoseOS(OpCode):
620
  """Compute the list of guest operating systems."""
621
  OP_ID = "OP_OS_DIAGNOSE"
622
  __slots__ = OpCode.__slots__ + ["output_fields", "names"]
623

    
624

    
625
# Exports opcodes
626
class OpQueryExports(OpCode):
627
  """Compute the list of exported images."""
628
  OP_ID = "OP_BACKUP_QUERY"
629
  __slots__ = OpCode.__slots__ + ["nodes", "use_locking"]
630

    
631

    
632
class OpExportInstance(OpCode):
633
  """Export an instance."""
634
  OP_ID = "OP_BACKUP_EXPORT"
635
  OP_DSC_FIELD = "instance_name"
636
  __slots__ = OpCode.__slots__ + [
637
    "instance_name", "target_node", "shutdown", "shutdown_timeout",
638
    ]
639

    
640

    
641
class OpRemoveExport(OpCode):
642
  """Remove an instance's export."""
643
  OP_ID = "OP_BACKUP_REMOVE"
644
  OP_DSC_FIELD = "instance_name"
645
  __slots__ = OpCode.__slots__ + ["instance_name"]
646

    
647

    
648
# Tags opcodes
649
class OpGetTags(OpCode):
650
  """Returns the tags of the given object."""
651
  OP_ID = "OP_TAGS_GET"
652
  OP_DSC_FIELD = "name"
653
  __slots__ = OpCode.__slots__ + ["kind", "name"]
654

    
655

    
656
class OpSearchTags(OpCode):
657
  """Searches the tags in the cluster for a given pattern."""
658
  OP_ID = "OP_TAGS_SEARCH"
659
  OP_DSC_FIELD = "pattern"
660
  __slots__ = OpCode.__slots__ + ["pattern"]
661

    
662

    
663
class OpAddTags(OpCode):
664
  """Add a list of tags on a given object."""
665
  OP_ID = "OP_TAGS_SET"
666
  __slots__ = OpCode.__slots__ + ["kind", "name", "tags"]
667

    
668

    
669
class OpDelTags(OpCode):
670
  """Remove a list of tags from a given object."""
671
  OP_ID = "OP_TAGS_DEL"
672
  __slots__ = OpCode.__slots__ + ["kind", "name", "tags"]
673

    
674

    
675
# Test opcodes
676
class OpTestDelay(OpCode):
677
  """Sleeps for a configured amount of time.
678

679
  This is used just for debugging and testing.
680

681
  Parameters:
682
    - duration: the time to sleep
683
    - on_master: if true, sleep on the master
684
    - on_nodes: list of nodes in which to sleep
685

686
  If the on_master parameter is true, it will execute a sleep on the
687
  master (before any node sleep).
688

689
  If the on_nodes list is not empty, it will sleep on those nodes
690
  (after the sleep on the master, if that is enabled).
691

692
  As an additional feature, the case of duration < 0 will be reported
693
  as an execution error, so this opcode can be used as a failure
694
  generator. The case of duration == 0 will not be treated specially.
695

696
  """
697
  OP_ID = "OP_TEST_DELAY"
698
  OP_DSC_FIELD = "duration"
699
  __slots__ = OpCode.__slots__ + ["duration", "on_master", "on_nodes"]
700

    
701

    
702
class OpTestAllocator(OpCode):
703
  """Allocator framework testing.
704

705
  This opcode has two modes:
706
    - gather and return allocator input for a given mode (allocate new
707
      or replace secondary) and a given instance definition (direction
708
      'in')
709
    - run a selected allocator for a given operation (as above) and
710
      return the allocator output (direction 'out')
711

712
  """
713
  OP_ID = "OP_TEST_ALLOCATOR"
714
  OP_DSC_FIELD = "allocator"
715
  __slots__ = OpCode.__slots__ + [
716
    "direction", "mode", "allocator", "name",
717
    "mem_size", "disks", "disk_template",
718
    "os", "tags", "nics", "vcpus", "hypervisor",
719
    ]
720

    
721

    
722
OP_MAPPING = dict([(v.OP_ID, v) for v in globals().values()
723
                   if (isinstance(v, type) and issubclass(v, OpCode) and
724
                       hasattr(v, "OP_ID"))])