/ - Diff - snf-ganeti - Greek Research and Technology Network's projects

Revision 65e183af

     # few public methods:
     # pylint: disable-msg=R0903
     from ganeti import constants
     from ganeti import errors
     from ganeti import ht
     # Common opcode attributes
     #: output fields for a query operation
     _POutputFields = ("output_fields", ht.NoDefault, ht.TListOf(ht.TNonEmptyString))
     #: the shutdown timeout
     _PShutdownTimeout = ("shutdown_timeout", constants.DEFAULT_SHUTDOWN_TIMEOUT,
                          ht.TPositiveInt)
     #: the force parameter
     _PForce = ("force", False, ht.TBool)
     #: a required instance name (for single-instance LUs)
     _PInstanceName = ("instance_name", ht.NoDefault, ht.TNonEmptyString)
     #: Whether to ignore offline nodes
     _PIgnoreOfflineNodes = ("ignore_offline_nodes", False, ht.TBool)
     #: a required node name (for single-node LUs)
     _PNodeName = ("node_name", ht.NoDefault, ht.TNonEmptyString)
     #: a required node group name (for single-group LUs)
     _PGroupName = ("group_name", ht.NoDefault, ht.TNonEmptyString)
     #: Migration type (live/non-live)
     _PMigrationMode = ("mode", None,
                        ht.TOr(ht.TNone, ht.TElemOf(constants.HT_MIGRATION_MODES)))
     #: Obsolete 'live' migration mode (boolean)
     _PMigrationLive = ("live", None, ht.TMaybeBool)
     #: Tag type
     _PTagKind = ("kind", ht.NoDefault, ht.TElemOf(constants.VALID_TAG_TYPES))
     #: List of tag strings
     _PTags = ("tags", ht.NoDefault, ht.TListOf(ht.TNonEmptyString))
     def RequireFileStorage():
       """Checks that file storage is enabled.
       While it doesn't really fit into this module, L{utils} was deemed too large
       of a dependency to be imported for just one or two functions.
       @raise errors.OpPrereqError: when file storage is disabled
       """
       if not constants.ENABLE_FILE_STORAGE:
         raise errors.OpPrereqError("File storage disabled at configure time",
                                    errors.ECODE_INVAL)
     def _CheckDiskTemplate(template):
       """Ensure a given disk template is valid.
       """
       if template not in constants.DISK_TEMPLATES:
         # Using str.join directly to avoid importing utils for CommaJoin
         msg = ("Invalid disk template name '%s', valid templates are: %s" %
                (template, ", ".join(constants.DISK_TEMPLATES)))
         raise errors.OpPrereqError(msg, errors.ECODE_INVAL)
       if template == constants.DT_FILE:
         RequireFileStorage()
       return True
     def _CheckStorageType(storage_type):
       """Ensure a given storage type is valid.
       """
       if storage_type not in constants.VALID_STORAGE_TYPES:
         raise errors.OpPrereqError("Unknown storage type: %s" % storage_type,
                                    errors.ECODE_INVAL)
       if storage_type == constants.ST_FILE:
         RequireFileStorage()
       return True
     #: Storage type parameter
     _PStorageType = ("storage_type", ht.NoDefault, _CheckStorageType)
     class _AutoOpParamSlots(type):
       """Meta class for opcode definitions.
       """
       def __new__(mcs, name, bases, attrs):
         """Called when a class should be created.
         @param mcs: The meta class
         @param name: Name of created class
         @param bases: Base classes
         @type attrs: dict
         @param attrs: Class attributes
         """
         assert "__slots__" not in attrs, \
           "Class '%s' defines __slots__ when it should use OP_PARAMS" % name
         assert "OP_ID" in attrs, "Class '%s' is missing OP_ID attribute" % name
         # Always set OP_PARAMS to avoid duplicates in BaseOpCode.GetAllParams
         params = attrs.setdefault("OP_PARAMS", [])
         # Use parameter names as slots
         slots = [pname for (pname, _, _) in params]
         assert "OP_DSC_FIELD" not in attrs or attrs["OP_DSC_FIELD"] in slots, \
           "Class '%s' uses unknown field in OP_DSC_FIELD" % name
         attrs["__slots__"] = slots
         return type.__new__(mcs, name, bases, attrs)
     class BaseOpCode(object):
       """A simple serializable object.
-...
       field handling.
       """
       __slots__ = []
       __metaclass__ = _AutoOpParamSlots
       OP_ID = None
       def __init__(self, **kwargs):
         """Constructor for BaseOpCode.
-...
           slots.extend(getattr(parent, "__slots__", []))
         return slots
       @classmethod
       def GetAllParams(cls):
         """Compute list of all parameters for an opcode.
         """
         slots = []
         for parent in cls.__mro__:
           slots.extend(getattr(parent, "OP_PARAMS", []))
         return slots
     class OpCode(BaseOpCode):
       """Abstract OpCode.
-...
       @cvar OP_DSC_FIELD: The name of a field whose value will be included in the
                           string returned by Summary(); see the docstring of that
                           method for details).
       @cvar OP_PARAMS: List of opcode attributes, the default values they should
                        get if not already defined, and types they must match.
       @ivar dry_run: Whether the LU should be run in dry-run mode, i.e. just
                      the check steps
       @ivar priority: Opcode priority for queue
       """
       OP_ID = "OP_ABSTRACT"
       __slots__ = ["dry_run", "debug_level", "priority"]
       OP_PARAMS = [
         ("dry_run", None, ht.TMaybeBool),
         ("debug_level", None, ht.TOr(ht.TNone, ht.TPositiveInt)),
         ("priority", constants.OP_PRIO_DEFAULT,
          ht.TElemOf(constants.OP_PRIO_SUBMIT_VALID)),
+        ]
       def __getstate__(self):
         """Specialized getstate for opcodes.
-...
       """
       OP_ID = "OP_CLUSTER_POST_INIT"
       __slots__ = []
     class OpDestroyCluster(OpCode):
-...
       """
       OP_ID = "OP_CLUSTER_DESTROY"
       __slots__ = []
     class OpQueryClusterInfo(OpCode):
       """Query cluster information."""
       OP_ID = "OP_CLUSTER_QUERY"
       __slots__ = []
     class OpVerifyCluster(OpCode):
-...
       """
       OP_ID = "OP_CLUSTER_VERIFY"
       __slots__ = ["skip_checks", "verbose", "error_codes",
                    "debug_simulate_errors"]
       OP_PARAMS = [
         ("skip_checks", ht.EmptyList,
          ht.TListOf(ht.TElemOf(constants.VERIFY_OPTIONAL_CHECKS))),
         ("verbose", False, ht.TBool),
         ("error_codes", False, ht.TBool),
         ("debug_simulate_errors", False, ht.TBool),
+        ]
     class OpVerifyDisks(OpCode):
-...
       """
       OP_ID = "OP_CLUSTER_VERIFY_DISKS"
       __slots__ = []
     class OpRepairDiskSizes(OpCode):
-...
       """
       OP_ID = "OP_CLUSTER_REPAIR_DISK_SIZES"
       __slots__ = ["instances"]
       OP_PARAMS = [
         ("instances", ht.EmptyList, ht.TListOf(ht.TNonEmptyString)),
+        ]
     class OpQueryConfigValues(OpCode):
       """Query cluster configuration values."""
       OP_ID = "OP_CLUSTER_CONFIG_QUERY"
       __slots__ = ["output_fields"]
       OP_PARAMS = [
         _POutputFields
+        ]
     class OpRenameCluster(OpCode):
-...
       """
       OP_ID = "OP_CLUSTER_RENAME"
       OP_DSC_FIELD = "name"
       __slots__ = ["name"]
       OP_PARAMS = [
         ("name", ht.NoDefault, ht.TNonEmptyString),
+        ]
     class OpSetClusterParams(OpCode):
-...
       """
       OP_ID = "OP_CLUSTER_SET_PARAMS"
       __slots__ = [
         "vg_name",
         "drbd_helper",
         "enabled_hypervisors",
         "hvparams",
         "os_hvp",
         "beparams",
         "osparams",
         "nicparams",
         "ndparams",
         "candidate_pool_size",
         "maintain_node_health",
         "uid_pool",
         "add_uids",
         "remove_uids",
         "default_iallocator",
         "reserved_lvs",
         "hidden_os",
         "blacklisted_os",
         "prealloc_wipe_disks",
         "master_netdev",
       OP_PARAMS = [
         ("vg_name", None, ht.TMaybeString),
         ("enabled_hypervisors", None,
          ht.TOr(ht.TAnd(ht.TListOf(ht.TElemOf(constants.HYPER_TYPES)), ht.TTrue),
                 ht.TNone)),
         ("hvparams", None, ht.TOr(ht.TDictOf(ht.TNonEmptyString, ht.TDict),
                                   ht.TNone)),
         ("beparams", None, ht.TOr(ht.TDict, ht.TNone)),
         ("os_hvp", None, ht.TOr(ht.TDictOf(ht.TNonEmptyString, ht.TDict),
                                 ht.TNone)),
         ("osparams", None, ht.TOr(ht.TDictOf(ht.TNonEmptyString, ht.TDict),
                                   ht.TNone)),
         ("candidate_pool_size", None, ht.TOr(ht.TStrictPositiveInt, ht.TNone)),
         ("uid_pool", None, ht.NoType),
         ("add_uids", None, ht.NoType),
         ("remove_uids", None, ht.NoType),
         ("maintain_node_health", None, ht.TMaybeBool),
         ("prealloc_wipe_disks", None, ht.TMaybeBool),
         ("nicparams", None, ht.TOr(ht.TDict, ht.TNone)),
         ("ndparams", None, ht.TOr(ht.TDict, ht.TNone)),
         ("drbd_helper", None, ht.TOr(ht.TString, ht.TNone)),
         ("default_iallocator", None, ht.TOr(ht.TString, ht.TNone)),
         ("master_netdev", None, ht.TOr(ht.TString, ht.TNone)),
         ("reserved_lvs", None, ht.TOr(ht.TListOf(ht.TNonEmptyString), ht.TNone)),
         ("hidden_os", None, ht.TOr(ht.TListOf(
               ht.TAnd(ht.TList,
                     ht.TIsLength(2),
                     ht.TMap(lambda v: v[0], ht.TElemOf(constants.DDMS_VALUES)))),
               ht.TNone)),
         ("blacklisted_os", None, ht.TOr(ht.TListOf(
               ht.TAnd(ht.TList,
                     ht.TIsLength(2),
                     ht.TMap(lambda v: v[0], ht.TElemOf(constants.DDMS_VALUES)))),
               ht.TNone)),
+        ]
-...
       """
       OP_ID = "OP_CLUSTER_REDIST_CONF"
       __slots__ = []
     class OpQuery(OpCode):
-...
       """
       OP_ID = "OP_QUERY"
       __slots__ = [
         "what",
         "fields",
         "filter",
       OP_PARAMS = [
         ("what", ht.NoDefault, ht.TElemOf(constants.QR_OP_QUERY)),
         ("fields", ht.NoDefault, ht.TListOf(ht.TNonEmptyString)),
         ("filter", None, ht.TOr(ht.TNone,
                                 ht.TListOf(ht.TOr(ht.TNonEmptyString, ht.TList)))),
+        ]
-...
       """
       OP_ID = "OP_QUERY_FIELDS"
       __slots__ = [
         "what",
         "fields",
       OP_PARAMS = [
         ("what", ht.NoDefault, ht.TElemOf(constants.QR_OP_QUERY)),
         ("fields", None, ht.TOr(ht.TNone, ht.TListOf(ht.TNonEmptyString))),
+        ]
     class OpOobCommand(OpCode):
       """Interact with OOB."""
       OP_ID = "OP_OOB_COMMAND"
       __slots__ = [
         "node_name",
         "command",
         "timeout",
       OP_PARAMS = [
         _PNodeName,
         ("command", None, ht.TElemOf(constants.OOB_COMMANDS)),
         ("timeout", constants.OOB_TIMEOUT, ht.TInt),
+        ]
-...
       """
       OP_ID = "OP_NODE_REMOVE"
       OP_DSC_FIELD = "node_name"
       __slots__ = ["node_name"]
       OP_PARAMS = [
         _PNodeName,
+        ]
     class OpAddNode(OpCode):
-...
       """
       OP_ID = "OP_NODE_ADD"
       OP_DSC_FIELD = "node_name"
       __slots__ = ["node_name", "primary_ip", "secondary_ip", "readd", "group",
                    "vm_capable", "master_capable", "ndparams"]
       OP_PARAMS = [
         _PNodeName,
         ("primary_ip", None, ht.NoType),
         ("secondary_ip", None, ht.TMaybeString),
         ("readd", False, ht.TBool),
         ("group", None, ht.TMaybeString),
         ("master_capable", None, ht.TMaybeBool),
         ("vm_capable", None, ht.TMaybeBool),
         ("ndparams", None, ht.TOr(ht.TDict, ht.TNone)),
+        ]
     class OpQueryNodes(OpCode):
       """Compute the list of nodes."""
       OP_ID = "OP_NODE_QUERY"
       __slots__ = ["output_fields", "names", "use_locking"]
       OP_PARAMS = [
         _POutputFields,
         ("names", ht.EmptyList, ht.TListOf(ht.TNonEmptyString)),
         ("use_locking", False, ht.TBool),
+        ]
     class OpQueryNodeVolumes(OpCode):
       """Get list of volumes on node."""
       OP_ID = "OP_NODE_QUERYVOLS"
       __slots__ = ["nodes", "output_fields"]
       OP_PARAMS = [
         _POutputFields,
         ("nodes", ht.EmptyList, ht.TListOf(ht.TNonEmptyString)),
+        ]
     class OpQueryNodeStorage(OpCode):
       """Get information on storage for node(s)."""
       OP_ID = "OP_NODE_QUERY_STORAGE"
       __slots__ = [
         "nodes",
         "storage_type",
         "name",
         "output_fields",
       OP_PARAMS = [
         _POutputFields,
         _PStorageType,
         ("nodes", ht.EmptyList, ht.TListOf(ht.TNonEmptyString)),
         ("name", None, ht.TMaybeString),
+        ]
     class OpModifyNodeStorage(OpCode):
       """Modifies the properies of a storage unit"""
       OP_ID = "OP_NODE_MODIFY_STORAGE"
       __slots__ = [
         "node_name",
         "storage_type",
         "name",
         "changes",
       OP_PARAMS = [
         _PNodeName,
         _PStorageType,
         ("name", ht.NoDefault, ht.TNonEmptyString),
         ("changes", ht.NoDefault, ht.TDict),
+        ]
-...
       """Repairs the volume group on a node."""
       OP_ID = "OP_REPAIR_NODE_STORAGE"
       OP_DSC_FIELD = "node_name"
       __slots__ = [
         "node_name",
         "storage_type",
         "name",
         "ignore_consistency",
       OP_PARAMS = [
         _PNodeName,
         _PStorageType,
         ("name", ht.NoDefault, ht.TNonEmptyString),
         ("ignore_consistency", False, ht.TBool),
+        ]
-...
       """Change the parameters of a node."""
       OP_ID = "OP_NODE_SET_PARAMS"
       OP_DSC_FIELD = "node_name"
       __slots__ = [
         "node_name",
         "force",
         "master_candidate",
         "offline",
         "drained",
         "auto_promote",
         "master_capable",
         "vm_capable",
         "secondary_ip",
         "ndparams",
         "powered",
       OP_PARAMS = [
         _PNodeName,
         _PForce,
         ("master_candidate", None, ht.TMaybeBool),
         ("offline", None, ht.TMaybeBool),
         ("drained", None, ht.TMaybeBool),
         ("auto_promote", False, ht.TBool),
         ("master_capable", None, ht.TMaybeBool),
         ("vm_capable", None, ht.TMaybeBool),
         ("secondary_ip", None, ht.TMaybeString),
         ("ndparams", None, ht.TOr(ht.TDict, ht.TNone)),
         ("powered", None, ht.TMaybeBool),
+        ]
-...
       """Tries to powercycle a node."""
       OP_ID = "OP_NODE_POWERCYCLE"
       OP_DSC_FIELD = "node_name"
       __slots__ = [
         "node_name",
         "force",
       OP_PARAMS = [
         _PNodeName,
         _PForce,
+        ]
-...
       """Migrate all instances from a node."""
       OP_ID = "OP_NODE_MIGRATE"
       OP_DSC_FIELD = "node_name"
       __slots__ = [
         "node_name",
         "mode",
         "live",
       OP_PARAMS = [
         _PNodeName,
         _PMigrationMode,
         _PMigrationLive,
+        ]
-...
       """Compute the evacuation strategy for a list of nodes."""
       OP_ID = "OP_NODE_EVAC_STRATEGY"
       OP_DSC_FIELD = "nodes"
       __slots__ = ["nodes", "iallocator", "remote_node"]
       OP_PARAMS = [
         ("nodes", ht.NoDefault, ht.TListOf(ht.TNonEmptyString)),
         ("remote_node", None, ht.TMaybeString),
         ("iallocator", None, ht.TMaybeString),
+        ]
     # instance opcodes
-...
       """
       OP_ID = "OP_INSTANCE_CREATE"
       OP_DSC_FIELD = "instance_name"
       __slots__ = [
         "instance_name",
         "os_type", "force_variant", "no_install",
         "pnode", "disk_template", "snode", "mode",
         "disks", "nics",
         "src_node", "src_path", "start", "identify_defaults",
         "wait_for_sync", "ip_check", "name_check",
         "file_storage_dir", "file_driver",
         "iallocator",
         "hypervisor", "hvparams", "beparams", "osparams",
         "source_handshake",
         "source_x509_ca",
         "source_instance_name",
         "source_shutdown_timeout",
       OP_PARAMS = [
         _PInstanceName,
         ("beparams", ht.EmptyDict, ht.TDict),
         ("disks", ht.NoDefault, ht.TListOf(ht.TDict)),
         ("disk_template", ht.NoDefault, _CheckDiskTemplate),
         ("file_driver", None, ht.TOr(ht.TNone, ht.TElemOf(constants.FILE_DRIVER))),
         ("file_storage_dir", None, ht.TMaybeString),
         ("force_variant", False, ht.TBool),
         ("hvparams", ht.EmptyDict, ht.TDict),
         ("hypervisor", None, ht.TMaybeString),
         ("iallocator", None, ht.TMaybeString),
         ("identify_defaults", False, ht.TBool),
         ("ip_check", True, ht.TBool),
         ("mode", ht.NoDefault, ht.TElemOf(constants.INSTANCE_CREATE_MODES)),
         ("name_check", True, ht.TBool),
         ("nics", ht.NoDefault, ht.TListOf(ht.TDict)),
         ("no_install", None, ht.TMaybeBool),
         ("osparams", ht.EmptyDict, ht.TDict),
         ("os_type", None, ht.TMaybeString),
         ("pnode", None, ht.TMaybeString),
         ("snode", None, ht.TMaybeString),
         ("source_handshake", None, ht.TOr(ht.TList, ht.TNone)),
         ("source_instance_name", None, ht.TMaybeString),
         ("source_shutdown_timeout", constants.DEFAULT_SHUTDOWN_TIMEOUT,
          ht.TPositiveInt),
         ("source_x509_ca", None, ht.TMaybeString),
         ("src_node", None, ht.TMaybeString),
         ("src_path", None, ht.TMaybeString),
         ("start", True, ht.TBool),
         ("wait_for_sync", True, ht.TBool),
+        ]
-...
       """Reinstall an instance's OS."""
       OP_ID = "OP_INSTANCE_REINSTALL"
       OP_DSC_FIELD = "instance_name"
       __slots__ = ["instance_name", "os_type", "force_variant", "osparams"]
       OP_PARAMS = [
         _PInstanceName,
         ("os_type", None, ht.TMaybeString),
         ("force_variant", False, ht.TBool),
         ("osparams", None, ht.TOr(ht.TDict, ht.TNone)),
+        ]
     class OpRemoveInstance(OpCode):
       """Remove an instance."""
       OP_ID = "OP_INSTANCE_REMOVE"
       OP_DSC_FIELD = "instance_name"
       __slots__ = [
         "instance_name",
         "ignore_failures",
         "shutdown_timeout",
       OP_PARAMS = [
         _PInstanceName,
         _PShutdownTimeout,
         ("ignore_failures", False, ht.TBool),
+        ]
     class OpRenameInstance(OpCode):
       """Rename an instance."""
       OP_ID = "OP_INSTANCE_RENAME"
       __slots__ = [
         "instance_name", "ip_check", "new_name", "name_check",
       OP_PARAMS = [
         _PInstanceName,
         ("new_name", ht.NoDefault, ht.TNonEmptyString),
         ("ip_check", False, ht.TBool),
         ("name_check", True, ht.TBool),
+        ]
-...
       """Startup an instance."""
       OP_ID = "OP_INSTANCE_STARTUP"
       OP_DSC_FIELD = "instance_name"
       __slots__ = [
         "instance_name", "force", "hvparams", "beparams", "ignore_offline_nodes",
       OP_PARAMS = [
         _PInstanceName,
         _PForce,
         _PIgnoreOfflineNodes,
         ("hvparams", ht.EmptyDict, ht.TDict),
         ("beparams", ht.EmptyDict, ht.TDict),
+        ]
-...
       """Shutdown an instance."""
       OP_ID = "OP_INSTANCE_SHUTDOWN"
       OP_DSC_FIELD = "instance_name"
       __slots__ = [
         "instance_name", "timeout", "ignore_offline_nodes",
       OP_PARAMS = [
         _PInstanceName,
         _PIgnoreOfflineNodes,
         ("timeout", constants.DEFAULT_SHUTDOWN_TIMEOUT, ht.TPositiveInt),
+        ]
-...
       """Reboot an instance."""
       OP_ID = "OP_INSTANCE_REBOOT"
       OP_DSC_FIELD = "instance_name"
       __slots__ = [
         "instance_name", "reboot_type", "ignore_secondaries", "shutdown_timeout",
       OP_PARAMS = [
         _PInstanceName,
         _PShutdownTimeout,
         ("ignore_secondaries", False, ht.TBool),
         ("reboot_type", ht.NoDefault, ht.TElemOf(constants.REBOOT_TYPES)),
+        ]
-...
       """Replace the disks of an instance."""
       OP_ID = "OP_INSTANCE_REPLACE_DISKS"
       OP_DSC_FIELD = "instance_name"
       __slots__ = [
         "instance_name", "remote_node", "mode", "disks", "iallocator",
         "early_release",
       OP_PARAMS = [
         _PInstanceName,
         ("mode", ht.NoDefault, ht.TElemOf(constants.REPLACE_MODES)),
         ("disks", ht.EmptyList, ht.TListOf(ht.TPositiveInt)),
         ("remote_node", None, ht.TMaybeString),
         ("iallocator", None, ht.TMaybeString),
         ("early_release", False, ht.TBool),
+        ]
-...
       """Failover an instance."""
       OP_ID = "OP_INSTANCE_FAILOVER"
       OP_DSC_FIELD = "instance_name"
       __slots__ = [
         "instance_name", "ignore_consistency", "shutdown_timeout",
       OP_PARAMS = [
         _PInstanceName,
         _PShutdownTimeout,
         ("ignore_consistency", False, ht.TBool),
+        ]
-...
       """
       OP_ID = "OP_INSTANCE_MIGRATE"
       OP_DSC_FIELD = "instance_name"
       __slots__ = ["instance_name", "mode", "cleanup", "live"]
       OP_PARAMS = [
         _PInstanceName,
         _PMigrationMode,
         _PMigrationLive,
         ("cleanup", False, ht.TBool),
+        ]
     class OpMoveInstance(OpCode):
-...
       """
       OP_ID = "OP_INSTANCE_MOVE"
       OP_DSC_FIELD = "instance_name"
       __slots__ = [
         "instance_name", "target_node", "shutdown_timeout",
       OP_PARAMS = [
         _PInstanceName,
         _PShutdownTimeout,
         ("target_node", ht.NoDefault, ht.TNonEmptyString),
+        ]
-...
       """Connect to an instance's console."""
       OP_ID = "OP_INSTANCE_CONSOLE"
       OP_DSC_FIELD = "instance_name"
       __slots__ = ["instance_name"]
       OP_PARAMS = [
         _PInstanceName
+        ]
     class OpActivateInstanceDisks(OpCode):
       """Activate an instance's disks."""
       OP_ID = "OP_INSTANCE_ACTIVATE_DISKS"
       OP_DSC_FIELD = "instance_name"
       __slots__ = ["instance_name", "ignore_size"]
       OP_PARAMS = [
         _PInstanceName,
         ("ignore_size", False, ht.TBool),
+        ]
     class OpDeactivateInstanceDisks(OpCode):
       """Deactivate an instance's disks."""
       OP_ID = "OP_INSTANCE_DEACTIVATE_DISKS"
       OP_DSC_FIELD = "instance_name"
       __slots__ = ["instance_name"]
       OP_PARAMS = [
         _PInstanceName
+        ]
     class OpRecreateInstanceDisks(OpCode):
       """Deactivate an instance's disks."""
       OP_ID = "OP_INSTANCE_RECREATE_DISKS"
       OP_DSC_FIELD = "instance_name"
       __slots__ = ["instance_name", "disks"]
       OP_PARAMS = [
         _PInstanceName,
         ("disks", ht.EmptyList, ht.TListOf(ht.TPositiveInt)),
+        ]
     class OpQueryInstances(OpCode):
       """Compute the list of instances."""
       OP_ID = "OP_INSTANCE_QUERY"
       __slots__ = ["output_fields", "names", "use_locking"]
       OP_PARAMS = [
         _POutputFields,
         ("names", ht.EmptyList, ht.TListOf(ht.TNonEmptyString)),
         ("use_locking", False, ht.TBool),
+        ]
     class OpQueryInstanceData(OpCode):
       """Compute the run-time status of instances."""
       OP_ID = "OP_INSTANCE_QUERY_DATA"
       __slots__ = ["instances", "static"]
       OP_PARAMS = [
         ("instances", ht.EmptyList, ht.TListOf(ht.TNonEmptyString)),
         ("static", False, ht.TBool),
+        ]
     class OpSetInstanceParams(OpCode):
       """Change the parameters of an instance."""
       OP_ID = "OP_INSTANCE_SET_PARAMS"
       OP_DSC_FIELD = "instance_name"
       __slots__ = [
         "instance_name",
         "hvparams", "beparams", "osparams", "force",
         "nics", "disks", "disk_template",
         "remote_node", "os_name", "force_variant",
       OP_PARAMS = [
         _PInstanceName,
         _PForce,
         ("nics", ht.EmptyList, ht.TList),
         ("disks", ht.EmptyList, ht.TList),
         ("beparams", ht.EmptyDict, ht.TDict),
         ("hvparams", ht.EmptyDict, ht.TDict),
         ("disk_template", None, _CheckDiskTemplate),
         ("remote_node", None, ht.TMaybeString),
         ("os_name", None, ht.TMaybeString),
         ("force_variant", False, ht.TBool),
         ("osparams", None, ht.TOr(ht.TDict, ht.TNone)),
+        ]
-...
       """Grow a disk of an instance."""
       OP_ID = "OP_INSTANCE_GROW_DISK"
       OP_DSC_FIELD = "instance_name"
       __slots__ = [
         "instance_name", "disk", "amount", "wait_for_sync",
       OP_PARAMS = [
         _PInstanceName,
         ("disk", ht.NoDefault, ht.TInt),
         ("amount", ht.NoDefault, ht.TInt),
         ("wait_for_sync", True, ht.TBool),
+        ]
-...
       """Add a node group to the cluster."""
       OP_ID = "OP_GROUP_ADD"
       OP_DSC_FIELD = "group_name"
       __slots__ = [
         "group_name",
         "ndparams",
         "alloc_policy",
       OP_PARAMS = [
         _PGroupName,
         ("ndparams", None, ht.TOr(ht.TDict, ht.TNone)),
         ("alloc_policy", None,
          ht.TOr(ht.TNone, ht.TElemOf(constants.VALID_ALLOC_POLICIES))),
+        ]
     class OpQueryGroups(OpCode):
       """Compute the list of node groups."""
       OP_ID = "OP_GROUP_QUERY"
       __slots__ = ["output_fields", "names"]
       OP_PARAMS = [
         _POutputFields,
         ("names", ht.EmptyList, ht.TListOf(ht.TNonEmptyString)),
+        ]
     class OpSetGroupParams(OpCode):
       """Change the parameters of a node group."""
       OP_ID = "OP_GROUP_SET_PARAMS"
       OP_DSC_FIELD = "group_name"
       __slots__ = [
         "group_name",
         "ndparams",
         "alloc_policy",
       OP_PARAMS = [
         _PGroupName,
         ("ndparams", None, ht.TOr(ht.TDict, ht.TNone)),
         ("alloc_policy", None, ht.TOr(ht.TNone,
                                       ht.TElemOf(constants.VALID_ALLOC_POLICIES))),
+        ]
-...
       """Remove a node group from the cluster."""
       OP_ID = "OP_GROUP_REMOVE"
       OP_DSC_FIELD = "group_name"
       __slots__ = ["group_name"]
       OP_PARAMS = [
         _PGroupName,
+        ]
     class OpRenameGroup(OpCode):
       """Rename a node group in the cluster."""
       OP_ID = "OP_GROUP_RENAME"
       OP_DSC_FIELD = "old_name"
       __slots__ = ["old_name", "new_name"]
       OP_PARAMS = [
         ("old_name", ht.NoDefault, ht.TNonEmptyString),
         ("new_name", ht.NoDefault, ht.TNonEmptyString),
+        ]
     # OS opcodes
     class OpDiagnoseOS(OpCode):
       """Compute the list of guest operating systems."""
       OP_ID = "OP_OS_DIAGNOSE"
       __slots__ = ["output_fields", "names"]
       OP_PARAMS = [
         _POutputFields,
         ("names", ht.EmptyList, ht.TListOf(ht.TNonEmptyString)),
+        ]
     # Exports opcodes
     class OpQueryExports(OpCode):
       """Compute the list of exported images."""
       OP_ID = "OP_BACKUP_QUERY"
       __slots__ = ["nodes", "use_locking"]
       OP_PARAMS = [
         ("nodes", ht.EmptyList, ht.TListOf(ht.TNonEmptyString)),
         ("use_locking", False, ht.TBool),
+        ]
     class OpPrepareExport(OpCode):
-...
       """
       OP_ID = "OP_BACKUP_PREPARE"
       OP_DSC_FIELD = "instance_name"
       __slots__ = [
         "instance_name", "mode",
       OP_PARAMS = [
         _PInstanceName,
         ("mode", ht.NoDefault, ht.TElemOf(constants.EXPORT_MODES)),
+        ]
-...
       """
       OP_ID = "OP_BACKUP_EXPORT"
       OP_DSC_FIELD = "instance_name"
       __slots__ = [
       OP_PARAMS = [
         _PInstanceName,
         _PShutdownTimeout,
         # TODO: Rename target_node as it changes meaning for different export modes
         # (e.g. "destination")
         "instance_name", "target_node", "shutdown", "shutdown_timeout",
         "remove_instance",
         "ignore_remove_failures",
         "mode",
         "x509_key_name",
         "destination_x509_ca",
         ("target_node", ht.NoDefault, ht.TOr(ht.TNonEmptyString, ht.TList)),
         ("shutdown", True, ht.TBool),
         ("remove_instance", False, ht.TBool),
         ("ignore_remove_failures", False, ht.TBool),
         ("mode", constants.EXPORT_MODE_LOCAL, ht.TElemOf(constants.EXPORT_MODES)),
         ("x509_key_name", None, ht.TOr(ht.TList, ht.TNone)),
         ("destination_x509_ca", None, ht.TMaybeString),
+        ]
-...
       """Remove an instance's export."""
       OP_ID = "OP_BACKUP_REMOVE"
       OP_DSC_FIELD = "instance_name"
       __slots__ = ["instance_name"]
       OP_PARAMS = [
         _PInstanceName,
+        ]
     # Tags opcodes
-...
       """Returns the tags of the given object."""
       OP_ID = "OP_TAGS_GET"
       OP_DSC_FIELD = "name"
       __slots__ = ["kind", "name"]
       OP_PARAMS = [
         _PTagKind,
         # Name is only meaningful for nodes and instances
         ("name", ht.NoDefault, ht.TMaybeString),
+        ]
     class OpSearchTags(OpCode):
       """Searches the tags in the cluster for a given pattern."""
       OP_ID = "OP_TAGS_SEARCH"
       OP_DSC_FIELD = "pattern"
       __slots__ = ["pattern"]
       OP_PARAMS = [
         ("pattern", ht.NoDefault, ht.TNonEmptyString),
+        ]
     class OpAddTags(OpCode):
       """Add a list of tags on a given object."""
       OP_ID = "OP_TAGS_SET"
       __slots__ = ["kind", "name", "tags"]
       OP_PARAMS = [
         _PTagKind,
         _PTags,
         # Name is only meaningful for nodes and instances
         ("name", ht.NoDefault, ht.TMaybeString),
+        ]
     class OpDelTags(OpCode):
       """Remove a list of tags from a given object."""
       OP_ID = "OP_TAGS_DEL"
       __slots__ = ["kind", "name", "tags"]
       OP_PARAMS = [
         _PTagKind,
         _PTags,
         # Name is only meaningful for nodes and instances
         ("name", ht.NoDefault, ht.TMaybeString),
+        ]
     # Test opcodes
     class OpTestDelay(OpCode):
-...
       """
       OP_ID = "OP_TEST_DELAY"
       OP_DSC_FIELD = "duration"
       __slots__ = ["duration", "on_master", "on_nodes", "repeat"]
       OP_PARAMS = [
         ("duration", ht.NoDefault, ht.TFloat),
         ("on_master", True, ht.TBool),
         ("on_nodes", ht.EmptyList, ht.TListOf(ht.TNonEmptyString)),
         ("repeat", 0, ht.TPositiveInt)
+        ]
     class OpTestAllocator(OpCode):
-...
       """
       OP_ID = "OP_TEST_ALLOCATOR"
       OP_DSC_FIELD = "allocator"
       __slots__ = [
         "direction", "mode", "allocator", "name",
         "mem_size", "disks", "disk_template",
         "os", "tags", "nics", "vcpus", "hypervisor",
         "evac_nodes",
       OP_PARAMS = [
         ("direction", ht.NoDefault,
          ht.TElemOf(constants.VALID_IALLOCATOR_DIRECTIONS)),
         ("mode", ht.NoDefault, ht.TElemOf(constants.VALID_IALLOCATOR_MODES)),
         ("name", ht.NoDefault, ht.TNonEmptyString),
         ("nics", ht.NoDefault, ht.TOr(ht.TNone, ht.TListOf(
           ht.TDictOf(ht.TElemOf(["mac", "ip", "bridge"]),
                    ht.TOr(ht.TNone, ht.TNonEmptyString))))),
         ("disks", ht.NoDefault, ht.TOr(ht.TNone, ht.TList)),
         ("hypervisor", None, ht.TMaybeString),
         ("allocator", None, ht.TMaybeString),
         ("tags", ht.EmptyList, ht.TListOf(ht.TNonEmptyString)),
         ("mem_size", None, ht.TOr(ht.TNone, ht.TPositiveInt)),
         ("vcpus", None, ht.TOr(ht.TNone, ht.TPositiveInt)),
         ("os", None, ht.TMaybeString),
         ("disk_template", None, ht.TMaybeString),
         ("evac_nodes", None, ht.TOr(ht.TNone, ht.TListOf(ht.TNonEmptyString))),
+        ]
-...
       """
       OP_ID = "OP_TEST_JQUEUE"
       __slots__ = [
         "notify_waitlock",
         "notify_exec",
         "log_messages",
         "fail",
       OP_PARAMS = [
         ("notify_waitlock", False, ht.TBool),
         ("notify_exec", False, ht.TBool),
         ("log_messages", ht.EmptyList, ht.TListOf(ht.TString)),
         ("fail", False, ht.TBool),
+        ]
-...
       """
       OP_ID = "OP_TEST_DUMMY"
       __slots__ = [
         "result",
         "messages",
         "fail",
       OP_PARAMS = [
         ("result", ht.NoDefault, ht.NoType),
         ("messages", ht.NoDefault, ht.NoType),
         ("fail", ht.NoDefault, ht.NoType),
+        ]

     from ganeti import errors
     from ganeti import utils
     from ganeti import luxi
     from ganeti import ht
     import testutils
     import mocks
-...
         class TestOpcode(opcodes.OpCode):
           OP_ID = "OP_TEST"
           __slots__ = ["iallocator", "node"]
           OP_PARAMS = [
             ("iallocator", None, ht.NoType),
             ("node", None, ht.NoType),
+            ]
         default_iallocator = mocks.FakeConfig().GetDefaultIAllocator()
         other_iallocator = default_iallocator + "_not"

     from ganeti import utils
     from ganeti import opcodes
     from ganeti import ht
     import testutils
-...
             self.assert_(isinstance(restored, cls))
             self._checkSummary(restored)
             for name in ["x_y_z", "hello_world"]:
               assert name not in cls._all_slots()
               for value in [None, True, False, [], "Hello World"]:
                 self.assertRaises(AttributeError, setattr, op, name, value)
       def _checkSummary(self, op):
         summary = op.Summary()
-...
         else:
           self.assertEqual("OP_%s" % summary, op.OP_ID)
       def testParams(self):
         supported_by_all = set(["debug_level", "dry_run", "priority"])
         self.assert_(opcodes.BaseOpCode not in opcodes.OP_MAPPING.values())
         self.assert_(opcodes.OpCode in opcodes.OP_MAPPING.values())
         for cls in opcodes.OP_MAPPING.values():
           all_slots = cls._all_slots()
           self.assertEqual(len(set(all_slots) & supported_by_all), 3,
                            msg=("Opcode %s doesn't support all base"
                                 " parameters (%r)" % (cls.OP_ID, supported_by_all)))
           # All opcodes must have OP_PARAMS
           self.assert_(hasattr(cls, "OP_PARAMS"),
                        msg="%s doesn't have OP_PARAMS" % cls.OP_ID)
           param_names = [name for (name, _, _) in cls.GetAllParams()]
           self.assertEqual(all_slots, param_names)
           # Without inheritance
           self.assertEqual(cls.__slots__, [name for (name, _, _) in cls.OP_PARAMS])
           # This won't work if parameters are converted to a dictionary
           duplicates = utils.FindDuplicates(param_names)
           self.assertFalse(duplicates,
                            msg=("Found duplicate parameters %r in %s" %
                                 (duplicates, cls.OP_ID)))
           # Check parameter definitions
           for attr_name, aval, test in cls.GetAllParams():
             self.assert_(attr_name)
             self.assert_(test is None or test is ht.NoType or callable(test),
                          msg=("Invalid type check for %s.%s" %
                               (cls.OP_ID, attr_name)))
             if callable(aval):
               self.assertFalse(callable(aval()),
                                msg="Default value returned by function is callable")
     if __name__ == "__main__":
       testutils.GanetiTestProgram()

Also available in: Unified diff

Synnefo » snf-ganeti

Revision 65e183af