system/NetworkManager
system/NetworkManager
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/NetworkManager/NetworkManager synced 2024-07-22 02:35:25 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

libnm: rework checkpoint API

Browse source 
The libnm API fir checkpoints was only introduced with 1.11. It
is not yet stable, so there is still time to adjust it. Note that
this changes API/ABI of the development branch.

Changes:

- we only add async variants of the checkpoint functions. I believe
  that synchronous D-Bus methods are fundamentally flawed, because
  they mess up the ordering of events.
  Rename the async functions by removing the "_async" suffix. This
  matches glib style, for which the async form is also not specially
  marked.

- for function that refere to a particular checkpoint (rollback and
  destroy), accept the D-Bus path as string, instead of an NMCheckpoint
  instance. This form is more flexible, because it allows to use
  the function without having a NMCheckpoint instance at hand. On the
  other hand, if one has a NMCheckpoint instance, he can trivially
  obtain the path to make the call.
This commit is contained in:
Thomas Haller 2018-04-04 13:33:53 +02:00
parent 8171362d02
commit 735dc41bd0
6 changed files with 134 additions and 130 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

55
examples/python/gi/checkpoint.py
View file

@ -46,6 +46,29 @@ def show(c, ts = None):
print(" timeout: %u seconds%s" % (rt, "" if ts is None else (" (circa %s sec left)" % ((cr + (rt * 1000) - ts) / 1000.0)))) print(" timeout: %u seconds%s" % (rt, "" if ts is None else (" (circa %s sec left)" % ((cr + (rt * 1000) - ts) / 1000.0))))
print(" devices: %s" % (' '.join(sorted(map(lambda x: x.get_iface(), c.get_devices()))))) print(" devices: %s" % (' '.join(sorted(map(lambda x: x.get_iface(), c.get_devices())))))
def find_checkpoint(client, path):
for c in client.get_checkpoints():
if c.get_path() == path:
return c
return None
def validate_path(path, client):
try:
num = int(path)
path = "/org/freedesktop/NetworkManager/Checkpoint/%u" % (num)
except Exception as e:
pass
if not path or path[0] != '/':
sys.exit('Invalid checkpoint path \"%s\"' % (path))
if client is not None:
checkpoint = find_checkpoint(client, path)
if checkpoint is None:
print('WARNING: no checkpoint with path "%s" found' % (path))
return path
def do_create(client): def do_create(client):
flags = NM.CheckpointCreateFlags.NONE flags = NM.CheckpointCreateFlags.NONE
if len(sys.argv) < 3: if len(sys.argv) < 3:
@ -76,27 +99,13 @@ def do_create(client):
sys.stderr.write("Failed: %s\n" % e.message) sys.stderr.write("Failed: %s\n" % e.message)
main_loop.quit() main_loop.quit()
client.checkpoint_create_async(devices, timeout, flags, None, create_cb, None) client.checkpoint_create(devices, timeout, flags, None, create_cb, None)
def find_checkpoint(client, arg):
try:
num = int(arg)
path = "/org/freedesktop/NetworkManager/Checkpoint/%u" % num
except Exception as e:
path = arg
for c in client.get_checkpoints():
if c.get_path() == path:
return c
return None
def do_destroy(client): def do_destroy(client):
if len(sys.argv) < 3: if len(sys.argv) < 3:
sys.exit("Missing checkpoint path") sys.exit("Missing checkpoint path")
checkpoint = find_checkpoint(client, sys.argv[2]) path = validate_path(sys.argv[2], client)
if checkpoint is None:
sys.exit("Unknown checkpoint %s" % sys.argv[2])
def destroy_cb(client, result, data): def destroy_cb(client, result, data):
try: try:
@ -106,15 +115,13 @@ def do_destroy(client):
sys.stderr.write("Failed: %s\n" % e.message) sys.stderr.write("Failed: %s\n" % e.message)
main_loop.quit() main_loop.quit()
client.checkpoint_destroy_async(checkpoint, None, destroy_cb, None) client.checkpoint_destroy(path, None, destroy_cb, None)
def do_rollback(client): def do_rollback(client):
if len(sys.argv) < 3: if len(sys.argv) < 3:
sys.exit("Missing checkpoint path") sys.exit("Missing checkpoint path")
checkpoint = find_checkpoint(client, sys.argv[2]) path = validate_path(sys.argv[2], client)
if checkpoint is None:
sys.exit("Unknown checkpoint %s" % sys.argv[2])
def rollback_cb(client, result, data): def rollback_cb(client, result, data):
try: try:
@ -130,7 +137,7 @@ def do_rollback(client):
sys.stderr.write("Failed: %s\n" % e.message) sys.stderr.write("Failed: %s\n" % e.message)
main_loop.quit() main_loop.quit()
client.checkpoint_rollback_async(checkpoint, None, rollback_cb, None) client.checkpoint_rollback(path, None, rollback_cb, None)
def do_adjust_rollback_timeout(client): def do_adjust_rollback_timeout(client):
if len(sys.argv) < 3: if len(sys.argv) < 3:
@ -142,9 +149,7 @@ def do_adjust_rollback_timeout(client):
except: except:
sys.exit("Invalid timeout") sys.exit("Invalid timeout")
checkpoint = find_checkpoint(client, sys.argv[2]) path = validate_path(sys.argv[2], client)
if checkpoint is None:
sys.exit("Unknown checkpoint %s" % sys.argv[2])
def adjust_rollback_timeout_cb(client, result, data): def adjust_rollback_timeout_cb(client, result, data):
try: try:
@ -154,7 +159,7 @@ def do_adjust_rollback_timeout(client):
sys.stderr.write("Failed: %s\n" % e.message) sys.stderr.write("Failed: %s\n" % e.message)
main_loop.quit() main_loop.quit()
client.checkpoint_adjust_rollback_timeout(checkpoint.get_path(), add_timeout, None, adjust_rollback_timeout_cb, None) client.checkpoint_adjust_rollback_timeout(path, add_timeout, None, adjust_rollback_timeout_cb, None)
def do_show(client): def do_show(client):
ts = nmex.nm_boot_time_ms() ts = nmex.nm_boot_time_ms()

6
libnm/libnm.ver
View file

@ -1341,11 +1341,11 @@ global:
nm_checkpoint_get_type; nm_checkpoint_get_type;
nm_client_checkpoint_adjust_rollback_timeout; nm_client_checkpoint_adjust_rollback_timeout;
nm_client_checkpoint_adjust_rollback_timeout_finish; nm_client_checkpoint_adjust_rollback_timeout_finish;
nm_client_checkpoint_create_async; nm_client_checkpoint_create;
nm_client_checkpoint_create_finish; nm_client_checkpoint_create_finish;
nm_client_checkpoint_destroy_async; nm_client_checkpoint_destroy;
nm_client_checkpoint_destroy_finish; nm_client_checkpoint_destroy_finish;
nm_client_checkpoint_rollback_async; nm_client_checkpoint_rollback;
nm_client_checkpoint_rollback_finish; nm_client_checkpoint_rollback_finish;
nm_client_get_checkpoints; nm_client_get_checkpoints;
nm_device_ip_tunnel_get_flags; nm_device_ip_tunnel_get_flags;

79
libnm/nm-client.c
View file

@ -2121,7 +2121,7 @@ nm_client_get_checkpoints (NMClient *client)
} }
/** /**
* nm_client_checkpoint_create_async: * nm_client_checkpoint_create:
* @client: the %NMClient * @client: the %NMClient
* @devices: (element-type NMDevice): a list of devices for which a * @devices: (element-type NMDevice): a list of devices for which a
* checkpoint should be created. * checkpoint should be created.
@ -2139,13 +2139,13 @@ nm_client_get_checkpoints (NMClient *client)
* Since: 1.12 * Since: 1.12
**/ **/
void void
nm_client_checkpoint_create_async (NMClient *client, nm_client_checkpoint_create (NMClient *client,
const GPtrArray *devices, const GPtrArray *devices,
guint32 rollback_timeout, guint32 rollback_timeout,
NMCheckpointCreateFlags flags, NMCheckpointCreateFlags flags,
GCancellable *cancellable, GCancellable *cancellable,
GAsyncReadyCallback callback, GAsyncReadyCallback callback,
gpointer user_data) gpointer user_data)
{ {
GSimpleAsyncResult *simple; GSimpleAsyncResult *simple;
GError *error = NULL; GError *error = NULL;
@ -2158,12 +2158,12 @@ nm_client_checkpoint_create_async (NMClient *client,
} }
simple = g_simple_async_result_new (G_OBJECT (client), callback, user_data, simple = g_simple_async_result_new (G_OBJECT (client), callback, user_data,
nm_client_checkpoint_create_async); nm_client_checkpoint_create);
if (cancellable) if (cancellable)
g_simple_async_result_set_check_cancellable (simple, cancellable); g_simple_async_result_set_check_cancellable (simple, cancellable);
nm_manager_checkpoint_create_async (NM_CLIENT_GET_PRIVATE (client)->manager, nm_manager_checkpoint_create (NM_CLIENT_GET_PRIVATE (client)->manager,
devices, rollback_timeout, flags, devices, rollback_timeout, flags,
cancellable, checkpoint_create_cb, simple); cancellable, checkpoint_create_cb, simple);
} }
/** /**
@ -2172,7 +2172,7 @@ nm_client_checkpoint_create_async (NMClient *client,
* @result: the result passed to the #GAsyncReadyCallback * @result: the result passed to the #GAsyncReadyCallback
* @error: location for a #GError, or %NULL * @error: location for a #GError, or %NULL
* *
* Gets the result of a call to nm_client_checkpoint_create_async(). * Gets the result of a call to nm_client_checkpoint_create().
* *
* Returns: (transfer full): the new #NMCheckpoint on success, %NULL on * Returns: (transfer full): the new #NMCheckpoint on success, %NULL on
* failure, in which case @error will be set. * failure, in which case @error will be set.
@ -2214,9 +2214,9 @@ checkpoint_destroy_cb (GObject *object,
} }
/** /**
* nm_client_checkpoint_destroy_async: * nm_client_checkpoint_destroy:
* @client: the %NMClient * @client: the %NMClient
* @checkpoint: a checkpoint * @checkpoint_path: the D-Bus path for the checkpoint
* @cancellable: a #GCancellable, or %NULL * @cancellable: a #GCancellable, or %NULL
* @callback: (scope async): callback to be called when the add operation completes * @callback: (scope async): callback to be called when the add operation completes
* @user_data: (closure): caller-specific data passed to @callback * @user_data: (closure): caller-specific data passed to @callback
@ -2226,16 +2226,17 @@ checkpoint_destroy_cb (GObject *object,
* Since: 1.12 * Since: 1.12
**/ **/
void void
nm_client_checkpoint_destroy_async (NMClient *client, nm_client_checkpoint_destroy (NMClient *client,
NMCheckpoint *checkpoint, const char *checkpoint_path,
GCancellable *cancellable, GCancellable *cancellable,
GAsyncReadyCallback callback, GAsyncReadyCallback callback,
gpointer user_data) gpointer user_data)
{ {
GSimpleAsyncResult *simple; GSimpleAsyncResult *simple;
GError *error = NULL; GError *error = NULL;
g_return_if_fail (NM_IS_CLIENT (client)); g_return_if_fail (NM_IS_CLIENT (client));
g_return_if_fail (checkpoint_path && checkpoint_path[0] == '/');
if (!_nm_client_check_nm_running (client, &error)) { if (!_nm_client_check_nm_running (client, &error)) {
g_simple_async_report_take_gerror_in_idle (G_OBJECT (client), callback, user_data, error); g_simple_async_report_take_gerror_in_idle (G_OBJECT (client), callback, user_data, error);
@ -2243,12 +2244,12 @@ nm_client_checkpoint_destroy_async (NMClient *client,
} }
simple = g_simple_async_result_new (G_OBJECT (client), callback, user_data, simple = g_simple_async_result_new (G_OBJECT (client), callback, user_data,
nm_client_checkpoint_destroy_async); nm_client_checkpoint_destroy);
if (cancellable) if (cancellable)
g_simple_async_result_set_check_cancellable (simple, cancellable); g_simple_async_result_set_check_cancellable (simple, cancellable);
nm_manager_checkpoint_destroy_async (NM_CLIENT_GET_PRIVATE (client)->manager, nm_manager_checkpoint_destroy (NM_CLIENT_GET_PRIVATE (client)->manager,
checkpoint, checkpoint_path,
cancellable, checkpoint_destroy_cb, simple); cancellable, checkpoint_destroy_cb, simple);
} }
/** /**
@ -2257,7 +2258,7 @@ nm_client_checkpoint_destroy_async (NMClient *client,
* @result: the result passed to the #GAsyncReadyCallback * @result: the result passed to the #GAsyncReadyCallback
* @error: location for a #GError, or %NULL * @error: location for a #GError, or %NULL
* *
* Gets the result of a call to nm_client_checkpoint_destroy_async(). * Gets the result of a call to nm_client_checkpoint_destroy().
* *
* Returns: %TRUE on success or %FALSE on failure, in which case * Returns: %TRUE on success or %FALSE on failure, in which case
* @error will be set. * @error will be set.
@ -2301,9 +2302,9 @@ checkpoint_rollback_cb (GObject *object,
} }
/** /**
* nm_client_checkpoint_rollback_async: * nm_client_checkpoint_rollback:
* @client: the %NMClient * @client: the %NMClient
* @checkpoint: a checkpoint * @checkpoint_path: the D-Bus path to the checkpoint
* @cancellable: a #GCancellable, or %NULL * @cancellable: a #GCancellable, or %NULL
* @callback: (scope async): callback to be called when the add operation completes * @callback: (scope async): callback to be called when the add operation completes
* @user_data: (closure): caller-specific data passed to @callback * @user_data: (closure): caller-specific data passed to @callback
@ -2313,16 +2314,17 @@ checkpoint_rollback_cb (GObject *object,
* Since: 1.12 * Since: 1.12
**/ **/
void void
nm_client_checkpoint_rollback_async (NMClient *client, nm_client_checkpoint_rollback (NMClient *client,
NMCheckpoint *checkpoint, const char *checkpoint_path,
GCancellable *cancellable, GCancellable *cancellable,
GAsyncReadyCallback callback, GAsyncReadyCallback callback,
gpointer user_data) gpointer user_data)
{ {
GSimpleAsyncResult *simple; GSimpleAsyncResult *simple;
GError *error = NULL; GError *error = NULL;
g_return_if_fail (NM_IS_CLIENT (client)); g_return_if_fail (NM_IS_CLIENT (client));
g_return_if_fail (checkpoint_path && checkpoint_path[0] == '/');
if (!_nm_client_check_nm_running (client, &error)) { if (!_nm_client_check_nm_running (client, &error)) {
g_simple_async_report_take_gerror_in_idle (G_OBJECT (client), callback, user_data, error); g_simple_async_report_take_gerror_in_idle (G_OBJECT (client), callback, user_data, error);
@ -2330,12 +2332,12 @@ nm_client_checkpoint_rollback_async (NMClient *client,
} }
simple = g_simple_async_result_new (G_OBJECT (client), callback, user_data, simple = g_simple_async_result_new (G_OBJECT (client), callback, user_data,
nm_client_checkpoint_rollback_async); nm_client_checkpoint_rollback);
if (cancellable) if (cancellable)
g_simple_async_result_set_check_cancellable (simple, cancellable); g_simple_async_result_set_check_cancellable (simple, cancellable);
nm_manager_checkpoint_rollback_async (NM_CLIENT_GET_PRIVATE (client)->manager, nm_manager_checkpoint_rollback (NM_CLIENT_GET_PRIVATE (client)->manager,
checkpoint, checkpoint_path,
cancellable, checkpoint_rollback_cb, simple); cancellable, checkpoint_rollback_cb, simple);
} }
/** /**
@ -2344,7 +2346,7 @@ nm_client_checkpoint_rollback_async (NMClient *client,
* @result: the result passed to the #GAsyncReadyCallback * @result: the result passed to the #GAsyncReadyCallback
* @error: location for a #GError, or %NULL * @error: location for a #GError, or %NULL
* *
* Gets the result of a call to nm_client_checkpoint_rollback_async(). * Gets the result of a call to nm_client_checkpoint_rollback().
* *
* Returns: (transfer full) (element-type utf8 guint32): an hash table of * Returns: (transfer full) (element-type utf8 guint32): an hash table of
* devices and results. Devices are represented by their original * devices and results. Devices are represented by their original
@ -2415,6 +2417,7 @@ nm_client_checkpoint_adjust_rollback_timeout (NMClient *client,
GError *error = NULL; GError *error = NULL;
g_return_if_fail (NM_IS_CLIENT (client)); g_return_if_fail (NM_IS_CLIENT (client));
g_return_if_fail (checkpoint_path && checkpoint_path[0] == '/');
if (!_nm_client_check_nm_running (client, &error)) { if (!_nm_client_check_nm_running (client, &error)) {
g_simple_async_report_take_gerror_in_idle (G_OBJECT (client), callback, user_data, error); g_simple_async_report_take_gerror_in_idle (G_OBJECT (client), callback, user_data, error);
@ -2422,7 +2425,7 @@ nm_client_checkpoint_adjust_rollback_timeout (NMClient *client,
} }
simple = g_simple_async_result_new (G_OBJECT (client), callback, user_data, simple = g_simple_async_result_new (G_OBJECT (client), callback, user_data,
nm_client_checkpoint_rollback_async); nm_client_checkpoint_rollback);
if (cancellable) if (cancellable)
g_simple_async_result_set_check_cancellable (simple, cancellable); g_simple_async_result_set_check_cancellable (simple, cancellable);
nm_manager_checkpoint_adjust_rollback_timeout (NM_CLIENT_GET_PRIVATE (client)->manager, nm_manager_checkpoint_adjust_rollback_timeout (NM_CLIENT_GET_PRIVATE (client)->manager,

34
libnm/nm-client.h
View file

@ -408,35 +408,35 @@ NM_AVAILABLE_IN_1_12
const GPtrArray *nm_client_get_checkpoints (NMClient *client); const GPtrArray *nm_client_get_checkpoints (NMClient *client);
NM_AVAILABLE_IN_1_12 NM_AVAILABLE_IN_1_12
void nm_client_checkpoint_create_async (NMClient *client, void nm_client_checkpoint_create (NMClient *client,
const GPtrArray *devices, const GPtrArray *devices,
guint32 rollback_timeout, guint32 rollback_timeout,
NMCheckpointCreateFlags flags, NMCheckpointCreateFlags flags,
GCancellable *cancellable, GCancellable *cancellable,
GAsyncReadyCallback callback, GAsyncReadyCallback callback,
gpointer user_data); gpointer user_data);
NM_AVAILABLE_IN_1_12 NM_AVAILABLE_IN_1_12
NMCheckpoint *nm_client_checkpoint_create_finish (NMClient *client, NMCheckpoint *nm_client_checkpoint_create_finish (NMClient *client,
GAsyncResult *result, GAsyncResult *result,
GError **error); GError **error);
NM_AVAILABLE_IN_1_12 NM_AVAILABLE_IN_1_12
void nm_client_checkpoint_destroy_async (NMClient *client, void nm_client_checkpoint_destroy (NMClient *client,
NMCheckpoint *checkpoint, const char *checkpoint_path,
GCancellable *cancellable, GCancellable *cancellable,
GAsyncReadyCallback callback, GAsyncReadyCallback callback,
gpointer user_data); gpointer user_data);
NM_AVAILABLE_IN_1_12 NM_AVAILABLE_IN_1_12
gboolean nm_client_checkpoint_destroy_finish (NMClient *client, gboolean nm_client_checkpoint_destroy_finish (NMClient *client,
GAsyncResult *result, GAsyncResult *result,
GError **error); GError **error);
NM_AVAILABLE_IN_1_12 NM_AVAILABLE_IN_1_12
void nm_client_checkpoint_rollback_async (NMClient *client, void nm_client_checkpoint_rollback (NMClient *client,
NMCheckpoint *checkpoint, const char *checkpoint_path,
GCancellable *cancellable, GCancellable *cancellable,
GAsyncReadyCallback callback, GAsyncReadyCallback callback,
gpointer user_data); gpointer user_data);
NM_AVAILABLE_IN_1_12 NM_AVAILABLE_IN_1_12
GHashTable *nm_client_checkpoint_rollback_finish (NMClient *client, GHashTable *nm_client_checkpoint_rollback_finish (NMClient *client,
GAsyncResult *result, GAsyncResult *result,

56
libnm/nm-manager.c
View file

@ -1362,13 +1362,13 @@ checkpoint_created_cb (GObject *object,
} }
void void
nm_manager_checkpoint_create_async (NMManager *manager, nm_manager_checkpoint_create (NMManager *manager,
const GPtrArray *devices, const GPtrArray *devices,
guint32 rollback_timeout, guint32 rollback_timeout,
NMCheckpointCreateFlags flags, NMCheckpointCreateFlags flags,
GCancellable *cancellable, GCancellable *cancellable,
GAsyncReadyCallback callback, GAsyncReadyCallback callback,
gpointer user_data) gpointer user_data)
{ {
NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (manager); NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (manager);
gs_free const char **paths = NULL; gs_free const char **paths = NULL;
@ -1379,7 +1379,7 @@ nm_manager_checkpoint_create_async (NMManager *manager,
info = g_slice_new0 (CheckpointInfo); info = g_slice_new0 (CheckpointInfo);
info->manager = manager; info->manager = manager;
info->simple = g_simple_async_result_new (G_OBJECT (manager), callback, user_data, info->simple = g_simple_async_result_new (G_OBJECT (manager), callback, user_data,
nm_manager_checkpoint_create_async); nm_manager_checkpoint_create);
if (cancellable) if (cancellable)
g_simple_async_result_set_check_cancellable (info->simple, cancellable); g_simple_async_result_set_check_cancellable (info->simple, cancellable);
paths = get_device_paths (devices); paths = get_device_paths (devices);
@ -1430,26 +1430,24 @@ checkpoint_destroy_cb (GObject *object,
} }
void void
nm_manager_checkpoint_destroy_async (NMManager *manager, nm_manager_checkpoint_destroy (NMManager *manager,
NMCheckpoint *checkpoint, const char *checkpoint_path,
GCancellable *cancellable, GCancellable *cancellable,
GAsyncReadyCallback callback, GAsyncReadyCallback callback,
gpointer user_data) gpointer user_data)
{ {
const char *path;
GSimpleAsyncResult *simple; GSimpleAsyncResult *simple;
g_return_if_fail (NM_IS_MANAGER (manager)); g_return_if_fail (NM_IS_MANAGER (manager));
g_return_if_fail (NM_IS_CHECKPOINT (checkpoint)); g_return_if_fail (checkpoint_path && checkpoint_path[0] == '/');
simple = g_simple_async_result_new (G_OBJECT (manager), callback, user_data, simple = g_simple_async_result_new (G_OBJECT (manager), callback, user_data,
nm_manager_checkpoint_destroy_async); nm_manager_checkpoint_destroy);
if (cancellable) if (cancellable)
g_simple_async_result_set_check_cancellable (simple, cancellable); g_simple_async_result_set_check_cancellable (simple, cancellable);
path = nm_object_get_path (NM_OBJECT (checkpoint));
nmdbus_manager_call_checkpoint_destroy (NM_MANAGER_GET_PRIVATE (manager)->proxy, nmdbus_manager_call_checkpoint_destroy (NM_MANAGER_GET_PRIVATE (manager)->proxy,
path, checkpoint_path,
cancellable, cancellable,
checkpoint_destroy_cb, simple); checkpoint_destroy_cb, simple);
} }
@ -1462,7 +1460,7 @@ nm_manager_checkpoint_destroy_finish (NMManager *manager,
GSimpleAsyncResult *simple; GSimpleAsyncResult *simple;
g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (manager), g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (manager),
nm_manager_checkpoint_destroy_async), nm_manager_checkpoint_destroy),
FALSE); FALSE);
simple = G_SIMPLE_ASYNC_RESULT (result); simple = G_SIMPLE_ASYNC_RESULT (result);
@ -1503,26 +1501,24 @@ checkpoint_rollback_cb (GObject *object,
} }
void void
nm_manager_checkpoint_rollback_async (NMManager *manager, nm_manager_checkpoint_rollback (NMManager *manager,
NMCheckpoint *checkpoint, const char *checkpoint_path,
GCancellable *cancellable, GCancellable *cancellable,
GAsyncReadyCallback callback, GAsyncReadyCallback callback,
gpointer user_data) gpointer user_data)
{ {
const char *path;
GSimpleAsyncResult *simple; GSimpleAsyncResult *simple;
g_return_if_fail (NM_IS_MANAGER (manager)); g_return_if_fail (NM_IS_MANAGER (manager));
g_return_if_fail (NM_IS_CHECKPOINT (checkpoint)); g_return_if_fail (checkpoint_path && checkpoint_path[0] == '/');
simple = g_simple_async_result_new (G_OBJECT (manager), callback, user_data, simple = g_simple_async_result_new (G_OBJECT (manager), callback, user_data,
nm_manager_checkpoint_rollback_async); nm_manager_checkpoint_rollback);
if (cancellable) if (cancellable)
g_simple_async_result_set_check_cancellable (simple, cancellable); g_simple_async_result_set_check_cancellable (simple, cancellable);
path = nm_object_get_path (NM_OBJECT (checkpoint));
nmdbus_manager_call_checkpoint_rollback (NM_MANAGER_GET_PRIVATE (manager)->proxy, nmdbus_manager_call_checkpoint_rollback (NM_MANAGER_GET_PRIVATE (manager)->proxy,
path, checkpoint_path,
cancellable, cancellable,
checkpoint_rollback_cb, simple); checkpoint_rollback_cb, simple);
} }
@ -1535,7 +1531,7 @@ nm_manager_checkpoint_rollback_finish (NMManager *manager,
GSimpleAsyncResult *simple; GSimpleAsyncResult *simple;
g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (manager), g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (manager),
nm_manager_checkpoint_rollback_async), nm_manager_checkpoint_rollback),
NULL); NULL);
simple = G_SIMPLE_ASYNC_RESULT (result); simple = G_SIMPLE_ASYNC_RESULT (result);

34
libnm/nm-manager.h
View file

@ -184,29 +184,29 @@ gboolean nm_manager_deactivate_connection_finish (NMManager *manager,
GError **error); GError **error);
const GPtrArray *nm_manager_get_checkpoints (NMManager *manager); const GPtrArray *nm_manager_get_checkpoints (NMManager *manager);
void nm_manager_checkpoint_create_async (NMManager *manager, void nm_manager_checkpoint_create (NMManager *manager,
const GPtrArray *devices, const GPtrArray *devices,
guint32 rollback_timeout, guint32 rollback_timeout,
NMCheckpointCreateFlags flags, NMCheckpointCreateFlags flags,
GCancellable *cancellable, GCancellable *cancellable,
GAsyncReadyCallback callback, GAsyncReadyCallback callback,
gpointer user_data); gpointer user_data);
NMCheckpoint *nm_manager_checkpoint_create_finish (NMManager *manager, NMCheckpoint *nm_manager_checkpoint_create_finish (NMManager *manager,
GAsyncResult *result, GAsyncResult *result,
GError **error); GError **error);
void nm_manager_checkpoint_destroy_async (NMManager *manager, void nm_manager_checkpoint_destroy (NMManager *manager,
NMCheckpoint *checkpoint, const char *checkpoint_path,
GCancellable *cancellable, GCancellable *cancellable,
GAsyncReadyCallback callback, GAsyncReadyCallback callback,
gpointer user_data); gpointer user_data);
gboolean nm_manager_checkpoint_destroy_finish (NMManager *manager, gboolean nm_manager_checkpoint_destroy_finish (NMManager *manager,
GAsyncResult *result, GAsyncResult *result,
GError **error); GError **error);
void nm_manager_checkpoint_rollback_async (NMManager *manager, void nm_manager_checkpoint_rollback (NMManager *manager,
NMCheckpoint *checkpoint, const char *checkpoint_path,
GCancellable *cancellable, GCancellable *cancellable,
GAsyncReadyCallback callback, GAsyncReadyCallback callback,
gpointer user_data); gpointer user_data);
GHashTable *nm_manager_checkpoint_rollback_finish (NMManager *manager, GHashTable *nm_manager_checkpoint_rollback_finish (NMManager *manager,
GAsyncResult *result, GAsyncResult *result,
GError **error); GError **error);