keremet/rpm-ostree
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
ebc48d0158
rpm-ostree/src/daemon/transaction.c

677 lines
22 KiB
C
Raw Normal View History

daemon: Rework transactions A few changes: - Modify the D-Bus API to include a Finish() method instead of a Start() method, the idea being the client calls Finish() to obtain the final status and optional message once the transaction indicates it's done. Calling Finish() also removes the transaction object from the bus. - Introduce Transaction class as a thin wrapper for RPMOSTreeTransaction. Stores the status info for Finish(), detects when the caller's bus name vanishes, and emits various status signals to TransactionMonitor. - Introduce TransactionMonitor as a factory class for Transactions that also handles book keeping chores like tracking the active Transaction. The Sysroot and OS interfaces share a TransactionMonitor instance.
2015-07-23 18:30:33 +03:00
/*
* Copyright (C) 2015 Red Hat, Inc.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "config.h"
#include "ostree.h"
#include <libglnx.h>
#include "transaction.h"
#include "errors.h"
daemon: Convert transactions to subclasses Implementing a template pattern for transactions. The TransactionClass is now abstract, and transaction_new() is replaced with various method-specific functions like transaction_new_upgrade(). These custom subclasses live in a new file transaction-types.[ch]. Further, transaction_monitor_new_transaction() is replaced with transaction_monitor_add(). So the handlers for "OS" interface methods need only create an appropriate transaction instance and hand it off to the transaction monitor.
2015-08-13 20:17:01 +03:00
#include "sysroot.h"
daemon: Rework transactions A few changes: - Modify the D-Bus API to include a Finish() method instead of a Start() method, the idea being the client calls Finish() to obtain the final status and optional message once the transaction indicates it's done. Calling Finish() also removes the transaction object from the bus. - Introduce Transaction class as a thin wrapper for RPMOSTreeTransaction. Stores the status info for Finish(), detects when the caller's bus name vanishes, and emits various status signals to TransactionMonitor. - Introduce TransactionMonitor as a factory class for Transactions that also handles book keeping chores like tracking the active Transaction. The Sysroot and OS interfaces share a TransactionMonitor instance.
2015-07-23 18:30:33 +03:00
daemon: Prepare TransactionClass for subclassing Expose the instance and class structures, move instance members to a private structure. This is also towards having the TransactionClass follow a template pattern.
2015-08-13 19:53:58 +03:00
struct _TransactionPrivate {
daemon: Add "invocation" property to TransactionClass Move as much as possible out of transaction_new() for the benefit of subclasses. The GDBusMethodInvocation property for setting up D-Bus properties and name watching in the constructed() method.
2015-08-17 00:41:48 +03:00
GDBusMethodInvocation *invocation;
daemon: Implement GInitableIface in transactions Towards having the Transaction wrapper class follow a template pattern.
2015-08-13 17:03:56 +03:00
GCancellable *cancellable;
daemon: Rework transactions A few changes: - Modify the D-Bus API to include a Finish() method instead of a Start() method, the idea being the client calls Finish() to obtain the final status and optional message once the transaction indicates it's done. Calling Finish() also removes the transaction object from the bus. - Introduce Transaction class as a thin wrapper for RPMOSTreeTransaction. Stores the status info for Finish(), detects when the caller's bus name vanishes, and emits various status signals to TransactionMonitor. - Introduce TransactionMonitor as a factory class for Transactions that also handles book keeping chores like tracking the active Transaction. The Sysroot and OS interfaces share a TransactionMonitor instance.
2015-07-23 18:30:33 +03:00
daemon: Have Transaction objects handle sysroot locking Also, the Transaction holds an OstreeSysroot reference for its duration, which is convenient for callbacks.
2015-08-13 17:56:06 +03:00
/* Locked for the duration of the transaction. */
OstreeSysroot *sysroot;
daemon: Use a peer-to-peer connection for transactions Transaction progress and message signals are really only intended for one recipient: the client that invoked the method. Use a peer-to-peer connection for transactions so we're not spamming the system bus. This entails returning a bus address rather than an object path in methods that use transactions. The client opens a connection to the bus address, connects handlers to the Transaction interface (on path "/"), and then invokes the Start() method. To finish a transaction, the client need only close the connection, either explicitly or by terminating. The server will detect this and clean up resources for that transaction.
2015-08-17 20:42:03 +03:00
GDBusServer *server;
GDBusConnection *peer_connection;
daemon: Add a Start() method to transactions Turns out we do still need a Start() method after all. Not for lack of trying, but I can't get away from the client and server doing some sort of handshake at the beginning to avoid either raciness on the client side or artificial delays on the server side. I don't particularly like the "start" signal I've added -- I'd much prefer subclassing -- but I'm trying to keep the changes incremental.
2015-08-14 18:17:06 +03:00
gboolean started;
daemon: Rework transactions A few changes: - Modify the D-Bus API to include a Finish() method instead of a Start() method, the idea being the client calls Finish() to obtain the final status and optional message once the transaction indicates it's done. Calling Finish() also removes the transaction object from the bus. - Introduce Transaction class as a thin wrapper for RPMOSTreeTransaction. Stores the status info for Finish(), detects when the caller's bus name vanishes, and emits various status signals to TransactionMonitor. - Introduce TransactionMonitor as a factory class for Transactions that also handles book keeping chores like tracking the active Transaction. The Sysroot and OS interfaces share a TransactionMonitor instance.
2015-07-23 18:30:33 +03:00
gboolean success;
char *message;
guint watch_id;
};
enum {
daemon: Have Transaction objects handle sysroot locking Also, the Transaction holds an OstreeSysroot reference for its duration, which is convenient for callbacks.
2015-08-13 17:56:06 +03:00
PROP_0,
daemon: Add "invocation" property to TransactionClass Move as much as possible out of transaction_new() for the benefit of subclasses. The GDBusMethodInvocation property for setting up D-Bus properties and name watching in the constructed() method.
2015-08-17 00:41:48 +03:00
PROP_INVOCATION,
daemon: Have Transaction objects handle sysroot locking Also, the Transaction holds an OstreeSysroot reference for its duration, which is convenient for callbacks.
2015-08-13 17:56:06 +03:00
PROP_SYSROOT
daemon: Rework transactions A few changes: - Modify the D-Bus API to include a Finish() method instead of a Start() method, the idea being the client calls Finish() to obtain the final status and optional message once the transaction indicates it's done. Calling Finish() also removes the transaction object from the bus. - Introduce Transaction class as a thin wrapper for RPMOSTreeTransaction. Stores the status info for Finish(), detects when the caller's bus name vanishes, and emits various status signals to TransactionMonitor. - Introduce TransactionMonitor as a factory class for Transactions that also handles book keeping chores like tracking the active Transaction. The Sysroot and OS interfaces share a TransactionMonitor instance.
2015-07-23 18:30:33 +03:00
};
enum {
CANCELLED,
FINISHED,
OWNER_VANISHED,
LAST_SIGNAL
};
static guint signals[LAST_SIGNAL];
daemon: Implement GInitableIface in transactions Towards having the Transaction wrapper class follow a template pattern.
2015-08-13 17:03:56 +03:00
static void transaction_initable_iface_init (GInitableIface *iface);
static void transaction_dbus_iface_init (RPMOSTreeTransactionIface *iface);
daemon: Rework transactions A few changes: - Modify the D-Bus API to include a Finish() method instead of a Start() method, the idea being the client calls Finish() to obtain the final status and optional message once the transaction indicates it's done. Calling Finish() also removes the transaction object from the bus. - Introduce Transaction class as a thin wrapper for RPMOSTreeTransaction. Stores the status info for Finish(), detects when the caller's bus name vanishes, and emits various status signals to TransactionMonitor. - Introduce TransactionMonitor as a factory class for Transactions that also handles book keeping chores like tracking the active Transaction. The Sysroot and OS interfaces share a TransactionMonitor instance.
2015-07-23 18:30:33 +03:00
daemon: Prepare TransactionClass for subclassing Expose the instance and class structures, move instance members to a private structure. This is also towards having the TransactionClass follow a template pattern.
2015-08-13 19:53:58 +03:00
/* XXX I tried using G_ADD_PRIVATE here, but was getting memory corruption
* on the 2nd instance and valgrind was going crazy with invalid reads
* and writes. So I'm falling back to the allegedly deprecated method
* and deferring further investigation. */
daemon: Convert transactions to subclasses Implementing a template pattern for transactions. The TransactionClass is now abstract, and transaction_new() is replaced with various method-specific functions like transaction_new_upgrade(). These custom subclasses live in a new file transaction-types.[ch]. Further, transaction_monitor_new_transaction() is replaced with transaction_monitor_add(). So the handlers for "OS" interface methods need only create an appropriate transaction instance and hand it off to the transaction monitor.
2015-08-13 20:17:01 +03:00
G_DEFINE_ABSTRACT_TYPE_WITH_CODE (Transaction, transaction,
RPMOSTREE_TYPE_TRANSACTION_SKELETON,
G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE,
transaction_initable_iface_init)
G_IMPLEMENT_INTERFACE (RPMOSTREE_TYPE_TRANSACTION,
transaction_dbus_iface_init))
daemon: Rework transactions A few changes: - Modify the D-Bus API to include a Finish() method instead of a Start() method, the idea being the client calls Finish() to obtain the final status and optional message once the transaction indicates it's done. Calling Finish() also removes the transaction object from the bus. - Introduce Transaction class as a thin wrapper for RPMOSTreeTransaction. Stores the status info for Finish(), detects when the caller's bus name vanishes, and emits various status signals to TransactionMonitor. - Introduce TransactionMonitor as a factory class for Transactions that also handles book keeping chores like tracking the active Transaction. The Sysroot and OS interfaces share a TransactionMonitor instance.
2015-07-23 18:30:33 +03:00
daemon: Prepare TransactionClass for subclassing Expose the instance and class structures, move instance members to a private structure. This is also towards having the TransactionClass follow a template pattern.
2015-08-13 19:53:58 +03:00
/* XXX This is lame but it's meant to keep it simple to
* transition to transaction_get_instance_private(). */
static TransactionPrivate *
transaction_get_private (Transaction *self)
{
return self->priv;
}
daemon: Use a peer-to-peer connection for transactions Transaction progress and message signals are really only intended for one recipient: the client that invoked the method. Use a peer-to-peer connection for transactions so we're not spamming the system bus. This entails returning a bus address rather than an object path in methods that use transactions. The client opens a connection to the bus address, connects handlers to the Transaction interface (on path "/"), and then invokes the Start() method. To finish a transaction, the client need only close the connection, either explicitly or by terminating. The server will detect this and clean up resources for that transaction.
2015-08-17 20:42:03 +03:00
static gboolean
transaction_new_connection_cb (GDBusServer *server,
GDBusConnection *connection,
Transaction *self)
{
TransactionPrivate *priv = transaction_get_private (self);
GError *local_error = NULL;
if (priv->peer_connection != NULL)
return FALSE;
g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (self),
connection, "/", &local_error);
if (local_error != NULL)
{
g_critical ("Failed to export interface: %s", local_error->message);
g_clear_error (&local_error);
return FALSE;
}
priv->peer_connection = g_object_ref (connection);
return TRUE;
}
daemon: Rework transactions A few changes: - Modify the D-Bus API to include a Finish() method instead of a Start() method, the idea being the client calls Finish() to obtain the final status and optional message once the transaction indicates it's done. Calling Finish() also removes the transaction object from the bus. - Introduce Transaction class as a thin wrapper for RPMOSTreeTransaction. Stores the status info for Finish(), detects when the caller's bus name vanishes, and emits various status signals to TransactionMonitor. - Introduce TransactionMonitor as a factory class for Transactions that also handles book keeping chores like tracking the active Transaction. The Sysroot and OS interfaces share a TransactionMonitor instance.
2015-07-23 18:30:33 +03:00
static void
transaction_owner_vanished_cb (GDBusConnection *connection,
const char *name,
gpointer user_data)
{
daemon: Use a peer-to-peer connection for transactions Transaction progress and message signals are really only intended for one recipient: the client that invoked the method. Use a peer-to-peer connection for transactions so we're not spamming the system bus. This entails returning a bus address rather than an object path in methods that use transactions. The client opens a connection to the bus address, connects handlers to the Transaction interface (on path "/"), and then invokes the Start() method. To finish a transaction, the client need only close the connection, either explicitly or by terminating. The server will detect this and clean up resources for that transaction.
2015-08-17 20:42:03 +03:00
Transaction *self = TRANSACTION (user_data);
TransactionPrivate *priv = transaction_get_private (self);
daemon: Rework transactions A few changes: - Modify the D-Bus API to include a Finish() method instead of a Start() method, the idea being the client calls Finish() to obtain the final status and optional message once the transaction indicates it's done. Calling Finish() also removes the transaction object from the bus. - Introduce Transaction class as a thin wrapper for RPMOSTreeTransaction. Stores the status info for Finish(), detects when the caller's bus name vanishes, and emits various status signals to TransactionMonitor. - Introduce TransactionMonitor as a factory class for Transactions that also handles book keeping chores like tracking the active Transaction. The Sysroot and OS interfaces share a TransactionMonitor instance.
2015-07-23 18:30:33 +03:00
daemon: Prepare TransactionClass for subclassing Expose the instance and class structures, move instance members to a private structure. This is also towards having the TransactionClass follow a template pattern.
2015-08-13 19:53:58 +03:00
if (priv->watch_id > 0)
daemon: Rework transactions A few changes: - Modify the D-Bus API to include a Finish() method instead of a Start() method, the idea being the client calls Finish() to obtain the final status and optional message once the transaction indicates it's done. Calling Finish() also removes the transaction object from the bus. - Introduce Transaction class as a thin wrapper for RPMOSTreeTransaction. Stores the status info for Finish(), detects when the caller's bus name vanishes, and emits various status signals to TransactionMonitor. - Introduce TransactionMonitor as a factory class for Transactions that also handles book keeping chores like tracking the active Transaction. The Sysroot and OS interfaces share a TransactionMonitor instance.
2015-07-23 18:30:33 +03:00
{
daemon: Prepare TransactionClass for subclassing Expose the instance and class structures, move instance members to a private structure. This is also towards having the TransactionClass follow a template pattern.
2015-08-13 19:53:58 +03:00
g_bus_unwatch_name (priv->watch_id);
priv->watch_id = 0;
daemon: Rework transactions A few changes: - Modify the D-Bus API to include a Finish() method instead of a Start() method, the idea being the client calls Finish() to obtain the final status and optional message once the transaction indicates it's done. Calling Finish() also removes the transaction object from the bus. - Introduce Transaction class as a thin wrapper for RPMOSTreeTransaction. Stores the status info for Finish(), detects when the caller's bus name vanishes, and emits various status signals to TransactionMonitor. - Introduce TransactionMonitor as a factory class for Transactions that also handles book keeping chores like tracking the active Transaction. The Sysroot and OS interfaces share a TransactionMonitor instance.
2015-07-23 18:30:33 +03:00
/* Emit the signal AFTER unwatching the bus name, since this
* may finalize the transaction and invalidate the watch_id. */
daemon: Use a peer-to-peer connection for transactions Transaction progress and message signals are really only intended for one recipient: the client that invoked the method. Use a peer-to-peer connection for transactions so we're not spamming the system bus. This entails returning a bus address rather than an object path in methods that use transactions. The client opens a connection to the bus address, connects handlers to the Transaction interface (on path "/"), and then invokes the Start() method. To finish a transaction, the client need only close the connection, either explicitly or by terminating. The server will detect this and clean up resources for that transaction.
2015-08-17 20:42:03 +03:00
g_signal_emit (self, signals[OWNER_VANISHED], 0);
daemon: Rework transactions A few changes: - Modify the D-Bus API to include a Finish() method instead of a Start() method, the idea being the client calls Finish() to obtain the final status and optional message once the transaction indicates it's done. Calling Finish() also removes the transaction object from the bus. - Introduce Transaction class as a thin wrapper for RPMOSTreeTransaction. Stores the status info for Finish(), detects when the caller's bus name vanishes, and emits various status signals to TransactionMonitor. - Introduce TransactionMonitor as a factory class for Transactions that also handles book keeping chores like tracking the active Transaction. The Sysroot and OS interfaces share a TransactionMonitor instance.
2015-07-23 18:30:33 +03:00
}
}
static void
transaction_progress_changed_cb (OstreeAsyncProgress *progress,
RPMOSTreeTransaction *transaction)
{
guint64 start_time = ostree_async_progress_get_uint64 (progress, "start-time");
guint64 elapsed_secs = 0;
guint outstanding_fetches = ostree_async_progress_get_uint (progress, "outstanding-fetches");
guint outstanding_writes = ostree_async_progress_get_uint (progress, "outstanding-writes");
guint n_scanned_metadata = ostree_async_progress_get_uint (progress, "scanned-metadata");
guint metadata_fetched = ostree_async_progress_get_uint (progress, "metadata-fetched");
guint outstanding_metadata_fetches = ostree_async_progress_get_uint (progress, "outstanding-metadata-fetches");
guint total_delta_parts = ostree_async_progress_get_uint (progress, "total-delta-parts");
guint fetched_delta_parts = ostree_async_progress_get_uint (progress, "fetched-delta-parts");
guint total_delta_superblocks = ostree_async_progress_get_uint (progress, "total-delta-superblocks");
guint64 total_delta_part_size = ostree_async_progress_get_uint64 (progress, "total-delta-part-size");
guint fetched = ostree_async_progress_get_uint (progress, "fetched");
guint requested = ostree_async_progress_get_uint (progress, "requested");
guint64 bytes_sec = 0;
guint64 bytes_transferred = ostree_async_progress_get_uint64 (progress, "bytes-transferred");
GVariant *arg_time;
GVariant *arg_outstanding;
GVariant *arg_metadata;
GVariant *arg_delta;
GVariant *arg_content;
GVariant *arg_transfer;
g_autofree gchar *status;
/* If there is a status that is all we output */
status = ostree_async_progress_get_status (progress);
if (status) {
rpmostree_transaction_emit_message (transaction, g_strdup (status));
return;
}
if (start_time)
{
guint64 elapsed_secs = (g_get_monotonic_time () - start_time) / G_USEC_PER_SEC;
if (elapsed_secs)
bytes_sec = bytes_transferred / elapsed_secs;
}
arg_time = g_variant_new ("(tt)",
start_time,
elapsed_secs);
arg_outstanding = g_variant_new ("(uu)",
outstanding_fetches,
outstanding_writes);
arg_metadata = g_variant_new ("(uuu)",
n_scanned_metadata,
metadata_fetched,
outstanding_metadata_fetches);
arg_delta = g_variant_new ("(uuut)",
total_delta_parts,
fetched_delta_parts,
total_delta_superblocks,
total_delta_part_size);
arg_content = g_variant_new ("(uu)",
fetched,
requested);
arg_transfer = g_variant_new ("(tt)",
bytes_transferred,
bytes_sec);
/* This sinks the floating GVariant refs (I think...). */
rpmostree_transaction_emit_download_progress (transaction,
arg_time,
arg_outstanding,
arg_metadata,
arg_delta,
arg_content,
arg_transfer);
}
static void
transaction_gpg_verify_result_cb (OstreeRepo *repo,
const char *checksum,
OstreeGpgVerifyResult *result,
RPMOSTreeTransaction *transaction)
{
guint n, i;
GVariantBuilder builder;
if (!rpmostree_transaction_get_active (transaction))
return;
g_variant_builder_init (&builder, G_VARIANT_TYPE ("av"));
n = ostree_gpg_verify_result_count_all (result);
for (i = 0; i < n; i++)
{
g_variant_builder_add (&builder, "v",
ostree_gpg_verify_result_get_all (result, i));
}
rpmostree_transaction_emit_signature_progress (transaction,
g_variant_builder_end (&builder),
g_strdup (checksum));
}
daemon: Convert transactions to subclasses Implementing a template pattern for transactions. The TransactionClass is now abstract, and transaction_new() is replaced with various method-specific functions like transaction_new_upgrade(). These custom subclasses live in a new file transaction-types.[ch]. Further, transaction_monitor_new_transaction() is replaced with transaction_monitor_add(). So the handlers for "OS" interface methods need only create an appropriate transaction instance and hand it off to the transaction monitor.
2015-08-13 20:17:01 +03:00
static void
transaction_execute_thread (GTask *task,
gpointer source_object,
gpointer task_data,
GCancellable *cancellable)
{
Transaction *self = TRANSACTION (source_object);
TransactionClass *class = TRANSACTION_GET_CLASS (self);
gboolean success = TRUE;
GError *local_error = NULL;
if (class->execute != NULL)
success = class->execute (self, cancellable, &local_error);
if (local_error != NULL)
g_task_return_error (task, local_error);
else
g_task_return_boolean (task, success);
}
static void
transaction_execute_done_cb (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
{
Transaction *self = TRANSACTION (source_object);
TransactionPrivate *priv = transaction_get_private (self);
const char *message = NULL;
gboolean success;
GError *local_error = NULL;
success = g_task_propagate_boolean (G_TASK (result), &local_error);
/* Sanity check */
g_warn_if_fail ((success && local_error == NULL) ||
(!success && local_error != NULL));
if (local_error != NULL)
message = local_error->message;
if (message == NULL)
message = "";
priv->success = success;
priv->message = g_strdup (message);
if (success && priv->sysroot != NULL)
sysroot_emit_update (sysroot_get (), priv->sysroot);
rpmostree_transaction_set_active (RPMOSTREE_TRANSACTION (self), FALSE);
}
daemon: Rework transactions A few changes: - Modify the D-Bus API to include a Finish() method instead of a Start() method, the idea being the client calls Finish() to obtain the final status and optional message once the transaction indicates it's done. Calling Finish() also removes the transaction object from the bus. - Introduce Transaction class as a thin wrapper for RPMOSTreeTransaction. Stores the status info for Finish(), detects when the caller's bus name vanishes, and emits various status signals to TransactionMonitor. - Introduce TransactionMonitor as a factory class for Transactions that also handles book keeping chores like tracking the active Transaction. The Sysroot and OS interfaces share a TransactionMonitor instance.
2015-07-23 18:30:33 +03:00
static void
transaction_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
daemon: Prepare TransactionClass for subclassing Expose the instance and class structures, move instance members to a private structure. This is also towards having the TransactionClass follow a template pattern.
2015-08-13 19:53:58 +03:00
Transaction *self = TRANSACTION (object);
TransactionPrivate *priv = transaction_get_private (self);
daemon: Rework transactions A few changes: - Modify the D-Bus API to include a Finish() method instead of a Start() method, the idea being the client calls Finish() to obtain the final status and optional message once the transaction indicates it's done. Calling Finish() also removes the transaction object from the bus. - Introduce Transaction class as a thin wrapper for RPMOSTreeTransaction. Stores the status info for Finish(), detects when the caller's bus name vanishes, and emits various status signals to TransactionMonitor. - Introduce TransactionMonitor as a factory class for Transactions that also handles book keeping chores like tracking the active Transaction. The Sysroot and OS interfaces share a TransactionMonitor instance.
2015-07-23 18:30:33 +03:00
switch (property_id)
{
daemon: Add "invocation" property to TransactionClass Move as much as possible out of transaction_new() for the benefit of subclasses. The GDBusMethodInvocation property for setting up D-Bus properties and name watching in the constructed() method.
2015-08-17 00:41:48 +03:00
case PROP_INVOCATION:
priv->invocation = g_value_dup_object (value);
daemon: Have Transaction objects handle sysroot locking Also, the Transaction holds an OstreeSysroot reference for its duration, which is convenient for callbacks.
2015-08-13 17:56:06 +03:00
case PROP_SYSROOT:
daemon: Prepare TransactionClass for subclassing Expose the instance and class structures, move instance members to a private structure. This is also towards having the TransactionClass follow a template pattern.
2015-08-13 19:53:58 +03:00
priv->sysroot = g_value_dup_object (value);
daemon: Have Transaction objects handle sysroot locking Also, the Transaction holds an OstreeSysroot reference for its duration, which is convenient for callbacks.
2015-08-13 17:56:06 +03:00
break;
daemon: Rework transactions A few changes: - Modify the D-Bus API to include a Finish() method instead of a Start() method, the idea being the client calls Finish() to obtain the final status and optional message once the transaction indicates it's done. Calling Finish() also removes the transaction object from the bus. - Introduce Transaction class as a thin wrapper for RPMOSTreeTransaction. Stores the status info for Finish(), detects when the caller's bus name vanishes, and emits various status signals to TransactionMonitor. - Introduce TransactionMonitor as a factory class for Transactions that also handles book keeping chores like tracking the active Transaction. The Sysroot and OS interfaces share a TransactionMonitor instance.
2015-07-23 18:30:33 +03:00
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
transaction_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
daemon: Prepare TransactionClass for subclassing Expose the instance and class structures, move instance members to a private structure. This is also towards having the TransactionClass follow a template pattern.
2015-08-13 19:53:58 +03:00
Transaction *self = TRANSACTION (object);
TransactionPrivate *priv = transaction_get_private (self);
daemon: Rework transactions A few changes: - Modify the D-Bus API to include a Finish() method instead of a Start() method, the idea being the client calls Finish() to obtain the final status and optional message once the transaction indicates it's done. Calling Finish() also removes the transaction object from the bus. - Introduce Transaction class as a thin wrapper for RPMOSTreeTransaction. Stores the status info for Finish(), detects when the caller's bus name vanishes, and emits various status signals to TransactionMonitor. - Introduce TransactionMonitor as a factory class for Transactions that also handles book keeping chores like tracking the active Transaction. The Sysroot and OS interfaces share a TransactionMonitor instance.
2015-07-23 18:30:33 +03:00
switch (property_id)
{
daemon: Add "invocation" property to TransactionClass Move as much as possible out of transaction_new() for the benefit of subclasses. The GDBusMethodInvocation property for setting up D-Bus properties and name watching in the constructed() method.
2015-08-17 00:41:48 +03:00
case PROP_INVOCATION:
g_value_set_object (value, priv->invocation);
break;
daemon: Have Transaction objects handle sysroot locking Also, the Transaction holds an OstreeSysroot reference for its duration, which is convenient for callbacks.
2015-08-13 17:56:06 +03:00
case PROP_SYSROOT:
daemon: Prepare TransactionClass for subclassing Expose the instance and class structures, move instance members to a private structure. This is also towards having the TransactionClass follow a template pattern.
2015-08-13 19:53:58 +03:00
g_value_set_object (value, priv->sysroot);
daemon: Have Transaction objects handle sysroot locking Also, the Transaction holds an OstreeSysroot reference for its duration, which is convenient for callbacks.
2015-08-13 17:56:06 +03:00
break;
daemon: Rework transactions A few changes: - Modify the D-Bus API to include a Finish() method instead of a Start() method, the idea being the client calls Finish() to obtain the final status and optional message once the transaction indicates it's done. Calling Finish() also removes the transaction object from the bus. - Introduce Transaction class as a thin wrapper for RPMOSTreeTransaction. Stores the status info for Finish(), detects when the caller's bus name vanishes, and emits various status signals to TransactionMonitor. - Introduce TransactionMonitor as a factory class for Transactions that also handles book keeping chores like tracking the active Transaction. The Sysroot and OS interfaces share a TransactionMonitor instance.
2015-07-23 18:30:33 +03:00
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
transaction_dispose (GObject *object)
{
daemon: Prepare TransactionClass for subclassing Expose the instance and class structures, move instance members to a private structure. This is also towards having the TransactionClass follow a template pattern.
2015-08-13 19:53:58 +03:00
Transaction *self = TRANSACTION (object);
TransactionPrivate *priv = transaction_get_private (self);
daemon: Rework transactions A few changes: - Modify the D-Bus API to include a Finish() method instead of a Start() method, the idea being the client calls Finish() to obtain the final status and optional message once the transaction indicates it's done. Calling Finish() also removes the transaction object from the bus. - Introduce Transaction class as a thin wrapper for RPMOSTreeTransaction. Stores the status info for Finish(), detects when the caller's bus name vanishes, and emits various status signals to TransactionMonitor. - Introduce TransactionMonitor as a factory class for Transactions that also handles book keeping chores like tracking the active Transaction. The Sysroot and OS interfaces share a TransactionMonitor instance.
2015-07-23 18:30:33 +03:00
daemon: Prepare TransactionClass for subclassing Expose the instance and class structures, move instance members to a private structure. This is also towards having the TransactionClass follow a template pattern.
2015-08-13 19:53:58 +03:00
if (priv->sysroot != NULL)
ostree_sysroot_unlock (priv->sysroot);
daemon: Have Transaction objects handle sysroot locking Also, the Transaction holds an OstreeSysroot reference for its duration, which is convenient for callbacks.
2015-08-13 17:56:06 +03:00
daemon: Add "invocation" property to TransactionClass Move as much as possible out of transaction_new() for the benefit of subclasses. The GDBusMethodInvocation property for setting up D-Bus properties and name watching in the constructed() method.
2015-08-17 00:41:48 +03:00
g_clear_object (&priv->invocation);
daemon: Prepare TransactionClass for subclassing Expose the instance and class structures, move instance members to a private structure. This is also towards having the TransactionClass follow a template pattern.
2015-08-13 19:53:58 +03:00
g_clear_object (&priv->cancellable);
g_clear_object (&priv->sysroot);
daemon: Use a peer-to-peer connection for transactions Transaction progress and message signals are really only intended for one recipient: the client that invoked the method. Use a peer-to-peer connection for transactions so we're not spamming the system bus. This entails returning a bus address rather than an object path in methods that use transactions. The client opens a connection to the bus address, connects handlers to the Transaction interface (on path "/"), and then invokes the Start() method. To finish a transaction, the client need only close the connection, either explicitly or by terminating. The server will detect this and clean up resources for that transaction.
2015-08-17 20:42:03 +03:00
g_clear_object (&priv->server);
g_clear_object (&priv->peer_connection);
daemon: Rework transactions A few changes: - Modify the D-Bus API to include a Finish() method instead of a Start() method, the idea being the client calls Finish() to obtain the final status and optional message once the transaction indicates it's done. Calling Finish() also removes the transaction object from the bus. - Introduce Transaction class as a thin wrapper for RPMOSTreeTransaction. Stores the status info for Finish(), detects when the caller's bus name vanishes, and emits various status signals to TransactionMonitor. - Introduce TransactionMonitor as a factory class for Transactions that also handles book keeping chores like tracking the active Transaction. The Sysroot and OS interfaces share a TransactionMonitor instance.
2015-07-23 18:30:33 +03:00
G_OBJECT_CLASS (transaction_parent_class)->dispose (object);
}
static void
transaction_finalize (GObject *object)
{
daemon: Prepare TransactionClass for subclassing Expose the instance and class structures, move instance members to a private structure. This is also towards having the TransactionClass follow a template pattern.
2015-08-13 19:53:58 +03:00
Transaction *self = TRANSACTION (object);
TransactionPrivate *priv = transaction_get_private (self);
daemon: Rework transactions A few changes: - Modify the D-Bus API to include a Finish() method instead of a Start() method, the idea being the client calls Finish() to obtain the final status and optional message once the transaction indicates it's done. Calling Finish() also removes the transaction object from the bus. - Introduce Transaction class as a thin wrapper for RPMOSTreeTransaction. Stores the status info for Finish(), detects when the caller's bus name vanishes, and emits various status signals to TransactionMonitor. - Introduce TransactionMonitor as a factory class for Transactions that also handles book keeping chores like tracking the active Transaction. The Sysroot and OS interfaces share a TransactionMonitor instance.
2015-07-23 18:30:33 +03:00
daemon: Prepare TransactionClass for subclassing Expose the instance and class structures, move instance members to a private structure. This is also towards having the TransactionClass follow a template pattern.
2015-08-13 19:53:58 +03:00
g_free (priv->message);
daemon: Rework transactions A few changes: - Modify the D-Bus API to include a Finish() method instead of a Start() method, the idea being the client calls Finish() to obtain the final status and optional message once the transaction indicates it's done. Calling Finish() also removes the transaction object from the bus. - Introduce Transaction class as a thin wrapper for RPMOSTreeTransaction. Stores the status info for Finish(), detects when the caller's bus name vanishes, and emits various status signals to TransactionMonitor. - Introduce TransactionMonitor as a factory class for Transactions that also handles book keeping chores like tracking the active Transaction. The Sysroot and OS interfaces share a TransactionMonitor instance.
2015-07-23 18:30:33 +03:00
daemon: Prepare TransactionClass for subclassing Expose the instance and class structures, move instance members to a private structure. This is also towards having the TransactionClass follow a template pattern.
2015-08-13 19:53:58 +03:00
if (priv->watch_id > 0)
g_bus_unwatch_name (priv->watch_id);
daemon: Rework transactions A few changes: - Modify the D-Bus API to include a Finish() method instead of a Start() method, the idea being the client calls Finish() to obtain the final status and optional message once the transaction indicates it's done. Calling Finish() also removes the transaction object from the bus. - Introduce Transaction class as a thin wrapper for RPMOSTreeTransaction. Stores the status info for Finish(), detects when the caller's bus name vanishes, and emits various status signals to TransactionMonitor. - Introduce TransactionMonitor as a factory class for Transactions that also handles book keeping chores like tracking the active Transaction. The Sysroot and OS interfaces share a TransactionMonitor instance.
2015-07-23 18:30:33 +03:00
G_OBJECT_CLASS (transaction_parent_class)->finalize (object);
}
daemon: Add "invocation" property to TransactionClass Move as much as possible out of transaction_new() for the benefit of subclasses. The GDBusMethodInvocation property for setting up D-Bus properties and name watching in the constructed() method.
2015-08-17 00:41:48 +03:00
static void
transaction_constructed (GObject *object)
{
Transaction *self = TRANSACTION (object);
TransactionPrivate *priv = transaction_get_private (self);
G_OBJECT_CLASS (transaction_parent_class)->constructed (object);
if (priv->invocation != NULL)
{
GDBusConnection *connection;
const char *method_name;
const char *sender;
connection = g_dbus_method_invocation_get_connection (priv->invocation);
method_name = g_dbus_method_invocation_get_method_name (priv->invocation);
sender = g_dbus_method_invocation_get_sender (priv->invocation);
/* Initialize D-Bus properties. */
g_object_set (self,
"method-name", method_name,
"owner", sender,
"active", TRUE,
NULL);
priv->watch_id = g_bus_watch_name_on_connection (connection,
sender,
G_BUS_NAME_WATCHER_FLAGS_NONE,
NULL,
transaction_owner_vanished_cb,
self,
NULL);
}
}
daemon: Implement GInitableIface in transactions Towards having the Transaction wrapper class follow a template pattern.
2015-08-13 17:03:56 +03:00
static gboolean
transaction_initable_init (GInitable *initable,
GCancellable *cancellable,
GError **error)
{
daemon: Prepare TransactionClass for subclassing Expose the instance and class structures, move instance members to a private structure. This is also towards having the TransactionClass follow a template pattern.
2015-08-13 19:53:58 +03:00
Transaction *self = TRANSACTION (initable);
TransactionPrivate *priv = transaction_get_private (self);
daemon: Use a peer-to-peer connection for transactions Transaction progress and message signals are really only intended for one recipient: the client that invoked the method. Use a peer-to-peer connection for transactions so we're not spamming the system bus. This entails returning a bus address rather than an object path in methods that use transactions. The client opens a connection to the bus address, connects handlers to the Transaction interface (on path "/"), and then invokes the Start() method. To finish a transaction, the client need only close the connection, either explicitly or by terminating. The server will detect this and clean up resources for that transaction.
2015-08-17 20:42:03 +03:00
g_autofree char *guid = NULL;
daemon: Have Transaction objects handle sysroot locking Also, the Transaction holds an OstreeSysroot reference for its duration, which is convenient for callbacks.
2015-08-13 17:56:06 +03:00
gboolean ret = FALSE;
daemon: Implement GInitableIface in transactions Towards having the Transaction wrapper class follow a template pattern.
2015-08-13 17:03:56 +03:00
if (G_IS_CANCELLABLE (cancellable))
daemon: Prepare TransactionClass for subclassing Expose the instance and class structures, move instance members to a private structure. This is also towards having the TransactionClass follow a template pattern.
2015-08-13 19:53:58 +03:00
priv->cancellable = g_object_ref (cancellable);
daemon: Implement GInitableIface in transactions Towards having the Transaction wrapper class follow a template pattern.
2015-08-13 17:03:56 +03:00
daemon: Use a peer-to-peer connection for transactions Transaction progress and message signals are really only intended for one recipient: the client that invoked the method. Use a peer-to-peer connection for transactions so we're not spamming the system bus. This entails returning a bus address rather than an object path in methods that use transactions. The client opens a connection to the bus address, connects handlers to the Transaction interface (on path "/"), and then invokes the Start() method. To finish a transaction, the client need only close the connection, either explicitly or by terminating. The server will detect this and clean up resources for that transaction.
2015-08-17 20:42:03 +03:00
/* Set up a private D-Bus server over which to emit
* progress and informational messages to the caller. */
guid = g_dbus_generate_guid ();
priv->server = g_dbus_server_new_sync ("unix:tmpdir=/tmp/rpm-ostree",
G_DBUS_SERVER_FLAGS_NONE,
guid,
NULL,
cancellable,
error);
if (priv->server == NULL)
goto out;
g_signal_connect_object (priv->server,
"new-connection",
G_CALLBACK (transaction_new_connection_cb),
self, 0);
daemon: Prepare TransactionClass for subclassing Expose the instance and class structures, move instance members to a private structure. This is also towards having the TransactionClass follow a template pattern.
2015-08-13 19:53:58 +03:00
if (priv->sysroot != NULL)
daemon: Have Transaction objects handle sysroot locking Also, the Transaction holds an OstreeSysroot reference for its duration, which is convenient for callbacks.
2015-08-13 17:56:06 +03:00
{
gboolean lock_acquired = FALSE;
daemon: Prepare TransactionClass for subclassing Expose the instance and class structures, move instance members to a private structure. This is also towards having the TransactionClass follow a template pattern.
2015-08-13 19:53:58 +03:00
if (!ostree_sysroot_try_lock (priv->sysroot, &lock_acquired, error))
daemon: Have Transaction objects handle sysroot locking Also, the Transaction holds an OstreeSysroot reference for its duration, which is convenient for callbacks.
2015-08-13 17:56:06 +03:00
goto out;
if (!lock_acquired)
{
g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_BUSY,
"System transaction in progress");
goto out;
}
}
daemon: Use a peer-to-peer connection for transactions Transaction progress and message signals are really only intended for one recipient: the client that invoked the method. Use a peer-to-peer connection for transactions so we're not spamming the system bus. This entails returning a bus address rather than an object path in methods that use transactions. The client opens a connection to the bus address, connects handlers to the Transaction interface (on path "/"), and then invokes the Start() method. To finish a transaction, the client need only close the connection, either explicitly or by terminating. The server will detect this and clean up resources for that transaction.
2015-08-17 20:42:03 +03:00
g_dbus_server_start (priv->server);
daemon: Have Transaction objects handle sysroot locking Also, the Transaction holds an OstreeSysroot reference for its duration, which is convenient for callbacks.
2015-08-13 17:56:06 +03:00
ret = TRUE;
out:
return ret;
daemon: Implement GInitableIface in transactions Towards having the Transaction wrapper class follow a template pattern.
2015-08-13 17:03:56 +03:00
}
daemon: Rework transactions A few changes: - Modify the D-Bus API to include a Finish() method instead of a Start() method, the idea being the client calls Finish() to obtain the final status and optional message once the transaction indicates it's done. Calling Finish() also removes the transaction object from the bus. - Introduce Transaction class as a thin wrapper for RPMOSTreeTransaction. Stores the status info for Finish(), detects when the caller's bus name vanishes, and emits various status signals to TransactionMonitor. - Introduce TransactionMonitor as a factory class for Transactions that also handles book keeping chores like tracking the active Transaction. The Sysroot and OS interfaces share a TransactionMonitor instance.
2015-07-23 18:30:33 +03:00
static gboolean
transaction_handle_cancel (RPMOSTreeTransaction *transaction,
GDBusMethodInvocation *invocation)
{
daemon: Prepare TransactionClass for subclassing Expose the instance and class structures, move instance members to a private structure. This is also towards having the TransactionClass follow a template pattern.
2015-08-13 19:53:58 +03:00
Transaction *self = TRANSACTION (transaction);
TransactionPrivate *priv = transaction_get_private (self);
daemon: Rework transactions A few changes: - Modify the D-Bus API to include a Finish() method instead of a Start() method, the idea being the client calls Finish() to obtain the final status and optional message once the transaction indicates it's done. Calling Finish() also removes the transaction object from the bus. - Introduce Transaction class as a thin wrapper for RPMOSTreeTransaction. Stores the status info for Finish(), detects when the caller's bus name vanishes, and emits various status signals to TransactionMonitor. - Introduce TransactionMonitor as a factory class for Transactions that also handles book keeping chores like tracking the active Transaction. The Sysroot and OS interfaces share a TransactionMonitor instance.
2015-07-23 18:30:33 +03:00
daemon: Prepare TransactionClass for subclassing Expose the instance and class structures, move instance members to a private structure. This is also towards having the TransactionClass follow a template pattern.
2015-08-13 19:53:58 +03:00
if (priv->cancellable == NULL)
daemon: Rework transactions A few changes: - Modify the D-Bus API to include a Finish() method instead of a Start() method, the idea being the client calls Finish() to obtain the final status and optional message once the transaction indicates it's done. Calling Finish() also removes the transaction object from the bus. - Introduce Transaction class as a thin wrapper for RPMOSTreeTransaction. Stores the status info for Finish(), detects when the caller's bus name vanishes, and emits various status signals to TransactionMonitor. - Introduce TransactionMonitor as a factory class for Transactions that also handles book keeping chores like tracking the active Transaction. The Sysroot and OS interfaces share a TransactionMonitor instance.
2015-07-23 18:30:33 +03:00
return FALSE;
daemon: Remove owner checks on Transaction methods Because peer-to-peer endpoints don't get assigned unique names, the sender == owner check is rendered useless. But I'm not sure we even need a check since the transaction *is* peer-to-peer now. One way to secure the returned bus address from prying eyes would be to employ GcrSecretExchange, but this would only complicate the hand- shake further and (imo) necessitate a public client-side function to implement the handshake correctly.
2015-08-18 18:42:22 +03:00
g_cancellable_cancel (priv->cancellable);
g_signal_emit (transaction, signals[CANCELLED], 0);
rpmostree_transaction_complete_cancel (transaction, invocation);
daemon: Rework transactions A few changes: - Modify the D-Bus API to include a Finish() method instead of a Start() method, the idea being the client calls Finish() to obtain the final status and optional message once the transaction indicates it's done. Calling Finish() also removes the transaction object from the bus. - Introduce Transaction class as a thin wrapper for RPMOSTreeTransaction. Stores the status info for Finish(), detects when the caller's bus name vanishes, and emits various status signals to TransactionMonitor. - Introduce TransactionMonitor as a factory class for Transactions that also handles book keeping chores like tracking the active Transaction. The Sysroot and OS interfaces share a TransactionMonitor instance.
2015-07-23 18:30:33 +03:00
return TRUE;
}
daemon: Add a Start() method to transactions Turns out we do still need a Start() method after all. Not for lack of trying, but I can't get away from the client and server doing some sort of handshake at the beginning to avoid either raciness on the client side or artificial delays on the server side. I don't particularly like the "start" signal I've added -- I'd much prefer subclassing -- but I'm trying to keep the changes incremental.
2015-08-14 18:17:06 +03:00
static gboolean
transaction_handle_start (RPMOSTreeTransaction *transaction,
GDBusMethodInvocation *invocation)
{
Transaction *self = TRANSACTION (transaction);
TransactionPrivate *priv = transaction_get_private (self);
if (priv->started)
{
g_dbus_method_invocation_return_error (invocation,
RPM_OSTREED_ERROR,
RPM_OSTREED_ERROR_FAILED,
"Transaction has already started");
}
else
{
daemon: Convert transactions to subclasses Implementing a template pattern for transactions. The TransactionClass is now abstract, and transaction_new() is replaced with various method-specific functions like transaction_new_upgrade(). These custom subclasses live in a new file transaction-types.[ch]. Further, transaction_monitor_new_transaction() is replaced with transaction_monitor_add(). So the handlers for "OS" interface methods need only create an appropriate transaction instance and hand it off to the transaction monitor.
2015-08-13 20:17:01 +03:00
GTask *task;
daemon: Add a Start() method to transactions Turns out we do still need a Start() method after all. Not for lack of trying, but I can't get away from the client and server doing some sort of handshake at the beginning to avoid either raciness on the client side or artificial delays on the server side. I don't particularly like the "start" signal I've added -- I'd much prefer subclassing -- but I'm trying to keep the changes incremental.
2015-08-14 18:17:06 +03:00
priv->started = TRUE;
daemon: Convert transactions to subclasses Implementing a template pattern for transactions. The TransactionClass is now abstract, and transaction_new() is replaced with various method-specific functions like transaction_new_upgrade(). These custom subclasses live in a new file transaction-types.[ch]. Further, transaction_monitor_new_transaction() is replaced with transaction_monitor_add(). So the handlers for "OS" interface methods need only create an appropriate transaction instance and hand it off to the transaction monitor.
2015-08-13 20:17:01 +03:00
task = g_task_new (transaction,
priv->cancellable,
transaction_execute_done_cb,
NULL);
g_task_run_in_thread (task, transaction_execute_thread);
g_object_unref (task);
daemon: Add a Start() method to transactions Turns out we do still need a Start() method after all. Not for lack of trying, but I can't get away from the client and server doing some sort of handshake at the beginning to avoid either raciness on the client side or artificial delays on the server side. I don't particularly like the "start" signal I've added -- I'd much prefer subclassing -- but I'm trying to keep the changes incremental.
2015-08-14 18:17:06 +03:00
rpmostree_transaction_complete_start (transaction, invocation);
}
return TRUE;
}
daemon: Rework transactions A few changes: - Modify the D-Bus API to include a Finish() method instead of a Start() method, the idea being the client calls Finish() to obtain the final status and optional message once the transaction indicates it's done. Calling Finish() also removes the transaction object from the bus. - Introduce Transaction class as a thin wrapper for RPMOSTreeTransaction. Stores the status info for Finish(), detects when the caller's bus name vanishes, and emits various status signals to TransactionMonitor. - Introduce TransactionMonitor as a factory class for Transactions that also handles book keeping chores like tracking the active Transaction. The Sysroot and OS interfaces share a TransactionMonitor instance.
2015-07-23 18:30:33 +03:00
static gboolean
transaction_handle_finish (RPMOSTreeTransaction *transaction,
GDBusMethodInvocation *invocation)
{
daemon: Prepare TransactionClass for subclassing Expose the instance and class structures, move instance members to a private structure. This is also towards having the TransactionClass follow a template pattern.
2015-08-13 19:53:58 +03:00
Transaction *self = TRANSACTION (transaction);
TransactionPrivate *priv = transaction_get_private (self);
daemon: Rework transactions A few changes: - Modify the D-Bus API to include a Finish() method instead of a Start() method, the idea being the client calls Finish() to obtain the final status and optional message once the transaction indicates it's done. Calling Finish() also removes the transaction object from the bus. - Introduce Transaction class as a thin wrapper for RPMOSTreeTransaction. Stores the status info for Finish(), detects when the caller's bus name vanishes, and emits various status signals to TransactionMonitor. - Introduce TransactionMonitor as a factory class for Transactions that also handles book keeping chores like tracking the active Transaction. The Sysroot and OS interfaces share a TransactionMonitor instance.
2015-07-23 18:30:33 +03:00
daemon: Remove owner checks on Transaction methods Because peer-to-peer endpoints don't get assigned unique names, the sender == owner check is rendered useless. But I'm not sure we even need a check since the transaction *is* peer-to-peer now. One way to secure the returned bus address from prying eyes would be to employ GcrSecretExchange, but this would only complicate the hand- shake further and (imo) necessitate a public client-side function to implement the handshake correctly.
2015-08-18 18:42:22 +03:00
if (rpmostree_transaction_get_active (transaction))
daemon: Rework transactions A few changes: - Modify the D-Bus API to include a Finish() method instead of a Start() method, the idea being the client calls Finish() to obtain the final status and optional message once the transaction indicates it's done. Calling Finish() also removes the transaction object from the bus. - Introduce Transaction class as a thin wrapper for RPMOSTreeTransaction. Stores the status info for Finish(), detects when the caller's bus name vanishes, and emits various status signals to TransactionMonitor. - Introduce TransactionMonitor as a factory class for Transactions that also handles book keeping chores like tracking the active Transaction. The Sysroot and OS interfaces share a TransactionMonitor instance.
2015-07-23 18:30:33 +03:00
{
g_dbus_method_invocation_return_error (invocation,
RPM_OSTREED_ERROR,
RPM_OSTREED_ERROR_FAILED,
"Transaction is still active");
}
else
{
g_signal_emit (transaction, signals[FINISHED], 0);
rpmostree_transaction_complete_finish (transaction, invocation,
daemon: Prepare TransactionClass for subclassing Expose the instance and class structures, move instance members to a private structure. This is also towards having the TransactionClass follow a template pattern.
2015-08-13 19:53:58 +03:00
priv->success,
priv->message ?
priv->message : "");
daemon: Rework transactions A few changes: - Modify the D-Bus API to include a Finish() method instead of a Start() method, the idea being the client calls Finish() to obtain the final status and optional message once the transaction indicates it's done. Calling Finish() also removes the transaction object from the bus. - Introduce Transaction class as a thin wrapper for RPMOSTreeTransaction. Stores the status info for Finish(), detects when the caller's bus name vanishes, and emits various status signals to TransactionMonitor. - Introduce TransactionMonitor as a factory class for Transactions that also handles book keeping chores like tracking the active Transaction. The Sysroot and OS interfaces share a TransactionMonitor instance.
2015-07-23 18:30:33 +03:00
}
return TRUE;
}
static void
transaction_class_init (TransactionClass *class)
{
GObjectClass *object_class;
daemon: Prepare TransactionClass for subclassing Expose the instance and class structures, move instance members to a private structure. This is also towards having the TransactionClass follow a template pattern.
2015-08-13 19:53:58 +03:00
g_type_class_add_private (class, sizeof (TransactionPrivate));
daemon: Rework transactions A few changes: - Modify the D-Bus API to include a Finish() method instead of a Start() method, the idea being the client calls Finish() to obtain the final status and optional message once the transaction indicates it's done. Calling Finish() also removes the transaction object from the bus. - Introduce Transaction class as a thin wrapper for RPMOSTreeTransaction. Stores the status info for Finish(), detects when the caller's bus name vanishes, and emits various status signals to TransactionMonitor. - Introduce TransactionMonitor as a factory class for Transactions that also handles book keeping chores like tracking the active Transaction. The Sysroot and OS interfaces share a TransactionMonitor instance.
2015-07-23 18:30:33 +03:00
object_class = G_OBJECT_CLASS (class);
object_class->set_property = transaction_set_property;
object_class->get_property = transaction_get_property;
object_class->dispose = transaction_dispose;
object_class->finalize = transaction_finalize;
daemon: Add "invocation" property to TransactionClass Move as much as possible out of transaction_new() for the benefit of subclasses. The GDBusMethodInvocation property for setting up D-Bus properties and name watching in the constructed() method.
2015-08-17 00:41:48 +03:00
object_class->constructed = transaction_constructed;
g_object_class_install_property (object_class,
PROP_INVOCATION,
g_param_spec_object ("invocation",
"Invocation",
"D-Bus method invocation",
G_TYPE_DBUS_METHOD_INVOCATION,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS));
daemon: Rework transactions A few changes: - Modify the D-Bus API to include a Finish() method instead of a Start() method, the idea being the client calls Finish() to obtain the final status and optional message once the transaction indicates it's done. Calling Finish() also removes the transaction object from the bus. - Introduce Transaction class as a thin wrapper for RPMOSTreeTransaction. Stores the status info for Finish(), detects when the caller's bus name vanishes, and emits various status signals to TransactionMonitor. - Introduce TransactionMonitor as a factory class for Transactions that also handles book keeping chores like tracking the active Transaction. The Sysroot and OS interfaces share a TransactionMonitor instance.
2015-07-23 18:30:33 +03:00
daemon: Have Transaction objects handle sysroot locking Also, the Transaction holds an OstreeSysroot reference for its duration, which is convenient for callbacks.
2015-08-13 17:56:06 +03:00
g_object_class_install_property (object_class,
PROP_SYSROOT,
g_param_spec_object ("sysroot",
"Sysroot",
"An OstreeSysroot instance",
OSTREE_TYPE_SYSROOT,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS));
daemon: Rework transactions A few changes: - Modify the D-Bus API to include a Finish() method instead of a Start() method, the idea being the client calls Finish() to obtain the final status and optional message once the transaction indicates it's done. Calling Finish() also removes the transaction object from the bus. - Introduce Transaction class as a thin wrapper for RPMOSTreeTransaction. Stores the status info for Finish(), detects when the caller's bus name vanishes, and emits various status signals to TransactionMonitor. - Introduce TransactionMonitor as a factory class for Transactions that also handles book keeping chores like tracking the active Transaction. The Sysroot and OS interfaces share a TransactionMonitor instance.
2015-07-23 18:30:33 +03:00
signals[CANCELLED] = g_signal_new ("cancelled",
TYPE_TRANSACTION,
G_SIGNAL_RUN_LAST,
0, NULL, NULL, NULL,
G_TYPE_NONE, 0);
signals[FINISHED] = g_signal_new ("finished",
TYPE_TRANSACTION,
G_SIGNAL_RUN_LAST,
0, NULL, NULL, NULL,
G_TYPE_NONE, 0);
signals[OWNER_VANISHED] = g_signal_new ("owner-vanished",
TYPE_TRANSACTION,
G_SIGNAL_RUN_LAST,
0, NULL, NULL, NULL,
G_TYPE_NONE, 0);
}
static void
daemon: Implement GInitableIface in transactions Towards having the Transaction wrapper class follow a template pattern.
2015-08-13 17:03:56 +03:00
transaction_initable_iface_init (GInitableIface *iface)
{
iface->init = transaction_initable_init;
}
static void
transaction_dbus_iface_init (RPMOSTreeTransactionIface *iface)
daemon: Rework transactions A few changes: - Modify the D-Bus API to include a Finish() method instead of a Start() method, the idea being the client calls Finish() to obtain the final status and optional message once the transaction indicates it's done. Calling Finish() also removes the transaction object from the bus. - Introduce Transaction class as a thin wrapper for RPMOSTreeTransaction. Stores the status info for Finish(), detects when the caller's bus name vanishes, and emits various status signals to TransactionMonitor. - Introduce TransactionMonitor as a factory class for Transactions that also handles book keeping chores like tracking the active Transaction. The Sysroot and OS interfaces share a TransactionMonitor instance.
2015-07-23 18:30:33 +03:00
{
iface->handle_cancel = transaction_handle_cancel;
daemon: Add a Start() method to transactions Turns out we do still need a Start() method after all. Not for lack of trying, but I can't get away from the client and server doing some sort of handshake at the beginning to avoid either raciness on the client side or artificial delays on the server side. I don't particularly like the "start" signal I've added -- I'd much prefer subclassing -- but I'm trying to keep the changes incremental.
2015-08-14 18:17:06 +03:00
iface->handle_start = transaction_handle_start;
daemon: Rework transactions A few changes: - Modify the D-Bus API to include a Finish() method instead of a Start() method, the idea being the client calls Finish() to obtain the final status and optional message once the transaction indicates it's done. Calling Finish() also removes the transaction object from the bus. - Introduce Transaction class as a thin wrapper for RPMOSTreeTransaction. Stores the status info for Finish(), detects when the caller's bus name vanishes, and emits various status signals to TransactionMonitor. - Introduce TransactionMonitor as a factory class for Transactions that also handles book keeping chores like tracking the active Transaction. The Sysroot and OS interfaces share a TransactionMonitor instance.
2015-07-23 18:30:33 +03:00
iface->handle_finish = transaction_handle_finish;
}
static void
daemon: Prepare TransactionClass for subclassing Expose the instance and class structures, move instance members to a private structure. This is also towards having the TransactionClass follow a template pattern.
2015-08-13 19:53:58 +03:00
transaction_init (Transaction *self)
daemon: Rework transactions A few changes: - Modify the D-Bus API to include a Finish() method instead of a Start() method, the idea being the client calls Finish() to obtain the final status and optional message once the transaction indicates it's done. Calling Finish() also removes the transaction object from the bus. - Introduce Transaction class as a thin wrapper for RPMOSTreeTransaction. Stores the status info for Finish(), detects when the caller's bus name vanishes, and emits various status signals to TransactionMonitor. - Introduce TransactionMonitor as a factory class for Transactions that also handles book keeping chores like tracking the active Transaction. The Sysroot and OS interfaces share a TransactionMonitor instance.
2015-07-23 18:30:33 +03:00
{
daemon: Prepare TransactionClass for subclassing Expose the instance and class structures, move instance members to a private structure. This is also towards having the TransactionClass follow a template pattern.
2015-08-13 19:53:58 +03:00
self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
TYPE_TRANSACTION,
TransactionPrivate);
daemon: Rework transactions A few changes: - Modify the D-Bus API to include a Finish() method instead of a Start() method, the idea being the client calls Finish() to obtain the final status and optional message once the transaction indicates it's done. Calling Finish() also removes the transaction object from the bus. - Introduce Transaction class as a thin wrapper for RPMOSTreeTransaction. Stores the status info for Finish(), detects when the caller's bus name vanishes, and emits various status signals to TransactionMonitor. - Introduce TransactionMonitor as a factory class for Transactions that also handles book keeping chores like tracking the active Transaction. The Sysroot and OS interfaces share a TransactionMonitor instance.
2015-07-23 18:30:33 +03:00
}
daemon: Have Transaction objects handle sysroot locking Also, the Transaction holds an OstreeSysroot reference for its duration, which is convenient for callbacks.
2015-08-13 17:56:06 +03:00
OstreeSysroot *
daemon: Convert transactions to subclasses Implementing a template pattern for transactions. The TransactionClass is now abstract, and transaction_new() is replaced with various method-specific functions like transaction_new_upgrade(). These custom subclasses live in a new file transaction-types.[ch]. Further, transaction_monitor_new_transaction() is replaced with transaction_monitor_add(). So the handlers for "OS" interface methods need only create an appropriate transaction instance and hand it off to the transaction monitor.
2015-08-13 20:17:01 +03:00
transaction_get_sysroot (Transaction *transaction)
daemon: Have Transaction objects handle sysroot locking Also, the Transaction holds an OstreeSysroot reference for its duration, which is convenient for callbacks.
2015-08-13 17:56:06 +03:00
{
daemon: Prepare TransactionClass for subclassing Expose the instance and class structures, move instance members to a private structure. This is also towards having the TransactionClass follow a template pattern.
2015-08-13 19:53:58 +03:00
TransactionPrivate *priv;
daemon: Have Transaction objects handle sysroot locking Also, the Transaction holds an OstreeSysroot reference for its duration, which is convenient for callbacks.
2015-08-13 17:56:06 +03:00
daemon: Convert transactions to subclasses Implementing a template pattern for transactions. The TransactionClass is now abstract, and transaction_new() is replaced with various method-specific functions like transaction_new_upgrade(). These custom subclasses live in a new file transaction-types.[ch]. Further, transaction_monitor_new_transaction() is replaced with transaction_monitor_add(). So the handlers for "OS" interface methods need only create an appropriate transaction instance and hand it off to the transaction monitor.
2015-08-13 20:17:01 +03:00
g_return_val_if_fail (IS_TRANSACTION (transaction), NULL);
daemon: Have Transaction objects handle sysroot locking Also, the Transaction holds an OstreeSysroot reference for its duration, which is convenient for callbacks.
2015-08-13 17:56:06 +03:00
daemon: Convert transactions to subclasses Implementing a template pattern for transactions. The TransactionClass is now abstract, and transaction_new() is replaced with various method-specific functions like transaction_new_upgrade(). These custom subclasses live in a new file transaction-types.[ch]. Further, transaction_monitor_new_transaction() is replaced with transaction_monitor_add(). So the handlers for "OS" interface methods need only create an appropriate transaction instance and hand it off to the transaction monitor.
2015-08-13 20:17:01 +03:00
priv = transaction_get_private (transaction);
daemon: Have Transaction objects handle sysroot locking Also, the Transaction holds an OstreeSysroot reference for its duration, which is convenient for callbacks.
2015-08-13 17:56:06 +03:00
daemon: Prepare TransactionClass for subclassing Expose the instance and class structures, move instance members to a private structure. This is also towards having the TransactionClass follow a template pattern.
2015-08-13 19:53:58 +03:00
return priv->sysroot;
daemon: Have Transaction objects handle sysroot locking Also, the Transaction holds an OstreeSysroot reference for its duration, which is convenient for callbacks.
2015-08-13 17:56:06 +03:00
}
daemon: Use a peer-to-peer connection for transactions Transaction progress and message signals are really only intended for one recipient: the client that invoked the method. Use a peer-to-peer connection for transactions so we're not spamming the system bus. This entails returning a bus address rather than an object path in methods that use transactions. The client opens a connection to the bus address, connects handlers to the Transaction interface (on path "/"), and then invokes the Start() method. To finish a transaction, the client need only close the connection, either explicitly or by terminating. The server will detect this and clean up resources for that transaction.
2015-08-17 20:42:03 +03:00
const char *
transaction_get_client_address (Transaction *transaction)
{
TransactionPrivate *priv;
g_return_val_if_fail (IS_TRANSACTION (transaction), NULL);
priv = transaction_get_private (transaction);
return g_dbus_server_get_client_address (priv->server);
}
daemon: Rework transactions A few changes: - Modify the D-Bus API to include a Finish() method instead of a Start() method, the idea being the client calls Finish() to obtain the final status and optional message once the transaction indicates it's done. Calling Finish() also removes the transaction object from the bus. - Introduce Transaction class as a thin wrapper for RPMOSTreeTransaction. Stores the status info for Finish(), detects when the caller's bus name vanishes, and emits various status signals to TransactionMonitor. - Introduce TransactionMonitor as a factory class for Transactions that also handles book keeping chores like tracking the active Transaction. The Sysroot and OS interfaces share a TransactionMonitor instance.
2015-07-23 18:30:33 +03:00
void
daemon: Convert transactions to subclasses Implementing a template pattern for transactions. The TransactionClass is now abstract, and transaction_new() is replaced with various method-specific functions like transaction_new_upgrade(). These custom subclasses live in a new file transaction-types.[ch]. Further, transaction_monitor_new_transaction() is replaced with transaction_monitor_add(). So the handlers for "OS" interface methods need only create an appropriate transaction instance and hand it off to the transaction monitor.
2015-08-13 20:17:01 +03:00
transaction_emit_message_printf (Transaction *transaction,
daemon: Rework transactions A few changes: - Modify the D-Bus API to include a Finish() method instead of a Start() method, the idea being the client calls Finish() to obtain the final status and optional message once the transaction indicates it's done. Calling Finish() also removes the transaction object from the bus. - Introduce Transaction class as a thin wrapper for RPMOSTreeTransaction. Stores the status info for Finish(), detects when the caller's bus name vanishes, and emits various status signals to TransactionMonitor. - Introduce TransactionMonitor as a factory class for Transactions that also handles book keeping chores like tracking the active Transaction. The Sysroot and OS interfaces share a TransactionMonitor instance.
2015-07-23 18:30:33 +03:00
const char *format,
...)
{
daemon: Convert transactions to subclasses Implementing a template pattern for transactions. The TransactionClass is now abstract, and transaction_new() is replaced with various method-specific functions like transaction_new_upgrade(). These custom subclasses live in a new file transaction-types.[ch]. Further, transaction_monitor_new_transaction() is replaced with transaction_monitor_add(). So the handlers for "OS" interface methods need only create an appropriate transaction instance and hand it off to the transaction monitor.
2015-08-13 20:17:01 +03:00
g_autofree char *formatted_message = NULL;
daemon: Rework transactions A few changes: - Modify the D-Bus API to include a Finish() method instead of a Start() method, the idea being the client calls Finish() to obtain the final status and optional message once the transaction indicates it's done. Calling Finish() also removes the transaction object from the bus. - Introduce Transaction class as a thin wrapper for RPMOSTreeTransaction. Stores the status info for Finish(), detects when the caller's bus name vanishes, and emits various status signals to TransactionMonitor. - Introduce TransactionMonitor as a factory class for Transactions that also handles book keeping chores like tracking the active Transaction. The Sysroot and OS interfaces share a TransactionMonitor instance.
2015-07-23 18:30:33 +03:00
va_list args;
daemon: Convert transactions to subclasses Implementing a template pattern for transactions. The TransactionClass is now abstract, and transaction_new() is replaced with various method-specific functions like transaction_new_upgrade(). These custom subclasses live in a new file transaction-types.[ch]. Further, transaction_monitor_new_transaction() is replaced with transaction_monitor_add(). So the handlers for "OS" interface methods need only create an appropriate transaction instance and hand it off to the transaction monitor.
2015-08-13 20:17:01 +03:00
g_return_if_fail (IS_TRANSACTION (transaction));
daemon: Rework transactions A few changes: - Modify the D-Bus API to include a Finish() method instead of a Start() method, the idea being the client calls Finish() to obtain the final status and optional message once the transaction indicates it's done. Calling Finish() also removes the transaction object from the bus. - Introduce Transaction class as a thin wrapper for RPMOSTreeTransaction. Stores the status info for Finish(), detects when the caller's bus name vanishes, and emits various status signals to TransactionMonitor. - Introduce TransactionMonitor as a factory class for Transactions that also handles book keeping chores like tracking the active Transaction. The Sysroot and OS interfaces share a TransactionMonitor instance.
2015-07-23 18:30:33 +03:00
g_return_if_fail (format != NULL);
va_start (args, format);
daemon: Convert transactions to subclasses Implementing a template pattern for transactions. The TransactionClass is now abstract, and transaction_new() is replaced with various method-specific functions like transaction_new_upgrade(). These custom subclasses live in a new file transaction-types.[ch]. Further, transaction_monitor_new_transaction() is replaced with transaction_monitor_add(). So the handlers for "OS" interface methods need only create an appropriate transaction instance and hand it off to the transaction monitor.
2015-08-13 20:17:01 +03:00
formatted_message = g_strdup_vprintf (format, args);
daemon: Rework transactions A few changes: - Modify the D-Bus API to include a Finish() method instead of a Start() method, the idea being the client calls Finish() to obtain the final status and optional message once the transaction indicates it's done. Calling Finish() also removes the transaction object from the bus. - Introduce Transaction class as a thin wrapper for RPMOSTreeTransaction. Stores the status info for Finish(), detects when the caller's bus name vanishes, and emits various status signals to TransactionMonitor. - Introduce TransactionMonitor as a factory class for Transactions that also handles book keeping chores like tracking the active Transaction. The Sysroot and OS interfaces share a TransactionMonitor instance.
2015-07-23 18:30:33 +03:00
va_end (args);
daemon: Convert transactions to subclasses Implementing a template pattern for transactions. The TransactionClass is now abstract, and transaction_new() is replaced with various method-specific functions like transaction_new_upgrade(). These custom subclasses live in a new file transaction-types.[ch]. Further, transaction_monitor_new_transaction() is replaced with transaction_monitor_add(). So the handlers for "OS" interface methods need only create an appropriate transaction instance and hand it off to the transaction monitor.
2015-08-13 20:17:01 +03:00
rpmostree_transaction_emit_message (RPMOSTREE_TRANSACTION (transaction),
formatted_message);
daemon: Rework transactions A few changes: - Modify the D-Bus API to include a Finish() method instead of a Start() method, the idea being the client calls Finish() to obtain the final status and optional message once the transaction indicates it's done. Calling Finish() also removes the transaction object from the bus. - Introduce Transaction class as a thin wrapper for RPMOSTreeTransaction. Stores the status info for Finish(), detects when the caller's bus name vanishes, and emits various status signals to TransactionMonitor. - Introduce TransactionMonitor as a factory class for Transactions that also handles book keeping chores like tracking the active Transaction. The Sysroot and OS interfaces share a TransactionMonitor instance.
2015-07-23 18:30:33 +03:00
}
void
daemon: Convert transactions to subclasses Implementing a template pattern for transactions. The TransactionClass is now abstract, and transaction_new() is replaced with various method-specific functions like transaction_new_upgrade(). These custom subclasses live in a new file transaction-types.[ch]. Further, transaction_monitor_new_transaction() is replaced with transaction_monitor_add(). So the handlers for "OS" interface methods need only create an appropriate transaction instance and hand it off to the transaction monitor.
2015-08-13 20:17:01 +03:00
transaction_connect_download_progress (Transaction *transaction,
daemon: Rework transactions A few changes: - Modify the D-Bus API to include a Finish() method instead of a Start() method, the idea being the client calls Finish() to obtain the final status and optional message once the transaction indicates it's done. Calling Finish() also removes the transaction object from the bus. - Introduce Transaction class as a thin wrapper for RPMOSTreeTransaction. Stores the status info for Finish(), detects when the caller's bus name vanishes, and emits various status signals to TransactionMonitor. - Introduce TransactionMonitor as a factory class for Transactions that also handles book keeping chores like tracking the active Transaction. The Sysroot and OS interfaces share a TransactionMonitor instance.
2015-07-23 18:30:33 +03:00
OstreeAsyncProgress *progress)
{
daemon: Convert transactions to subclasses Implementing a template pattern for transactions. The TransactionClass is now abstract, and transaction_new() is replaced with various method-specific functions like transaction_new_upgrade(). These custom subclasses live in a new file transaction-types.[ch]. Further, transaction_monitor_new_transaction() is replaced with transaction_monitor_add(). So the handlers for "OS" interface methods need only create an appropriate transaction instance and hand it off to the transaction monitor.
2015-08-13 20:17:01 +03:00
g_return_if_fail (IS_TRANSACTION (transaction));
daemon: Rework transactions A few changes: - Modify the D-Bus API to include a Finish() method instead of a Start() method, the idea being the client calls Finish() to obtain the final status and optional message once the transaction indicates it's done. Calling Finish() also removes the transaction object from the bus. - Introduce Transaction class as a thin wrapper for RPMOSTreeTransaction. Stores the status info for Finish(), detects when the caller's bus name vanishes, and emits various status signals to TransactionMonitor. - Introduce TransactionMonitor as a factory class for Transactions that also handles book keeping chores like tracking the active Transaction. The Sysroot and OS interfaces share a TransactionMonitor instance.
2015-07-23 18:30:33 +03:00
g_return_if_fail (OSTREE_IS_ASYNC_PROGRESS (progress));
g_signal_connect_object (progress,
"changed",
G_CALLBACK (transaction_progress_changed_cb),
transaction, 0);
}
void
daemon: Convert transactions to subclasses Implementing a template pattern for transactions. The TransactionClass is now abstract, and transaction_new() is replaced with various method-specific functions like transaction_new_upgrade(). These custom subclasses live in a new file transaction-types.[ch]. Further, transaction_monitor_new_transaction() is replaced with transaction_monitor_add(). So the handlers for "OS" interface methods need only create an appropriate transaction instance and hand it off to the transaction monitor.
2015-08-13 20:17:01 +03:00
transaction_connect_signature_progress (Transaction *transaction,
daemon: Rework transactions A few changes: - Modify the D-Bus API to include a Finish() method instead of a Start() method, the idea being the client calls Finish() to obtain the final status and optional message once the transaction indicates it's done. Calling Finish() also removes the transaction object from the bus. - Introduce Transaction class as a thin wrapper for RPMOSTreeTransaction. Stores the status info for Finish(), detects when the caller's bus name vanishes, and emits various status signals to TransactionMonitor. - Introduce TransactionMonitor as a factory class for Transactions that also handles book keeping chores like tracking the active Transaction. The Sysroot and OS interfaces share a TransactionMonitor instance.
2015-07-23 18:30:33 +03:00
OstreeRepo *repo)
{
daemon: Convert transactions to subclasses Implementing a template pattern for transactions. The TransactionClass is now abstract, and transaction_new() is replaced with various method-specific functions like transaction_new_upgrade(). These custom subclasses live in a new file transaction-types.[ch]. Further, transaction_monitor_new_transaction() is replaced with transaction_monitor_add(). So the handlers for "OS" interface methods need only create an appropriate transaction instance and hand it off to the transaction monitor.
2015-08-13 20:17:01 +03:00
g_return_if_fail (IS_TRANSACTION (transaction));
daemon: Rework transactions A few changes: - Modify the D-Bus API to include a Finish() method instead of a Start() method, the idea being the client calls Finish() to obtain the final status and optional message once the transaction indicates it's done. Calling Finish() also removes the transaction object from the bus. - Introduce Transaction class as a thin wrapper for RPMOSTreeTransaction. Stores the status info for Finish(), detects when the caller's bus name vanishes, and emits various status signals to TransactionMonitor. - Introduce TransactionMonitor as a factory class for Transactions that also handles book keeping chores like tracking the active Transaction. The Sysroot and OS interfaces share a TransactionMonitor instance.
2015-07-23 18:30:33 +03:00
g_return_if_fail (OSTREE_REPO (repo));
g_signal_connect_object (repo, "gpg-verify-result",
G_CALLBACK (transaction_gpg_verify_result_cb),
transaction, 0);
}
Reference in New Issue Copy Permalink