Commit cd40dc53 authored by Michael Hanselmann's avatar Michael Hanselmann
Browse files

rpc: Improve argument definitions



Instead of in-place code now each argument has an (optional) kind
assigned. The RPC client will then take care of encoding each argument
according to its definition. A new base (_RpcClientBase) is added to
take care of encoding and dispatching calls.

Future patches will also use these definitions in the node daemon.

A nice side-effect of this change is the ability to use stand-alone
functions, as opposed to class member methods, for most of the encoding.
Signed-off-by: default avatarMichael Hanselmann <hansmi@google.com>
Reviewed-by: default avatarRené Nussbaumer <rn@google.com>
parent b8c160c1
......@@ -96,16 +96,6 @@ def _WriteDocstring(sw, name, timeout, kind, args, desc):
sw.Write("\"\"\"")
def _MakeArgument((argname, wrapper, _)):
"""Format argument for function call.
"""
if wrapper:
return wrapper % argname
else:
return argname
def _WriteBaseClass(sw, clsname, calls):
"""Write RPC wrapper class.
......@@ -158,8 +148,14 @@ def _WriteBaseClass(sw, clsname, calls):
buf.write("[node]")
else:
buf.write("node_list")
buf.write(", \"%s\", read_timeout, [%s])" %
(name, utils.CommaJoin(map(_MakeArgument, args))))
buf.write(", \"%s\", read_timeout, [%s], [%s])" %
(name,
# Argument definitions
utils.CommaJoin(map(compat.snd, args)),
# Function arguments
utils.CommaJoin(map(compat.fst, args))))
if kind == _SINGLE:
buf.write("[node]")
if postproc:
......
......@@ -47,6 +47,7 @@ from ganeti import netutils
from ganeti import ssconf
from ganeti import runtime
from ganeti import compat
from ganeti import rpc_defs
# Special module generated at build time
from ganeti import _generated_rpc
......@@ -409,7 +410,125 @@ class _RpcProcessor:
return self._CombineResults(results, requests, procedure)
class RpcRunner(_generated_rpc.RpcClientDefault,
class _RpcClientBase:
def __init__(self, resolver, encoder_fn, lock_monitor_cb=None):
"""Initializes this class.
"""
self._proc = _RpcProcessor(resolver,
netutils.GetDaemonPort(constants.NODED),
lock_monitor_cb=lock_monitor_cb)
self._encoder = compat.partial(self._EncodeArg, encoder_fn)
@staticmethod
def _EncodeArg(encoder_fn, (argkind, value)):
"""Encode argument.
"""
if argkind is None:
return value
else:
return encoder_fn(argkind)(value)
def _Call(self, node_list, procedure, timeout, argdefs, args):
"""Entry point for automatically generated RPC wrappers.
"""
assert len(args) == len(argdefs), "Wrong number of arguments"
body = serializer.DumpJson(map(self._encoder, zip(argdefs, args)),
indent=False)
return self._proc(node_list, procedure, body, read_timeout=timeout)
def _ObjectToDict(value):
"""Converts an object to a dictionary.
@note: See L{objects}.
"""
return value.ToDict()
def _ObjectListToDict(value):
"""Converts a list of L{objects} to dictionaries.
"""
return map(_ObjectToDict, value)
def _EncodeNodeToDiskDict(value):
"""Encodes a dictionary with node name as key and disk objects as values.
"""
return dict((name, _ObjectListToDict(disks))
for name, disks in value.items())
def _PrepareFileUpload(filename):
"""Loads a file and prepares it for an upload to nodes.
"""
data = _Compress(utils.ReadFile(filename))
st = os.stat(filename)
getents = runtime.GetEnts()
return [filename, data, st.st_mode, getents.LookupUid(st.st_uid),
getents.LookupGid(st.st_gid), st.st_atime, st.st_mtime]
def _PrepareFinalizeExportDisks(snap_disks):
"""Encodes disks for finalizing export.
"""
flat_disks = []
for disk in snap_disks:
if isinstance(disk, bool):
flat_disks.append(disk)
else:
flat_disks.append(disk.ToDict())
return flat_disks
def _EncodeImportExportIO((ieio, ieioargs)):
"""Encodes import/export I/O information.
"""
if ieio == constants.IEIO_RAW_DISK:
assert len(ieioargs) == 1
return (ieio, (ieioargs[0].ToDict(), ))
if ieio == constants.IEIO_SCRIPT:
assert len(ieioargs) == 2
return (ieio, (ieioargs[0].ToDict(), ieioargs[1]))
return (ieio, ieioargs)
def _EncodeBlockdevRename(value):
"""Encodes information for renaming block devices.
"""
return [(d.ToDict(), uid) for d, uid in value]
#: Generic encoders
_ENCODERS = {
rpc_defs.ED_OBJECT_DICT: _ObjectToDict,
rpc_defs.ED_OBJECT_DICT_LIST: _ObjectListToDict,
rpc_defs.ED_NODE_TO_DISK_DICT: _EncodeNodeToDiskDict,
rpc_defs.ED_FILE_DETAILS: _PrepareFileUpload,
rpc_defs.ED_COMPRESS: _Compress,
rpc_defs.ED_FINALIZE_EXPORT_DISKS: _PrepareFinalizeExportDisks,
rpc_defs.ED_IMPEXP_IO: _EncodeImportExportIO,
rpc_defs.ED_BLOCKDEV_RENAME: _EncodeBlockdevRename,
}
class RpcRunner(_RpcClientBase,
_generated_rpc.RpcClientDefault,
_generated_rpc.RpcClientBootstrap,
_generated_rpc.RpcClientConfig):
"""RPC runner class.
......@@ -422,21 +541,31 @@ class RpcRunner(_generated_rpc.RpcClientDefault,
@param context: Ganeti context
"""
self._cfg = context.cfg
encoders = _ENCODERS.copy()
# Add encoders requiring configuration object
encoders.update({
rpc_defs.ED_INST_DICT: self._InstDict,
rpc_defs.ED_INST_DICT_HVP_BEP: self._InstDictHvpBep,
rpc_defs.ED_INST_DICT_OSP: self._InstDictOsp,
})
# Resolver using configuration
resolver = compat.partial(_NodeConfigResolver, self._cfg.GetNodeInfo,
self._cfg.GetAllNodesInfo)
# Pylint doesn't recognize multiple inheritance properly, see
# <http://www.logilab.org/ticket/36586> and
# <http://www.logilab.org/ticket/35642>
# pylint: disable=W0233
_RpcClientBase.__init__(self, resolver, encoders.get,
lock_monitor_cb=context.glm.AddToLockMonitor)
_generated_rpc.RpcClientConfig.__init__(self)
_generated_rpc.RpcClientBootstrap.__init__(self)
_generated_rpc.RpcClientDefault.__init__(self)
self._cfg = context.cfg
self._proc = _RpcProcessor(compat.partial(_NodeConfigResolver,
self._cfg.GetNodeInfo,
self._cfg.GetAllNodesInfo),
netutils.GetDaemonPort(constants.NODED),
lock_monitor_cb=context.glm.AddToLockMonitor)
def _InstDict(self, instance, hvp=None, bep=None, osp=None):
"""Convert the given instance to a dict.
......@@ -485,14 +614,6 @@ class RpcRunner(_generated_rpc.RpcClientDefault,
"""
return self._InstDict(instance, osp=osparams)
def _Call(self, node_list, procedure, timeout, args):
"""Entry point for automatically generated RPC wrappers.
"""
body = serializer.DumpJson(args, indent=False)
return self._proc(node_list, procedure, body, read_timeout=timeout)
@staticmethod
def _MigrationStatusPostProc(result):
if not result.fail_msg and result.payload is not None:
......@@ -530,18 +651,6 @@ class RpcRunner(_generated_rpc.RpcClientDefault,
result.payload = objects.OS.FromDict(result.payload)
return result
@staticmethod
def _PrepareFinalizeExportDisks(snap_disks):
flat_disks = []
for disk in snap_disks:
if isinstance(disk, bool):
flat_disks.append(disk)
else:
flat_disks.append(disk.ToDict())
return flat_disks
@staticmethod
def _ImpExpStatusPostProc(result):
"""Post-processor for import/export status.
......@@ -564,32 +673,6 @@ class RpcRunner(_generated_rpc.RpcClientDefault,
return result
@staticmethod
def _EncodeImportExportIO((ieio, ieioargs)):
"""Encodes import/export I/O information.
"""
if ieio == constants.IEIO_RAW_DISK:
assert len(ieioargs) == 1
return (ieio, (ieioargs[0].ToDict(), ))
if ieio == constants.IEIO_SCRIPT:
assert len(ieioargs) == 2
return (ieio, (ieioargs[0].ToDict(), ieioargs[1]))
return (ieio, ieioargs)
@staticmethod
def _PrepareFileUpload(filename):
"""Loads a file and prepares it for an upload to nodes.
"""
data = _Compress(utils.ReadFile(filename))
st = os.stat(filename)
getents = runtime.GetEnts()
return [filename, data, st.st_mode, getents.LookupUid(st.st_uid),
getents.LookupGid(st.st_gid), st.st_atime, st.st_mtime]
#
# Begin RPC calls
#
......@@ -605,38 +688,26 @@ class RpcRunner(_generated_rpc.RpcClientDefault,
read_timeout=int(duration + 5))
class JobQueueRunner(_generated_rpc.RpcClientJobQueue):
class JobQueueRunner(_RpcClientBase, _generated_rpc.RpcClientJobQueue):
"""RPC wrappers for job queue.
"""
_Compress = staticmethod(_Compress)
def __init__(self, context, address_list):
"""Initializes this class.
"""
_generated_rpc.RpcClientJobQueue.__init__(self)
if address_list is None:
resolver = _SsconfResolver
else:
# Caller provided an address list
resolver = _StaticResolver(address_list)
self._proc = _RpcProcessor(resolver,
netutils.GetDaemonPort(constants.NODED),
lock_monitor_cb=context.glm.AddToLockMonitor)
def _Call(self, node_list, procedure, timeout, args):
"""Entry point for automatically generated RPC wrappers.
"""
body = serializer.DumpJson(args, indent=False)
return self._proc(node_list, procedure, body, read_timeout=timeout)
_RpcClientBase.__init__(self, resolver, _ENCODERS.get,
lock_monitor_cb=context.glm.AddToLockMonitor)
_generated_rpc.RpcClientJobQueue.__init__(self)
class BootstrapRunner(_generated_rpc.RpcClientBootstrap):
class BootstrapRunner(_RpcClientBase, _generated_rpc.RpcClientBootstrap):
"""RPC wrappers for bootstrapping.
"""
......@@ -644,46 +715,23 @@ class BootstrapRunner(_generated_rpc.RpcClientBootstrap):
"""Initializes this class.
"""
_RpcClientBase.__init__(self, _SsconfResolver, _ENCODERS.get)
_generated_rpc.RpcClientBootstrap.__init__(self)
self._proc = _RpcProcessor(_SsconfResolver,
netutils.GetDaemonPort(constants.NODED))
def _Call(self, node_list, procedure, timeout, args):
"""Entry point for automatically generated RPC wrappers.
"""
body = serializer.DumpJson(args, indent=False)
return self._proc(node_list, procedure, body, read_timeout=timeout)
class ConfigRunner(_generated_rpc.RpcClientConfig):
class ConfigRunner(_RpcClientBase, _generated_rpc.RpcClientConfig):
"""RPC wrappers for L{config}.
"""
_PrepareFileUpload = \
staticmethod(RpcRunner._PrepareFileUpload) # pylint: disable=W0212
def __init__(self, address_list):
"""Initializes this class.
"""
_generated_rpc.RpcClientConfig.__init__(self)
if address_list is None:
resolver = _SsconfResolver
else:
# Caller provided an address list
resolver = _StaticResolver(address_list)
self._proc = _RpcProcessor(resolver,
netutils.GetDaemonPort(constants.NODED))
def _Call(self, node_list, procedure, timeout, args):
"""Entry point for automatically generated RPC wrappers.
"""
body = serializer.DumpJson(args, indent=False)
return self._proc(node_list, procedure, body, read_timeout=timeout)
_RpcClientBase.__init__(self, resolver, _ENCODERS.get)
_generated_rpc.RpcClientConfig.__init__(self)
......@@ -28,7 +28,7 @@ RPC definition fields:
- List of arguments as tuples
- Name as string
- Wrapper code ("%s" is replaced with argument name, see L{OBJECT_TO_DICT})
- Argument kind used for encoding/decoding
- Description for docstring (can be C{None})
- Return value wrapper (e.g. for deserializing into L{objects}-based objects)
......@@ -52,13 +52,18 @@ TMO_1DAY = 86400
SINGLE = "single-node"
MULTI = "multi-node"
OBJECT_TO_DICT = "%s.ToDict()"
OBJECT_LIST_TO_DICT = "map(lambda d: d.ToDict(), %s)"
INST_TO_DICT = "self._InstDict(%s)"
NODE_TO_DISK_DICT = \
("dict((name, %s) for name, disks in %%s.items())" %
(OBJECT_LIST_TO_DICT % "disks"))
# Constants for encoding/decoding
(ED_OBJECT_DICT,
ED_OBJECT_DICT_LIST,
ED_INST_DICT,
ED_INST_DICT_HVP_BEP,
ED_NODE_TO_DISK_DICT,
ED_INST_DICT_OSP,
ED_IMPEXP_IO,
ED_FILE_DETAILS,
ED_FINALIZE_EXPORT_DISKS,
ED_COMPRESS,
ED_BLOCKDEV_RENAME) = range(1, 12)
_FILE_STORAGE_CALLS = [
("file_storage_dir_create", SINGLE, TMO_FAST, [
......@@ -106,55 +111,55 @@ _INSTANCE_CALLS = [
("hypervisor_list", None, "Hypervisors to query for instances"),
], None, "Returns the list of running instances on the given nodes"),
("instance_reboot", SINGLE, TMO_NORMAL, [
("inst", INST_TO_DICT, "Instance object"),
("inst", ED_INST_DICT, "Instance object"),
("reboot_type", None, None),
("shutdown_timeout", None, None),
], None, "Returns the list of running instances on the given nodes"),
("instance_shutdown", SINGLE, TMO_NORMAL, [
("instance", INST_TO_DICT, "Instance object"),
("instance", ED_INST_DICT, "Instance object"),
("timeout", None, None),
], None, "Stops an instance"),
("instance_run_rename", SINGLE, TMO_SLOW, [
("instance", INST_TO_DICT, "Instance object"),
("instance", ED_INST_DICT, "Instance object"),
("old_name", None, None),
("debug", None, None),
], None, "Run the OS rename script for an instance"),
("instance_migratable", SINGLE, TMO_NORMAL, [
("instance", INST_TO_DICT, "Instance object"),
("instance", ED_INST_DICT, "Instance object"),
], None, "Checks whether the given instance can be migrated"),
("migration_info", SINGLE, TMO_NORMAL, [
("instance", INST_TO_DICT, "Instance object"),
("instance", ED_INST_DICT, "Instance object"),
], None,
"Gather the information necessary to prepare an instance migration"),
("accept_instance", SINGLE, TMO_NORMAL, [
("instance", INST_TO_DICT, "Instance object"),
("instance", ED_INST_DICT, "Instance object"),
("info", None, "Result for the call_migration_info call"),
("target", None, "Target hostname (usually an IP address)"),
], None, "Prepare a node to accept an instance"),
("instance_finalize_migration_dst", SINGLE, TMO_NORMAL, [
("instance", INST_TO_DICT, "Instance object"),
("instance", ED_INST_DICT, "Instance object"),
("info", None, "Result for the call_migration_info call"),
("success", None, "Whether the migration was a success or failure"),
], None, "Finalize any target-node migration specific operation"),
("instance_migrate", SINGLE, TMO_SLOW, [
("instance", INST_TO_DICT, "Instance object"),
("instance", ED_INST_DICT, "Instance object"),
("target", None, "Target node name"),
("live", None, "Whether the migration should be done live or not"),
], None, "Migrate an instance"),
("instance_finalize_migration_src", SINGLE, TMO_SLOW, [
("instance", INST_TO_DICT, "Instance object"),
("instance", ED_INST_DICT, "Instance object"),
("success", None, "Whether the migration succeeded or not"),
("live", None, "Whether the user requested a live migration or not"),
], None, "Finalize the instance migration on the source node"),
("instance_get_migration_status", SINGLE, TMO_SLOW, [
("instance", INST_TO_DICT, "Instance object"),
("instance", ED_INST_DICT, "Instance object"),
], "self._MigrationStatusPostProc", "Report migration status"),
("instance_start", SINGLE, TMO_NORMAL, [
("instance_hvp_bep", "self._InstDictHvpBep(%s)", None),
("instance_hvp_bep", ED_INST_DICT_HVP_BEP, None),
("startup_paused", None, None),
], None, "Starts an instance"),
("instance_os_add", SINGLE, TMO_1DAY, [
("instance_osp", "self._InstDictOsp(%s)", None),
("instance_osp", ED_INST_DICT_OSP, None),
("reinstall", None, None),
("debug", None, None),
], None, "Starts an instance"),
......@@ -162,18 +167,18 @@ _INSTANCE_CALLS = [
_IMPEXP_CALLS = [
("import_start", SINGLE, TMO_NORMAL, [
("opts", OBJECT_TO_DICT, None),
("instance", INST_TO_DICT, None),
("opts", ED_OBJECT_DICT, None),
("instance", ED_INST_DICT, None),
("component", None, None),
("dest", "self._EncodeImportExportIO(%s)", "Import destination"),
("dest", ED_IMPEXP_IO, "Import destination"),
], None, "Starts an import daemon"),
("export_start", SINGLE, TMO_NORMAL, [
("opts", OBJECT_TO_DICT, None),
("opts", ED_OBJECT_DICT, None),
("host", None, None),
("port", None, None),
("instance", INST_TO_DICT, None),
("instance", ED_INST_DICT, None),
("component", None, None),
("source", "self._EncodeImportExportIO(%s)", "Export source"),
("source", ED_IMPEXP_IO, "Export source"),
], None, "Starts an export daemon"),
("impexp_status", SINGLE, TMO_FAST, [
("names", None, "Import/export names"),
......@@ -188,8 +193,8 @@ _IMPEXP_CALLS = [
("path", None, None),
], None, "Queries the export information in a given path"),
("finalize_export", SINGLE, TMO_NORMAL, [
("instance", INST_TO_DICT, None),
("snap_disks", "self._PrepareFinalizeExportDisks(%s)", None),
("instance", ED_INST_DICT, None),
("snap_disks", ED_FINALIZE_EXPORT_DISKS, None),
], None, "Request the completion of an export operation"),
("export_list", MULTI, TMO_FAST, [], None, "Gets the stored exports list"),
("export_remove", SINGLE, TMO_FAST, [
......@@ -211,90 +216,90 @@ _BLOCKDEV_CALLS = [
("devices", None, None),
], None, "Gets the sizes of requested block devices present on a node"),
("blockdev_create", SINGLE, TMO_NORMAL, [
("bdev", OBJECT_TO_DICT, None),
("bdev", ED_OBJECT_DICT, None),
("size", None, None),
("owner", None, None),
("on_primary", None, None),
("info", None, None),
], None, "Request creation of a given block device"),
("blockdev_wipe", SINGLE, TMO_SLOW, [
("bdev", OBJECT_TO_DICT, None),
("bdev", ED_OBJECT_DICT, None),
("offset", None, None),
("size", None, None),
], None,
"Request wipe at given offset with given size of a block device"),
("blockdev_remove", SINGLE, TMO_NORMAL, [
("bdev", OBJECT_TO_DICT, None),
("bdev", ED_OBJECT_DICT, None),
], None, "Request removal of a given block device"),
("blockdev_pause_resume_sync", SINGLE, TMO_NORMAL, [
("disks", OBJECT_LIST_TO_DICT, None),
("disks", ED_OBJECT_DICT_LIST, None),
("pause", None, None),
], None, "Request a pause/resume of given block device"),
("blockdev_assemble", SINGLE, TMO_NORMAL, [
("disk", OBJECT_TO_DICT, None),
("disk", ED_OBJECT_DICT, None),
("owner", None, None),
("on_primary", None, None),
("idx", None, None),
], None, "Request assembling of a given block device"),
("blockdev_shutdown", SINGLE, TMO_NORMAL, [
("disk", OBJECT_TO_DICT, None),
("disk", ED_OBJECT_DICT, None),
], None, "Request shutdown of a given block device"),
("blockdev_addchildren", SINGLE, TMO_NORMAL, [
("bdev", OBJECT_TO_DICT, None),
("ndevs", OBJECT_LIST_TO_DICT, None),
("bdev", ED_OBJECT_DICT, None),
("ndevs", ED_OBJECT_DICT_LIST, None),
], None, "Request adding a list of children to a (mirroring) device"),
("blockdev_removechildren", SINGLE, TMO_NORMAL, [
("bdev", OBJECT_TO_DICT, None),
("ndevs", OBJECT_LIST_TO_DICT, None),
("bdev", ED_OBJECT_DICT, None),
("ndevs", ED_OBJECT_DICT_LIST, None),
], None, "Request removing a list of children from a (mirroring) device"),
("blockdev_close", SINGLE, TMO_NORMAL, [
("instance_name", None, None),
("disks", OBJECT_LIST_TO_DICT, None),
("disks", ED_OBJECT_DICT_LIST, None),
], None, "Closes the given block devices"),
("blockdev_getsize", SINGLE, TMO_NORMAL, [
("disks", OBJECT_LIST_TO_DICT, None),
("disks", ED_OBJECT_DICT_LIST, None),
], None, "Returns the size of the given disks"),
("drbd_disconnect_net", MULTI, TMO_NORMAL, [
("nodes_ip", None, None),
("disks", OBJECT_LIST_TO_DICT, None),
("disks", ED_OBJECT_DICT_LIST, None),
], None, "Disconnects the network of the given drbd devices"),
("drbd_attach_net", MULTI, TMO_NORMAL, [
("nodes_ip", None, None),
("disks", OBJECT_LIST_TO_DICT, None),
("disks", ED_OBJECT_DICT_LIST, None),
("instance_name", None, None),
("multimaster", None, None),
], None, "Connects the given DRBD devices"),
("drbd_wait_sync", MULTI, TMO_SLOW, [
("nodes_ip", None, None),
("disks", OBJECT_LIST_TO_DICT, None),
("disks", ED_OBJECT_DICT_LIST, None),
], None, "Waits for the synchronization of drbd devices is complete"),
("blockdev_grow", SINGLE, TMO_NORMAL, [
("cf_bdev", OBJECT_TO_DICT, None),
("cf_bdev", ED_OBJECT_DICT, None),
("amount", None, None),
("dryrun", None, None),
], None, "Request a snapshot of the given block device"),
("blockdev_export", SINGLE, TMO_1DAY, [
("cf_bdev", OBJECT_TO_DICT, None),
("cf_bdev", ED_OBJECT_DICT, None),
("dest_node", None, None),
("dest_path", None, None),
("cluster_name", None, None),
], None, "Export a given disk to another node"),
("blockdev_snapshot", SINGLE, TMO_NORMAL, [
("cf_bdev", OBJECT_TO_DICT, None),
("cf_bdev", ED_OBJECT_DICT, None),
], None, "Export a given disk to another node"),
("blockdev_rename", SINGLE, TMO_NORMAL, [
("devlist", "[(d.ToDict(), uid) for d, uid in %s]", None),
("devlist", ED_BLOCKDEV_RENAME, None),
], None, "Request rename of the given block devices"),
("blockdev_find", SINGLE, TMO_NORMAL, [
("disk", OBJECT_TO_DICT, None),
("disk", ED_OBJECT_DICT, None),
], "self._BlockdevFindPostProc",
"Request identification of a given block device"),
("blockdev_getmirrorstatus", SINGLE, TMO_NORMAL, [
("disks", OBJECT_LIST_TO_DICT, None),
("disks", ED_OBJECT_DICT_LIST, None),
], "self._BlockdevGetMirrorStatusPostProc",
"Request status of a (mirroring) device"),
("blockdev_getmirrorstatus_multi", MULTI, TMO_NORMAL, [
("node_disks", NODE_TO_DISK_DICT, None),
("node_disks", ED_NODE_TO_DISK_DICT, None),
], "self._BlockdevGetMirrorStatusMultiPostProc",
"Request status of (mirroring) devices from multiple nodes"),
]
......@@ -382,7 +387,7 @@ CALLS = {
"RpcClientJobQueue": [
("jobqueue_update", MULTI, TMO_URGENT, [
("file_name", None, None),
("content", "self._Compress(%s)", None),
("content", ED_COMPRESS, None),
], None, "Update job queue file"),