Statistics
| Branch: | Tag: | Revision:

root / lib / opcodes.py @ 74409b12

History | View | Annotate | Download (14.6 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
    "file_storage_dir", "file_driver",
327
    "iallocator",
328
    "hypervisor", "hvparams", "beparams",
329
    ]
330

    
331

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

    
338

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

    
345

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

    
351

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

    
358

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

    
365

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

    
373

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

    
380

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

    
387

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

    
394

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

    
401

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

    
408

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

    
414

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

    
420

    
421
class OpSetInstanceParams(OpCode):
422
  """Change the parameters of an instance."""
423
  OP_ID = "OP_INSTANCE_SET_PARAMS"
424
  OP_DSC_FIELD = "instance_name"
425
  __slots__ = [
426
    "instance_name", "mem", "vcpus", "ip", "bridge", "mac",
427
    "hvparams", "force",
428
    ]
429

    
430

    
431
class OpGrowDisk(OpCode):
432
  """Grow a disk of an instance."""
433
  OP_ID = "OP_INSTANCE_GROW_DISK"
434
  OP_DSC_FIELD = "instance_name"
435
  __slots__ = ["instance_name", "disk", "amount"]
436

    
437

    
438
# OS opcodes
439
class OpDiagnoseOS(OpCode):
440
  """Compute the list of guest operating systems."""
441
  OP_ID = "OP_OS_DIAGNOSE"
442
  __slots__ = ["output_fields", "names"]
443

    
444

    
445
# Exports opcodes
446
class OpQueryExports(OpCode):
447
  """Compute the list of exported images."""
448
  OP_ID = "OP_BACKUP_QUERY"
449
  __slots__ = ["nodes"]
450

    
451

    
452
class OpExportInstance(OpCode):
453
  """Export an instance."""
454
  OP_ID = "OP_BACKUP_EXPORT"
455
  OP_DSC_FIELD = "instance_name"
456
  __slots__ = ["instance_name", "target_node", "shutdown"]
457

    
458

    
459
class OpRemoveExport(OpCode):
460
  """Remove an instance's export."""
461
  OP_ID = "OP_BACKUP_REMOVE"
462
  OP_DSC_FIELD = "instance_name"
463
  __slots__ = ["instance_name"]
464

    
465

    
466
# Tags opcodes
467
class OpGetTags(OpCode):
468
  """Returns the tags of the given object."""
469
  OP_ID = "OP_TAGS_GET"
470
  OP_DSC_FIELD = "name"
471
  __slots__ = ["kind", "name"]
472

    
473

    
474
class OpSearchTags(OpCode):
475
  """Searches the tags in the cluster for a given pattern."""
476
  OP_ID = "OP_TAGS_SEARCH"
477
  OP_DSC_FIELD = "pattern"
478
  __slots__ = ["pattern"]
479

    
480

    
481
class OpAddTags(OpCode):
482
  """Add a list of tags on a given object."""
483
  OP_ID = "OP_TAGS_SET"
484
  __slots__ = ["kind", "name", "tags"]
485

    
486

    
487
class OpDelTags(OpCode):
488
  """Remove a list of tags from a given object."""
489
  OP_ID = "OP_TAGS_DEL"
490
  __slots__ = ["kind", "name", "tags"]
491

    
492

    
493
# Test opcodes
494
class OpTestDelay(OpCode):
495
  """Sleeps for a configured amount of time.
496

497
  This is used just for debugging and testing.
498

499
  Parameters:
500
    - duration: the time to sleep
501
    - on_master: if true, sleep on the master
502
    - on_nodes: list of nodes in which to sleep
503

504
  If the on_master parameter is true, it will execute a sleep on the
505
  master (before any node sleep).
506

507
  If the on_nodes list is not empty, it will sleep on those nodes
508
  (after the sleep on the master, if that is enabled).
509

510
  As an additional feature, the case of duration < 0 will be reported
511
  as an execution error, so this opcode can be used as a failure
512
  generator. The case of duration == 0 will not be treated specially.
513

514
  """
515
  OP_ID = "OP_TEST_DELAY"
516
  OP_DSC_FIELD = "duration"
517
  __slots__ = ["duration", "on_master", "on_nodes"]
518

    
519

    
520
class OpTestAllocator(OpCode):
521
  """Allocator framework testing.
522

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

530
  """
531
  OP_ID = "OP_TEST_ALLOCATOR"
532
  OP_DSC_FIELD = "allocator"
533
  __slots__ = [
534
    "direction", "mode", "allocator", "name",
535
    "mem_size", "disks", "disk_template",
536
    "os", "tags", "nics", "vcpus",
537
    ]