Statistics
| Branch: | Tag: | Revision:

root / lib / opcodes.py @ e69d05fd

History | View | Annotate | Download (14.9 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
               childre of this class.
107

108
  """
109
  OP_ID = "OP_ABSTRACT"
110
  __slots__ = []
111

    
112
  def __getstate__(self):
113
    """Specialized getstate for opcodes.
114

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

119
    @rtype:   C{dict}
120
    @return:  the state as a dictionary
121

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

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

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

135
    @type data:  C{dict}
136
    @param data: the serialized opcode
137

138
    """
139
    if not isinstance(data, dict):
140
      raise ValueError("Invalid data to LoadOpCode (%s)" % type(data))
141
    if "OP_ID" not in data:
142
      raise ValueError("Invalid data to LoadOpcode, missing OP_ID")
143
    op_id = data["OP_ID"]
144
    op_class = None
145
    for item in globals().values():
146
      if (isinstance(item, type) and
147
          issubclass(item, cls) and
148
          hasattr(item, "OP_ID") and
149
          getattr(item, "OP_ID") == op_id):
150
        op_class = item
151
        break
152
    if op_class is None:
153
      raise ValueError("Invalid data to LoadOpCode: OP_ID %s unsupported" %
154
                       op_id)
155
    op = op_class()
156
    new_data = data.copy()
157
    del new_data["OP_ID"]
158
    op.__setstate__(new_data)
159
    return op
160

    
161
  def Summary(self):
162
    """Generates a summary description of this opcode.
163

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

    
173

    
174
class OpDestroyCluster(OpCode):
175
  """Destroy the cluster.
176

177
  This opcode has no other parameters. All the state is irreversibly
178
  lost after the execution of this opcode.
179

180
  """
181
  OP_ID = "OP_CLUSTER_DESTROY"
182
  __slots__ = []
183

    
184

    
185
class OpQueryClusterInfo(OpCode):
186
  """Query cluster information."""
187
  OP_ID = "OP_CLUSTER_QUERY"
188
  __slots__ = []
189

    
190

    
191
class OpVerifyCluster(OpCode):
192
  """Verify the cluster state.
193

194
  @type skip_checks: C{list}
195
  @ivar skip_checks: steps to be skipped from the verify process; this
196
                     needs to be a subset of
197
                     L{constants.VERIFY_OPTIONAL_CHECKS}; currently
198
                     only L{constants.VERIFY_NPLUSONE_MEM} can be passed
199

200
  """
201
  OP_ID = "OP_CLUSTER_VERIFY"
202
  __slots__ = ["skip_checks"]
203

    
204

    
205
class OpVerifyDisks(OpCode):
206
  """Verify the cluster disks.
207

208
  Parameters: none
209

210
  Result: a tuple of four elements:
211
    - list of node names with bad data returned (unreachable, etc.)
212
    - dict of node names with broken volume groups (values: error msg)
213
    - list of instances with degraded disks (that should be activated)
214
    - dict of instances with missing logical volumes (values: (node, vol)
215
      pairs with details about the missing volumes)
216

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

222
  Note that only instances that are drbd-based are taken into
223
  consideration. This might need to be revisited in the future.
224

225
  """
226
  OP_ID = "OP_CLUSTER_VERIFY_DISKS"
227
  __slots__ = []
228

    
229

    
230
class OpQueryConfigValues(OpCode):
231
  """Query cluster configuration values."""
232
  OP_ID = "OP_CLUSTER_CONFIG_QUERY"
233
  __slots__ = ["output_fields"]
234

    
235

    
236
class OpRenameCluster(OpCode):
237
  """Rename the cluster.
238

239
  @type name: C{str}
240
  @ivar name: The new name of the cluster. The name and/or the master IP
241
              address will be changed to match the new name and its IP
242
              address.
243

244
  """
245
  OP_ID = "OP_CLUSTER_RENAME"
246
  OP_DSC_FIELD = "name"
247
  __slots__ = ["name"]
248

    
249

    
250
class OpSetClusterParams(OpCode):
251
  """Change the parameters of the cluster.
252

253
  @type vg_name: C{str} or C{None}
254
  @ivar vg_name: The new volume group name or None to disable LVM usage.
255

256
  """
257
  OP_ID = "OP_CLUSTER_SET_PARAMS"
258
  __slots__ = ["vg_name"]
259

    
260

    
261
# node opcodes
262

    
263
class OpRemoveNode(OpCode):
264
  """Remove a node.
265

266
  @type node_name: C{str}
267
  @ivar node_name: The name of the node to remove. If the node still has
268
                   instances on it, the operation will fail.
269

270
  """
271
  OP_ID = "OP_NODE_REMOVE"
272
  OP_DSC_FIELD = "node_name"
273
  __slots__ = ["node_name"]
274

    
275

    
276
class OpAddNode(OpCode):
277
  """Add a node to the cluster.
278

279
  @type node_name: C{str}
280
  @ivar node_name: The name of the node to add. This can be a short name,
281
                   but it will be expanded to the FQDN.
282
  @type primary_ip: IP address
283
  @ivar primary_ip: The primary IP of the node. This will be ignored when the
284
                    opcode is submitted, but will be filled during the node
285
                    add (so it will be visible in the job query).
286
  @type secondary_ip: IP address
287
  @ivar secondary_ip: The secondary IP of the node. This needs to be passed
288
                      if the cluster has been initialized in 'dual-network'
289
                      mode, otherwise it must not be given.
290
  @type readd: C{bool}
291
  @ivar readd: Whether to re-add an existing node to the cluster. If
292
               this is not passed, then the operation will abort if the node
293
               name is already in the cluster; use this parameter to 'repair'
294
               a node that had its configuration broken, or was reinstalled
295
               without removal from the cluster.
296

297
  """
298
  OP_ID = "OP_NODE_ADD"
299
  OP_DSC_FIELD = "node_name"
300
  __slots__ = ["node_name", "primary_ip", "secondary_ip", "readd"]
301

    
302

    
303
class OpQueryNodes(OpCode):
304
  """Compute the list of nodes."""
305
  OP_ID = "OP_NODE_QUERY"
306
  __slots__ = ["output_fields", "names"]
307

    
308

    
309
class OpQueryNodeVolumes(OpCode):
310
  """Get list of volumes on node."""
311
  OP_ID = "OP_NODE_QUERYVOLS"
312
  __slots__ = ["nodes", "output_fields"]
313

    
314

    
315
# instance opcodes
316

    
317
class OpCreateInstance(OpCode):
318
  """Create an instance."""
319
  OP_ID = "OP_INSTANCE_CREATE"
320
  OP_DSC_FIELD = "instance_name"
321
  __slots__ = [
322
    "instance_name", "mem_size", "disk_size", "os_type", "pnode",
323
    "disk_template", "snode", "swap_size", "mode",
324
    "vcpus", "ip", "bridge", "src_node", "src_path", "start",
325
    "wait_for_sync", "ip_check", "mac",
326
    "kernel_path", "initrd_path", "hvm_boot_order", "hvm_acpi",
327
    "hvm_pae", "hvm_cdrom_image_path", "vnc_bind_address",
328
    "file_storage_dir", "file_driver",
329
    "iallocator", "hvm_nic_type", "hvm_disk_type",
330
    "hypervisor",
331
    ]
332

    
333

    
334
class OpReinstallInstance(OpCode):
335
  """Reinstall an instance's OS."""
336
  OP_ID = "OP_INSTANCE_REINSTALL"
337
  OP_DSC_FIELD = "instance_name"
338
  __slots__ = ["instance_name", "os_type"]
339

    
340

    
341
class OpRemoveInstance(OpCode):
342
  """Remove an instance."""
343
  OP_ID = "OP_INSTANCE_REMOVE"
344
  OP_DSC_FIELD = "instance_name"
345
  __slots__ = ["instance_name", "ignore_failures"]
346

    
347

    
348
class OpRenameInstance(OpCode):
349
  """Rename an instance."""
350
  OP_ID = "OP_INSTANCE_RENAME"
351
  __slots__ = ["instance_name", "ignore_ip", "new_name"]
352

    
353

    
354
class OpStartupInstance(OpCode):
355
  """Startup an instance."""
356
  OP_ID = "OP_INSTANCE_STARTUP"
357
  OP_DSC_FIELD = "instance_name"
358
  __slots__ = ["instance_name", "force", "extra_args"]
359

    
360

    
361
class OpShutdownInstance(OpCode):
362
  """Shutdown an instance."""
363
  OP_ID = "OP_INSTANCE_SHUTDOWN"
364
  OP_DSC_FIELD = "instance_name"
365
  __slots__ = ["instance_name"]
366

    
367

    
368
class OpRebootInstance(OpCode):
369
  """Reboot an instance."""
370
  OP_ID = "OP_INSTANCE_REBOOT"
371
  OP_DSC_FIELD = "instance_name"
372
  __slots__ = ["instance_name", "reboot_type", "extra_args",
373
               "ignore_secondaries" ]
374

    
375

    
376
class OpReplaceDisks(OpCode):
377
  """Replace the disks of an instance."""
378
  OP_ID = "OP_INSTANCE_REPLACE_DISKS"
379
  OP_DSC_FIELD = "instance_name"
380
  __slots__ = ["instance_name", "remote_node", "mode", "disks", "iallocator"]
381

    
382

    
383
class OpFailoverInstance(OpCode):
384
  """Failover an instance."""
385
  OP_ID = "OP_INSTANCE_FAILOVER"
386
  OP_DSC_FIELD = "instance_name"
387
  __slots__ = ["instance_name", "ignore_consistency"]
388

    
389

    
390
class OpConnectConsole(OpCode):
391
  """Connect to an instance's console."""
392
  OP_ID = "OP_INSTANCE_CONSOLE"
393
  OP_DSC_FIELD = "instance_name"
394
  __slots__ = ["instance_name"]
395

    
396

    
397
class OpActivateInstanceDisks(OpCode):
398
  """Activate an instance's disks."""
399
  OP_ID = "OP_INSTANCE_ACTIVATE_DISKS"
400
  OP_DSC_FIELD = "instance_name"
401
  __slots__ = ["instance_name"]
402

    
403

    
404
class OpDeactivateInstanceDisks(OpCode):
405
  """Deactivate an instance's disks."""
406
  OP_ID = "OP_INSTANCE_DEACTIVATE_DISKS"
407
  OP_DSC_FIELD = "instance_name"
408
  __slots__ = ["instance_name"]
409

    
410

    
411
class OpQueryInstances(OpCode):
412
  """Compute the list of instances."""
413
  OP_ID = "OP_INSTANCE_QUERY"
414
  __slots__ = ["output_fields", "names"]
415

    
416

    
417
class OpQueryInstanceData(OpCode):
418
  """Compute the run-time status of instances."""
419
  OP_ID = "OP_INSTANCE_QUERY_DATA"
420
  __slots__ = ["instances"]
421

    
422

    
423
class OpSetInstanceParams(OpCode):
424
  """Change the parameters of an instance."""
425
  OP_ID = "OP_INSTANCE_SET_PARAMS"
426
  OP_DSC_FIELD = "instance_name"
427
  __slots__ = [
428
    "instance_name", "mem", "vcpus", "ip", "bridge", "mac",
429
    "kernel_path", "initrd_path", "hvm_boot_order", "hvm_acpi",
430
    "hvm_pae", "hvm_cdrom_image_path", "vnc_bind_address",
431
    "hvm_nic_type", "hvm_disk_type", "force"
432
    ]
433

    
434

    
435
class OpGrowDisk(OpCode):
436
  """Grow a disk of an instance."""
437
  OP_ID = "OP_INSTANCE_GROW_DISK"
438
  OP_DSC_FIELD = "instance_name"
439
  __slots__ = ["instance_name", "disk", "amount"]
440

    
441

    
442
# OS opcodes
443
class OpDiagnoseOS(OpCode):
444
  """Compute the list of guest operating systems."""
445
  OP_ID = "OP_OS_DIAGNOSE"
446
  __slots__ = ["output_fields", "names"]
447

    
448

    
449
# Exports opcodes
450
class OpQueryExports(OpCode):
451
  """Compute the list of exported images."""
452
  OP_ID = "OP_BACKUP_QUERY"
453
  __slots__ = ["nodes"]
454

    
455

    
456
class OpExportInstance(OpCode):
457
  """Export an instance."""
458
  OP_ID = "OP_BACKUP_EXPORT"
459
  OP_DSC_FIELD = "instance_name"
460
  __slots__ = ["instance_name", "target_node", "shutdown"]
461

    
462

    
463
class OpRemoveExport(OpCode):
464
  """Remove an instance's export."""
465
  OP_ID = "OP_BACKUP_REMOVE"
466
  OP_DSC_FIELD = "instance_name"
467
  __slots__ = ["instance_name"]
468

    
469

    
470
# Tags opcodes
471
class OpGetTags(OpCode):
472
  """Returns the tags of the given object."""
473
  OP_ID = "OP_TAGS_GET"
474
  OP_DSC_FIELD = "name"
475
  __slots__ = ["kind", "name"]
476

    
477

    
478
class OpSearchTags(OpCode):
479
  """Searches the tags in the cluster for a given pattern."""
480
  OP_ID = "OP_TAGS_SEARCH"
481
  OP_DSC_FIELD = "pattern"
482
  __slots__ = ["pattern"]
483

    
484

    
485
class OpAddTags(OpCode):
486
  """Add a list of tags on a given object."""
487
  OP_ID = "OP_TAGS_SET"
488
  __slots__ = ["kind", "name", "tags"]
489

    
490

    
491
class OpDelTags(OpCode):
492
  """Remove a list of tags from a given object."""
493
  OP_ID = "OP_TAGS_DEL"
494
  __slots__ = ["kind", "name", "tags"]
495

    
496

    
497
# Test opcodes
498
class OpTestDelay(OpCode):
499
  """Sleeps for a configured amount of time.
500

501
  This is used just for debugging and testing.
502

503
  Parameters:
504
    - duration: the time to sleep
505
    - on_master: if true, sleep on the master
506
    - on_nodes: list of nodes in which to sleep
507

508
  If the on_master parameter is true, it will execute a sleep on the
509
  master (before any node sleep).
510

511
  If the on_nodes list is not empty, it will sleep on those nodes
512
  (after the sleep on the master, if that is enabled).
513

514
  As an additional feature, the case of duration < 0 will be reported
515
  as an execution error, so this opcode can be used as a failure
516
  generator. The case of duration == 0 will not be treated specially.
517

518
  """
519
  OP_ID = "OP_TEST_DELAY"
520
  OP_DSC_FIELD = "duration"
521
  __slots__ = ["duration", "on_master", "on_nodes"]
522

    
523

    
524
class OpTestAllocator(OpCode):
525
  """Allocator framework testing.
526

527
  This opcode has two modes:
528
    - gather and return allocator input for a given mode (allocate new
529
      or replace secondary) and a given instance definition (direction
530
      'in')
531
    - run a selected allocator for a given operation (as above) and
532
      return the allocator output (direction 'out')
533

534
  """
535
  OP_ID = "OP_TEST_ALLOCATOR"
536
  OP_DSC_FIELD = "allocator"
537
  __slots__ = [
538
    "direction", "mode", "allocator", "name",
539
    "mem_size", "disks", "disk_template",
540
    "os", "tags", "nics", "vcpus",
541
    ]