libnm: rework checkpoint API

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.

6 files changed, 134 insertions, 130 deletions

diff --git a/examples/python/gi/checkpoint.py b/examples/python/gi/checkpoint.py
index 49d4a1c7ac..7c36cdba57 100755
--- a/examples/python/gi/checkpoint.py
+++ b/examples/python/gi/checkpoint.py
@@ -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("  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):
     flags = NM.CheckpointCreateFlags.NONE
     if len(sys.argv) < 3:
@@ -76,27 +99,13 @@ def do_create(client):
             sys.stderr.write("Failed: %s\n" % e.message)
         main_loop.quit()
 
-    client.checkpoint_create_async(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
+    client.checkpoint_create(devices, timeout, flags, None, create_cb, None)
 
 def do_destroy(client):
     if len(sys.argv) < 3:
         sys.exit("Missing checkpoint path")
 
-    checkpoint = find_checkpoint(client, sys.argv[2])
-    if checkpoint is None:
-        sys.exit("Unknown checkpoint %s" % sys.argv[2])
+    path = validate_path(sys.argv[2], client)
 
     def destroy_cb(client, result, data):
         try:
@@ -106,15 +115,13 @@ def do_destroy(client):
             sys.stderr.write("Failed: %s\n" % e.message)
         main_loop.quit()
 
-    client.checkpoint_destroy_async(checkpoint, None, destroy_cb, None)
+    client.checkpoint_destroy(path, None, destroy_cb, None)
 
 def do_rollback(client):
     if len(sys.argv) < 3:
         sys.exit("Missing checkpoint path")
 
-    checkpoint = find_checkpoint(client, sys.argv[2])
-    if checkpoint is None:
-        sys.exit("Unknown checkpoint %s" % sys.argv[2])
+    path = validate_path(sys.argv[2], client)
 
     def rollback_cb(client, result, data):
         try:
@@ -130,7 +137,7 @@ def do_rollback(client):
             sys.stderr.write("Failed: %s\n" % e.message)
         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):
     if len(sys.argv) < 3:
@@ -142,9 +149,7 @@ def do_adjust_rollback_timeout(client):
     except:
         sys.exit("Invalid timeout")
 
-    checkpoint = find_checkpoint(client, sys.argv[2])
-    if checkpoint is None:
-        sys.exit("Unknown checkpoint %s" % sys.argv[2])
+    path = validate_path(sys.argv[2], client)
 
     def adjust_rollback_timeout_cb(client, result, data):
         try:
@@ -154,7 +159,7 @@ def do_adjust_rollback_timeout(client):
             sys.stderr.write("Failed: %s\n" % e.message)
         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):
     ts = nmex.nm_boot_time_ms()
diff --git a/libnm/libnm.ver b/libnm/libnm.ver
index 05716519d0..386216184e 100644
--- a/libnm/libnm.ver
+++ b/libnm/libnm.ver
@@ -1341,11 +1341,11 @@ global:
 	nm_checkpoint_get_type;
 	nm_client_checkpoint_adjust_rollback_timeout;
 	nm_client_checkpoint_adjust_rollback_timeout_finish;
-	nm_client_checkpoint_create_async;
+	nm_client_checkpoint_create;
 	nm_client_checkpoint_create_finish;
-	nm_client_checkpoint_destroy_async;
+	nm_client_checkpoint_destroy;
 	nm_client_checkpoint_destroy_finish;
-	nm_client_checkpoint_rollback_async;
+	nm_client_checkpoint_rollback;
 	nm_client_checkpoint_rollback_finish;
 	nm_client_get_checkpoints;
 	nm_device_ip_tunnel_get_flags;
diff --git a/libnm/nm-client.c b/libnm/nm-client.c
index 9cc36d11e7..a31a0845e5 100644
--- a/libnm/nm-client.c
+++ b/libnm/nm-client.c
@@ -2121,7 +2121,7 @@ nm_client_get_checkpoints (NMClient *client)
 }
 
 /**
- * nm_client_checkpoint_create_async:
+ * nm_client_checkpoint_create:
  * @client: the %NMClient
  * @devices: (element-type NMDevice): a list of devices for which a
  *   checkpoint should be created.
@@ -2139,13 +2139,13 @@ nm_client_get_checkpoints (NMClient *client)
  * Since: 1.12
  **/
 void
-nm_client_checkpoint_create_async (NMClient *client,
-                                   const GPtrArray *devices,
-                                   guint32 rollback_timeout,
-                                   NMCheckpointCreateFlags flags,
-                                   GCancellable *cancellable,
-                                   GAsyncReadyCallback callback,
-                                   gpointer user_data)
+nm_client_checkpoint_create (NMClient *client,
+                             const GPtrArray *devices,
+                             guint32 rollback_timeout,
+                             NMCheckpointCreateFlags flags,
+                             GCancellable *cancellable,
+                             GAsyncReadyCallback callback,
+                             gpointer user_data)
 {
 	GSimpleAsyncResult *simple;
 	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,
-	                                    nm_client_checkpoint_create_async);
+	                                    nm_client_checkpoint_create);
 	if (cancellable)
 		g_simple_async_result_set_check_cancellable (simple, cancellable);
-	nm_manager_checkpoint_create_async (NM_CLIENT_GET_PRIVATE (client)->manager,
-	                                    devices, rollback_timeout, flags,
-	                                    cancellable, checkpoint_create_cb, simple);
+	nm_manager_checkpoint_create (NM_CLIENT_GET_PRIVATE (client)->manager,
+	                              devices, rollback_timeout, flags,
+	                              cancellable, checkpoint_create_cb, simple);
 }
 
 /**
@@ -2172,7 +2172,7 @@ nm_client_checkpoint_create_async (NMClient *client,
  * @result: the result passed to the #GAsyncReadyCallback
  * @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
  *   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
- * @checkpoint: a checkpoint
+ * @checkpoint_path: the D-Bus path for the checkpoint
  * @cancellable: a #GCancellable, or %NULL
  * @callback: (scope async): callback to be called when the add operation completes
  * @user_data: (closure): caller-specific data passed to @callback
@@ -2226,16 +2226,17 @@ checkpoint_destroy_cb (GObject *object,
  * Since: 1.12
  **/
 void
-nm_client_checkpoint_destroy_async (NMClient *client,
-                                    NMCheckpoint *checkpoint,
-                                    GCancellable *cancellable,
-                                    GAsyncReadyCallback callback,
-                                    gpointer user_data)
+nm_client_checkpoint_destroy (NMClient *client,
+                              const char *checkpoint_path,
+                              GCancellable *cancellable,
+                              GAsyncReadyCallback callback,
+                              gpointer user_data)
 {
 	GSimpleAsyncResult *simple;
 	GError *error = NULL;
 
 	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)) {
 		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,
-	                                    nm_client_checkpoint_destroy_async);
+	                                    nm_client_checkpoint_destroy);
 	if (cancellable)
 		g_simple_async_result_set_check_cancellable (simple, cancellable);
-	nm_manager_checkpoint_destroy_async (NM_CLIENT_GET_PRIVATE (client)->manager,
-	                                     checkpoint,
-	                                     cancellable, checkpoint_destroy_cb, simple);
+	nm_manager_checkpoint_destroy (NM_CLIENT_GET_PRIVATE (client)->manager,
+	                               checkpoint_path,
+	                               cancellable, checkpoint_destroy_cb, simple);
 }
 
 /**
@@ -2257,7 +2258,7 @@ nm_client_checkpoint_destroy_async (NMClient *client,
  * @result: the result passed to the #GAsyncReadyCallback
  * @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
  *   @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
- * @checkpoint: a checkpoint
+ * @checkpoint_path: the D-Bus path to the checkpoint
  * @cancellable: a #GCancellable, or %NULL
  * @callback: (scope async): callback to be called when the add operation completes
  * @user_data: (closure): caller-specific data passed to @callback
@@ -2313,16 +2314,17 @@ checkpoint_rollback_cb (GObject *object,
  * Since: 1.12
  **/
 void
-nm_client_checkpoint_rollback_async (NMClient *client,
-                                     NMCheckpoint *checkpoint,
-                                     GCancellable *cancellable,
-                                     GAsyncReadyCallback callback,
-                                     gpointer user_data)
+nm_client_checkpoint_rollback (NMClient *client,
+                               const char *checkpoint_path,
+                               GCancellable *cancellable,
+                               GAsyncReadyCallback callback,
+                               gpointer user_data)
 {
 	GSimpleAsyncResult *simple;
 	GError *error = NULL;
 
 	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)) {
 		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,
-	                                    nm_client_checkpoint_rollback_async);
+	                                    nm_client_checkpoint_rollback);
 	if (cancellable)
 		g_simple_async_result_set_check_cancellable (simple, cancellable);
-	nm_manager_checkpoint_rollback_async (NM_CLIENT_GET_PRIVATE (client)->manager,
-	                                      checkpoint,
-	                                      cancellable, checkpoint_rollback_cb, simple);
+	nm_manager_checkpoint_rollback (NM_CLIENT_GET_PRIVATE (client)->manager,
+	                                checkpoint_path,
+	                                cancellable, checkpoint_rollback_cb, simple);
 }
 
 /**
@@ -2344,7 +2346,7 @@ nm_client_checkpoint_rollback_async (NMClient *client,
  * @result: the result passed to the #GAsyncReadyCallback
  * @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
  *   devices and results. Devices are represented by their original
@@ -2415,6 +2417,7 @@ nm_client_checkpoint_adjust_rollback_timeout (NMClient *client,
 	GError *error = NULL;
 
 	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)) {
 		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,
-	                                    nm_client_checkpoint_rollback_async);
+	                                    nm_client_checkpoint_rollback);
 	if (cancellable)
 		g_simple_async_result_set_check_cancellable (simple, cancellable);
 	nm_manager_checkpoint_adjust_rollback_timeout (NM_CLIENT_GET_PRIVATE (client)->manager,
diff --git a/libnm/nm-client.h b/libnm/nm-client.h
index f7ec4b7a2c..6f4a86c957 100644
--- a/libnm/nm-client.h
+++ b/libnm/nm-client.h
@@ -408,35 +408,35 @@ NM_AVAILABLE_IN_1_12
 const GPtrArray *nm_client_get_checkpoints (NMClient *client);
 
 NM_AVAILABLE_IN_1_12
-void nm_client_checkpoint_create_async (NMClient *client,
-                                        const GPtrArray *devices,
-                                        guint32 rollback_timeout,
-                                        NMCheckpointCreateFlags flags,
-                                        GCancellable *cancellable,
-                                        GAsyncReadyCallback callback,
-                                        gpointer user_data);
+void nm_client_checkpoint_create (NMClient *client,
+                                  const GPtrArray *devices,
+                                  guint32 rollback_timeout,
+                                  NMCheckpointCreateFlags flags,
+                                  GCancellable *cancellable,
+                                  GAsyncReadyCallback callback,
+                                  gpointer user_data);
 NM_AVAILABLE_IN_1_12
 NMCheckpoint *nm_client_checkpoint_create_finish (NMClient *client,
                                                   GAsyncResult *result,
                                                   GError **error);
 
 NM_AVAILABLE_IN_1_12
-void nm_client_checkpoint_destroy_async (NMClient *client,
-                                         NMCheckpoint *checkpoint,
-                                         GCancellable *cancellable,
-                                         GAsyncReadyCallback callback,
-                                         gpointer user_data);
+void nm_client_checkpoint_destroy (NMClient *client,
+                                   const char *checkpoint_path,
+                                   GCancellable *cancellable,
+                                   GAsyncReadyCallback callback,
+                                   gpointer user_data);
 NM_AVAILABLE_IN_1_12
 gboolean nm_client_checkpoint_destroy_finish (NMClient *client,
                                               GAsyncResult *result,
                                               GError **error);
 
 NM_AVAILABLE_IN_1_12
-void nm_client_checkpoint_rollback_async (NMClient *client,
-                                          NMCheckpoint *checkpoint,
-                                          GCancellable *cancellable,
-                                          GAsyncReadyCallback callback,
-                                          gpointer user_data);
+void nm_client_checkpoint_rollback (NMClient *client,
+                                    const char *checkpoint_path,
+                                    GCancellable *cancellable,
+                                    GAsyncReadyCallback callback,
+                                    gpointer user_data);
 NM_AVAILABLE_IN_1_12
 GHashTable *nm_client_checkpoint_rollback_finish (NMClient *client,
                                                   GAsyncResult *result,
diff --git a/libnm/nm-manager.c b/libnm/nm-manager.c
index 57af227c23..52b2e13510 100644
--- a/libnm/nm-manager.c
+++ b/libnm/nm-manager.c
@@ -1362,13 +1362,13 @@ checkpoint_created_cb (GObject *object,
 }
 
 void
-nm_manager_checkpoint_create_async (NMManager *manager,
-                                    const GPtrArray *devices,
-                                    guint32 rollback_timeout,
-                                    NMCheckpointCreateFlags flags,
-                                    GCancellable *cancellable,
-                                    GAsyncReadyCallback callback,
-                                    gpointer user_data)
+nm_manager_checkpoint_create (NMManager *manager,
+                              const GPtrArray *devices,
+                              guint32 rollback_timeout,
+                              NMCheckpointCreateFlags flags,
+                              GCancellable *cancellable,
+                              GAsyncReadyCallback callback,
+                              gpointer user_data)
 {
 	NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (manager);
 	gs_free const char **paths = NULL;
@@ -1379,7 +1379,7 @@ nm_manager_checkpoint_create_async (NMManager *manager,
 	info = g_slice_new0 (CheckpointInfo);
 	info->manager = manager;
 	info->simple = g_simple_async_result_new (G_OBJECT (manager), callback, user_data,
-	                                          nm_manager_checkpoint_create_async);
+	                                          nm_manager_checkpoint_create);
 	if (cancellable)
 		g_simple_async_result_set_check_cancellable (info->simple, cancellable);
 	paths = get_device_paths (devices);
@@ -1430,26 +1430,24 @@ checkpoint_destroy_cb (GObject *object,
 }
 
 void
-nm_manager_checkpoint_destroy_async (NMManager *manager,
-                                     NMCheckpoint *checkpoint,
-                                     GCancellable *cancellable,
-                                     GAsyncReadyCallback callback,
-                                     gpointer user_data)
+nm_manager_checkpoint_destroy (NMManager *manager,
+                               const char *checkpoint_path,
+                               GCancellable *cancellable,
+                               GAsyncReadyCallback callback,
+                               gpointer user_data)
 {
-	const char *path;
 	GSimpleAsyncResult *simple;
 
 	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,
-	                                    nm_manager_checkpoint_destroy_async);
+	                                    nm_manager_checkpoint_destroy);
 	if (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,
-	                                        path,
+	                                        checkpoint_path,
 	                                        cancellable,
 	                                        checkpoint_destroy_cb, simple);
 }
@@ -1462,7 +1460,7 @@ nm_manager_checkpoint_destroy_finish (NMManager *manager,
 	GSimpleAsyncResult *simple;
 
 	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);
 
 	simple = G_SIMPLE_ASYNC_RESULT (result);
@@ -1503,26 +1501,24 @@ checkpoint_rollback_cb (GObject *object,
 }
 
 void
-nm_manager_checkpoint_rollback_async (NMManager *manager,
-                                      NMCheckpoint *checkpoint,
-                                      GCancellable *cancellable,
-                                      GAsyncReadyCallback callback,
-                                      gpointer user_data)
+nm_manager_checkpoint_rollback (NMManager *manager,
+                                const char *checkpoint_path,
+                                GCancellable *cancellable,
+                                GAsyncReadyCallback callback,
+                                gpointer user_data)
 {
-	const char *path;
 	GSimpleAsyncResult *simple;
 
 	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,
-	                                    nm_manager_checkpoint_rollback_async);
+	                                    nm_manager_checkpoint_rollback);
 	if (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,
-	                                         path,
+	                                         checkpoint_path,
 	                                         cancellable,
 	                                         checkpoint_rollback_cb, simple);
 }
@@ -1535,7 +1531,7 @@ nm_manager_checkpoint_rollback_finish (NMManager *manager,
 	GSimpleAsyncResult *simple;
 
 	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);
 
 	simple = G_SIMPLE_ASYNC_RESULT (result);
diff --git a/libnm/nm-manager.h b/libnm/nm-manager.h
index 1d45bf3c2a..0a278aee58 100644
--- a/libnm/nm-manager.h
+++ b/libnm/nm-manager.h
@@ -184,29 +184,29 @@ gboolean nm_manager_deactivate_connection_finish (NMManager *manager,
                                                   GError **error);
 
 const GPtrArray *nm_manager_get_checkpoints (NMManager *manager);
-void nm_manager_checkpoint_create_async (NMManager *manager,
-                                         const GPtrArray *devices,
-                                         guint32 rollback_timeout,
-                                         NMCheckpointCreateFlags flags,
-                                         GCancellable *cancellable,
-                                         GAsyncReadyCallback callback,
-                                         gpointer user_data);
+void nm_manager_checkpoint_create (NMManager *manager,
+                                   const GPtrArray *devices,
+                                   guint32 rollback_timeout,
+                                   NMCheckpointCreateFlags flags,
+                                   GCancellable *cancellable,
+                                   GAsyncReadyCallback callback,
+                                   gpointer user_data);
 NMCheckpoint *nm_manager_checkpoint_create_finish (NMManager *manager,
                                                    GAsyncResult *result,
                                                    GError **error);
-void nm_manager_checkpoint_destroy_async (NMManager *manager,
-                                          NMCheckpoint *checkpoint,
-                                          GCancellable *cancellable,
-                                          GAsyncReadyCallback callback,
-                                          gpointer user_data);
+void nm_manager_checkpoint_destroy (NMManager *manager,
+                                    const char *checkpoint_path,
+                                    GCancellable *cancellable,
+                                    GAsyncReadyCallback callback,
+                                    gpointer user_data);
 gboolean nm_manager_checkpoint_destroy_finish (NMManager *manager,
                                                GAsyncResult *result,
                                                GError **error);
-void nm_manager_checkpoint_rollback_async (NMManager *manager,
-                                           NMCheckpoint *checkpoint,
-                                           GCancellable *cancellable,
-                                           GAsyncReadyCallback callback,
-                                           gpointer user_data);
+void nm_manager_checkpoint_rollback (NMManager *manager,
+                                     const char *checkpoint_path,
+                                     GCancellable *cancellable,
+                                     GAsyncReadyCallback callback,
+                                     gpointer user_data);
 GHashTable *nm_manager_checkpoint_rollback_finish (NMManager *manager,
                                                    GAsyncResult *result,
                                                    GError **error);