proxmox-mirrors/fwupd
1
0
Fork 0
mirror of https://git.proxmox.com/git/fwupd synced 2025-08-03 06:09:51 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Do not store the newest release as part of the FuDevice object

Browse Source
This commit is contained in:
Richard Hughes 2017-09-13 19:28:17 +01:00
parent e7fd8eb81f
commit cc3de2efa4
8 changed files with 119 additions and 213 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
libfwupd/fwupd-device.c
View File

@ -931,6 +931,12 @@ fwupd_device_to_data (FwupdDevice *device, const gchar *type_string)
return g_variant_new ("a{sv}", &builder);
if (g_strcmp0 (type_string, "(a{sv})") == 0)
return g_variant_new ("(a{sv})", &builder);
if (g_strcmp0 (type_string, "{sa{sv}}") == 0) {
const gchar *device_id = fwupd_device_get_id (device);
if (device_id == NULL)
device_id = "";
return g_variant_new ("{sa{sv}}", device_id, &builder);
}
return NULL;
}

20
src/fu-device-private.h
View File

@ -26,21 +26,13 @@
G_BEGIN_DECLS
#define fu_device_get_update_filename(d) fwupd_release_get_filename(fu_device_get_release(d))
#define fu_device_set_update_description(d,v) fwupd_release_set_description(fu_device_get_release(d),v)
#define fu_device_set_update_filename(d,v) fwupd_release_set_filename(fu_device_get_release(d),v)
#define fu_device_set_update_homepage(d,v) fwupd_release_set_homepage(fu_device_get_release(d),v)
#define fu_device_set_update_id(d,v) fwupd_release_set_appstream_id(fu_device_get_release(d),v)
#define fu_device_set_update_license(d,v) fwupd_release_set_license(fu_device_get_release(d),v)
#define fu_device_set_update_name(d,v) fwupd_release_set_name(fu_device_get_release(d),v)
#define fu_device_set_update_remote_id(d,v) fwupd_release_set_remote_id(fu_device_get_release(d),v)
#define fu_device_set_update_summary(d,v) fwupd_release_set_summary(fu_device_get_release(d),v)
#define fu_device_set_update_uri(d,v) fwupd_release_set_uri(fu_device_get_release(d),v)
#define fu_device_set_update_vendor(d,v) fwupd_release_set_vendor(fu_device_get_release(d),v)
#define fu_device_set_update_version(d,v) fwupd_release_set_version(fu_device_get_release(d),v)
gchar *fu_device_to_string (FuDevice *device);
FwupdRelease *fu_device_get_release (FuDevice *device);
const gchar *fu_device_get_version_new (FuDevice *device);
void fu_device_set_version_new (FuDevice *device,
const gchar *version_new);
const gchar *fu_device_get_filename_pending (FuDevice *device);
void fu_device_set_filename_pending (FuDevice *device,
const gchar *filename_pending);
G_END_DECLS

57
src/fu-device.c
View File

@ -32,9 +32,10 @@ static void fu_device_finalize (GObject *object);
typedef struct {
gchar *equivalent_id;
gchar *version_new;
gchar *filename_pending;
FuDevice *alternate;
GHashTable *metadata;
FwupdRelease *release;
} FuDevicePrivate;
G_DEFINE_TYPE_WITH_PRIVATE (FuDevice, fu_device, FWUPD_TYPE_DEVICE)
@ -57,12 +58,38 @@ fu_device_set_equivalent_id (FuDevice *device, const gchar *equivalent_id)
priv->equivalent_id = g_strdup (equivalent_id);
}
FwupdRelease *
fu_device_get_release (FuDevice *device)
const gchar *
fu_device_get_version_new (FuDevice *device)
{
FuDevicePrivate *priv = GET_PRIVATE (device);
g_return_val_if_fail (FU_IS_DEVICE (device), NULL);
return priv->release;
return priv->version_new;
}
void
fu_device_set_version_new (FuDevice *device, const gchar *version_new)
{
FuDevicePrivate *priv = GET_PRIVATE (device);
g_return_if_fail (FU_IS_DEVICE (device));
g_free (priv->version_new);
priv->version_new = g_strdup (version_new);
}
const gchar *
fu_device_get_filename_pending (FuDevice *device)
{
FuDevicePrivate *priv = GET_PRIVATE (device);
g_return_val_if_fail (FU_IS_DEVICE (device), NULL);
return priv->filename_pending;
}
void
fu_device_set_filename_pending (FuDevice *device, const gchar *filename_pending)
{
FuDevicePrivate *priv = GET_PRIVATE (device);
g_return_if_fail (FU_IS_DEVICE (device));
g_free (priv->filename_pending);
priv->filename_pending = g_strdup (filename_pending);
}
FuDevice *
@ -265,22 +292,20 @@ fu_device_to_string (FuDevice *device)
{
FuDevicePrivate *priv = GET_PRIVATE (device);
GString *str = g_string_new ("");
g_autofree gchar *tmp = NULL;
g_autoptr(GList) keys = NULL;
g_return_val_if_fail (FU_IS_DEVICE (device), NULL);
if (TRUE) {
g_autofree gchar *tmp = fwupd_device_to_string (FWUPD_DEVICE (device));
if (tmp != NULL && tmp[0] != '\0')
g_string_append (str, tmp);
}
if (TRUE) {
g_autofree gchar *tmp = fwupd_release_to_string (priv->release);
if (tmp != NULL && tmp[0] != '\0')
g_string_append (str, tmp);
}
tmp = fwupd_device_to_string (FWUPD_DEVICE (device));
if (tmp != NULL && tmp[0] != '\0')
g_string_append (str, tmp);
if (priv->equivalent_id != NULL)
fwupd_pad_kv_str (str, "EquivalentId", priv->equivalent_id);
if (priv->filename_pending != NULL)
fwupd_pad_kv_str (str, "FilenamePending", priv->filename_pending);
if (priv->version_new != NULL)
fwupd_pad_kv_str (str, "VersionNew", priv->version_new);
keys = g_hash_table_get_keys (priv->metadata);
for (GList *l = keys; l != NULL; l = l->next) {
const gchar *key = l->data;
@ -301,7 +326,6 @@ static void
fu_device_init (FuDevice *device)
{
FuDevicePrivate *priv = GET_PRIVATE (device);
priv->release = fwupd_release_new ();
priv->metadata = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free, g_free);
}
@ -316,7 +340,8 @@ fu_device_finalize (GObject *object)
g_object_unref (priv->alternate);
g_hash_table_unref (priv->metadata);
g_free (priv->equivalent_id);
g_object_unref (priv->release);
g_free (priv->version_new);
g_free (priv->filename_pending);
G_OBJECT_CLASS (fu_device_parent_class)->finalize (object);
}

142
src/fu-engine.c
View File

@ -32,6 +32,7 @@
#include "fwupd-error.h"
#include "fwupd-release-private.h"
#include "fwupd-remote-private.h"
#include "fwupd-result-private.h"
#include "fwupd-resources.h"
#include "fu-common.h"
@ -95,8 +96,6 @@ typedef struct {
FuPlugin *plugin;
} FuDeviceItem;
static gboolean fu_engine_get_updates_item_update (FuEngine *self, FuDeviceItem *item);
static void
fu_engine_emit_changed (FuEngine *self)
{
@ -1142,7 +1141,7 @@ fu_engine_install (FuEngine *self,
}
version = as_release_get_version (rel);
fu_device_set_update_version (item->device, version);
fu_device_set_version_new (item->device, version);
/* compare to the lowest supported version, if it exists */
tmp = fu_device_get_version_lowest (item->device);
@ -1732,125 +1731,19 @@ fu_engine_update_metadata (FuEngine *self, const gchar *remote_id,
}
static gboolean
fu_engine_get_updates_item_update (FuEngine *self, FuDeviceItem *item)
fu_engine_is_device_supported (FuEngine *self, FuDevice *device)
{
AsApp *app;
AsRelease *release;
GBytes *remote_blob;
GPtrArray *releases;
const gchar *tmp;
const gchar *version;
g_autoptr(GError) error = NULL;
g_autoptr(GPtrArray) updates_list = NULL;
/* get device version */
version = fu_device_get_version (item->device);
if (version == NULL)
/* no device version */
if (fu_device_get_version (device) == NULL)
return FALSE;
/* match the GUIDs in the XML */
app = fu_engine_store_get_app_by_guids (self->store, item->device);
app = fu_engine_store_get_app_by_guids (self->store, device);
if (app == NULL)
return FALSE;
/* get latest release */
release = as_app_get_release_default (app);
if (release == NULL) {
g_debug ("%s [%s] has no firmware update metadata",
fu_device_get_id (item->device),
fu_device_get_name (item->device));
return FALSE;
}
/* supported in metadata */
fu_device_add_flag (item->device, FWUPD_DEVICE_FLAG_SUPPORTED);
/* check if actually newer than what we have installed */
if (as_utils_vercmp (as_release_get_version (release), version) <= 0) {
g_debug ("%s has no firmware updates",
fu_device_get_id (item->device));
return FALSE;
}
/* check we can install it */
if (!fu_engine_check_requirements (app, item->device, &error)) {
g_debug ("can not be installed: %s", error->message);
return FALSE;
}
/* only show devices that can be updated */
if (!fu_device_has_flag (item->device, FWUPD_DEVICE_FLAG_UPDATABLE)) {
g_debug ("ignoring %s [%s] as not updatable",
fu_device_get_id (item->device),
fu_device_get_name (item->device));
return FALSE;
}
/* add application metadata */
fu_device_set_update_id (item->device, as_app_get_id (app));
tmp = as_app_get_developer_name (app, NULL);
if (tmp != NULL)
fu_device_set_update_vendor (item->device, tmp);
tmp = as_app_get_name (app, NULL);
if (tmp != NULL)
fu_device_set_update_name (item->device, tmp);
tmp = as_app_get_comment (app, NULL);
if (tmp != NULL)
fu_device_set_update_summary (item->device, tmp);
tmp = as_app_get_description (app, NULL);
if (tmp != NULL)
fu_device_set_description (item->device, tmp);
tmp = as_app_get_url_item (app, AS_URL_KIND_HOMEPAGE);
if (tmp != NULL)
fu_device_set_update_homepage (item->device, tmp);
tmp = as_app_get_project_license (app);
if (tmp != NULL)
fu_device_set_update_license (item->device, tmp);
remote_blob = as_release_get_blob (release, "fwupd::RemoteID");
if (remote_blob != NULL) {
fu_device_set_update_remote_id (item->device,
g_bytes_get_data (remote_blob, NULL));
}
/* add release information */
fu_engine_set_release_from_appstream (self,
fu_device_get_release (item->device),
release);
/* get the list of releases newer than the one installed */
updates_list = g_ptr_array_new ();
releases = as_app_get_releases (app);
for (guint i = 0; i < releases->len; i++) {
release = g_ptr_array_index (releases, i);
if (as_utils_vercmp (as_release_get_version (release), version) <= 0)
continue;
tmp = as_release_get_description (release, NULL);
if (tmp == NULL)
continue;
g_ptr_array_add (updates_list, release);
}
/* no prefix on each release */
if (updates_list->len == 1) {
release = g_ptr_array_index (updates_list, 0);
fu_device_set_update_description (item->device,
as_release_get_description (release, NULL));
} else {
g_autoptr(GString) update_desc = NULL;
update_desc = g_string_new ("");
/* get the descriptions with a version prefix */
for (guint i = 0; i < updates_list->len; i++) {
release = g_ptr_array_index (updates_list, i);
g_string_append_printf (update_desc,
"<p>%s:</p>%s",
as_release_get_version (release),
as_release_get_description (release, NULL));
}
if (update_desc->len > 0)
fu_device_set_update_description (item->device, update_desc->str);
}
/* success */
return TRUE;
}
@ -2069,7 +1962,7 @@ fu_engine_get_devices (FuEngine *self, GError **error)
*
* Gets the list of updates.
*
* Returns: (transfer container) (element-type FwupdDevice): results
* Returns: (transfer container) (element-type FwupdResult): results
**/
GPtrArray *
fu_engine_get_updates (FuEngine *self, GError **error)
@ -2082,8 +1975,20 @@ fu_engine_get_updates (FuEngine *self, GError **error)
updates = g_ptr_array_new_with_free_func ((GDestroyNotify) g_object_unref);
for (guint i = 0; i < self->devices->len; i++) {
FuDeviceItem *item = g_ptr_array_index (self->devices, i);
if (fu_engine_get_updates_item_update (self, item))
g_ptr_array_add (updates, g_object_ref (item->device));
g_autoptr(GError) error_local = NULL;
g_autoptr(GPtrArray) rels = NULL;
g_autoptr(FwupdResult) result = fwupd_result_new ();
FwupdRelease *rel_default;
rels = fu_engine_get_upgrades (self, fu_device_get_id (item->device), &error_local);
if (rels == NULL) {
g_debug ("no upgrades: %s", error_local->message);
continue;
}
rel_default = g_ptr_array_index (rels, 0);
fwupd_result_set_release (result, rel_default);
fwupd_result_set_device (result, FWUPD_DEVICE (item->device));
g_ptr_array_add (updates, g_steal_pointer (&result));
}
if (updates->len == 0) {
g_set_error_literal (error,
@ -2183,7 +2088,7 @@ fu_engine_get_releases_for_device (FuEngine *self, FuDevice *device, GError **er
/* create new FwupdRelease for the AsRelease */
fwupd_release_set_appstream_id (rel, as_app_get_id (app));
fu_engine_set_release_from_appstream (self, rel, app, release);
fu_engine_set_release_from_appstream (self, rel, release);
/* invalid */
if (fwupd_release_get_uri (rel) == NULL)
@ -2644,7 +2549,8 @@ fu_engine_plugin_device_added_cb (FuPlugin *plugin,
/* match the metadata at this point so clients can tell if the
* device is worthy */
fu_engine_get_updates_item_update (self, item);
if (fu_engine_is_device_supported (self, item->device))
fu_device_add_flag (item->device, FWUPD_DEVICE_FLAG_SUPPORTED);
/* notify clients */
fu_engine_emit_device_added (self, item->device);

8
src/fu-main.c
View File

@ -189,11 +189,7 @@ fu_main_device_array_to_variant (GPtrArray *devices)
g_variant_builder_init (&builder, G_VARIANT_TYPE_ARRAY);
for (guint i = 0; i < devices->len; i++) {
FuDevice *device = g_ptr_array_index (devices, i);
GVariant *tmp;
g_autoptr(FwupdResult) result = fwupd_result_new ();
fwupd_result_set_device (result, FWUPD_DEVICE (device));
fwupd_result_set_release (result, fu_device_get_release (device));
tmp = fwupd_result_to_data (result, "{sa{sv}}");
GVariant *tmp = fwupd_device_to_data (FWUPD_DEVICE (device), "{sa{sv}}");
g_variant_builder_add_value (&builder, tmp);
}
return g_variant_new ("(a{sa{sv}})", &builder);
@ -437,7 +433,7 @@ fu_main_daemon_method_call (GDBusConnection *connection, const gchar *sender,
g_dbus_method_invocation_return_gerror (invocation, error);
return;
}
val = fu_main_device_array_to_variant (updates);
val = fu_main_result_array_to_variant (updates);
g_dbus_method_invocation_return_value (invocation, val);
return;
}

53
src/fu-pending.c
View File

@ -137,8 +137,6 @@ gboolean
fu_pending_add_device (FuPending *pending, FuDevice *device, GError **error)
{
FuPendingPrivate *priv = GET_PRIVATE (pending);
FwupdDevice *dev = FWUPD_DEVICE (device);
FwupdRelease *rel = fu_device_get_release (device);
char *error_msg = NULL;
char *statement;
gboolean ret = TRUE;
@ -152,7 +150,7 @@ fu_pending_add_device (FuPending *pending, FuDevice *device, GError **error)
return FALSE;
}
g_debug ("FuPending: add device %s", fwupd_device_get_id (dev));
g_debug ("FuPending: add device %s", fu_device_get_id (device));
statement = sqlite3_mprintf ("INSERT INTO pending (device_id,"
"state,"
"filename,"
@ -161,13 +159,13 @@ fu_pending_add_device (FuPending *pending, FuDevice *device, GError **error)
"version_old,"
"version_new) "
"VALUES ('%q','%i','%q','%q','%q','%q','%q')",
fwupd_device_get_id (dev),
fu_device_get_id (device),
FWUPD_UPDATE_STATE_PENDING,
fwupd_release_get_filename (rel),
fwupd_device_get_name (dev),
fwupd_device_get_provider (dev),
fwupd_device_get_version (dev),
fwupd_release_get_version (rel));
fu_device_get_filename_pending (device),
fu_device_get_name (device),
fu_device_get_plugin (device),
fu_device_get_version (device),
fu_device_get_version_new (device));
/* insert entry */
rc = sqlite3_exec (priv->db, statement, NULL, NULL, &error_msg);
@ -219,7 +217,6 @@ gboolean
fu_pending_remove_device (FuPending *pending, FuDevice *device, GError **error)
{
FuPendingPrivate *priv = GET_PRIVATE (pending);
FwupdDevice *dev = FWUPD_DEVICE (device);
char *error_msg = NULL;
char *statement;
gboolean ret = TRUE;
@ -233,10 +230,10 @@ fu_pending_remove_device (FuPending *pending, FuDevice *device, GError **error)
return FALSE;
}
g_debug ("FuPending: remove device %s", fwupd_device_get_id (dev));
g_debug ("FuPending: remove device %s", fu_device_get_id (device));
statement = sqlite3_mprintf ("DELETE FROM pending WHERE "
"device_id = '%q';",
fwupd_device_get_id (dev));
fu_device_get_id (device));
/* remove entry */
rc = sqlite3_exec (priv->db, statement, NULL, NULL, &error_msg);
@ -262,56 +259,52 @@ fu_pending_device_sqlite_cb (void *data,
gchar **col_name)
{
GPtrArray *array = (GPtrArray *) data;
FwupdDevice *dev;
FwupdRelease *rel;
FuDevice *device;
/* create new result */
device = fu_device_new ();
rel = fu_device_get_release (device);
dev = FWUPD_DEVICE (device);
g_ptr_array_add (array, device);
g_debug ("FuPending: got sql result %s", argv[0]);
for (gint i = 0; i < argc; i++) {
if (g_strcmp0 (col_name[i], "device_id") == 0) {
fwupd_device_set_id (dev, argv[i]);
fu_device_set_id (device, argv[i]);
continue;
}
if (g_strcmp0 (col_name[i], "filename") == 0) {
fwupd_release_set_filename (rel, argv[i]);
fu_device_set_filename_pending (device, argv[i]);
continue;
}
if (g_strcmp0 (col_name[i], "display_name") == 0) {
fwupd_device_set_name (dev, argv[i]);
fu_device_set_name (device, argv[i]);
continue;
}
if (g_strcmp0 (col_name[i], "version_old") == 0) {
fwupd_device_set_version (dev, argv[i]);
fu_device_set_version (device, argv[i]);
continue;
}
if (g_strcmp0 (col_name[i], "version_new") == 0) {
fwupd_release_set_version (rel, argv[i]);
fu_device_set_version_new (device, argv[i]);
continue;
}
if (g_strcmp0 (col_name[i], "provider") == 0) {
fwupd_device_set_provider (dev, argv[i]);
fu_device_set_plugin (device, argv[i]);
continue;
}
if (g_strcmp0 (col_name[i], "state") == 0) {
FwupdUpdateState state = atoi (argv[i]);
fwupd_device_set_update_state (dev, state);
fu_device_set_update_state (device, state);
continue;
}
if (g_strcmp0 (col_name[i], "timestamp") == 0) {
guint64 timestamp = g_ascii_strtoull (argv[i], NULL, 10);
if (timestamp > 0)
fwupd_device_set_created (dev, timestamp);
fu_device_set_created (device, timestamp);
continue;
}
if (g_strcmp0 (col_name[i], "error") == 0) {
if (argv[i] != NULL)
fwupd_device_set_update_error (dev, argv[i]);
fu_device_set_update_error (device, argv[i]);
continue;
}
}
@ -421,7 +414,6 @@ fu_pending_set_state (FuPending *pending,
GError **error)
{
FuPendingPrivate *priv = GET_PRIVATE (pending);
FwupdDevice *dev = FWUPD_DEVICE (device);
char *error_msg = NULL;
char *statement;
gboolean ret = TRUE;
@ -436,11 +428,11 @@ fu_pending_set_state (FuPending *pending,
}
g_debug ("FuPending: set state of %s to %s",
fwupd_device_get_id (dev),
fu_device_get_id (device),
fwupd_update_state_to_string (state));
statement = sqlite3_mprintf ("UPDATE pending SET state='%i' WHERE "
"device_id = '%q';",
state, fwupd_device_get_id (dev));
state, fu_device_get_id (device));
/* remove entry */
rc = sqlite3_exec (priv->db, statement, NULL, NULL, &error_msg);
@ -466,7 +458,6 @@ fu_pending_set_error_msg (FuPending *pending,
GError **error)
{
FuPendingPrivate *priv = GET_PRIVATE (pending);
FwupdDevice *dev = FWUPD_DEVICE (device);
char *error_msg = NULL;
char *statement;
gboolean ret = TRUE;
@ -481,11 +472,11 @@ fu_pending_set_error_msg (FuPending *pending,
}
g_debug ("FuPending: add comment to %s: %s",
fwupd_device_get_id (dev), error_msg2);
fu_device_get_id (device), error_msg2);
statement = sqlite3_mprintf ("UPDATE pending SET error='%q' WHERE "
"device_id = '%q';",
error_msg2,
fwupd_device_get_id (dev));
fu_device_get_id (device));
/* remove entry */
rc = sqlite3_exec (priv->db, statement, NULL, NULL, &error_msg);

19
src/fu-plugin.c
View File

@ -887,7 +887,7 @@ fu_plugin_runner_schedule_update (FuPlugin *plugin,
/* schedule for next boot */
g_debug ("schedule %s to be installed to %s on next boot",
filename, fu_device_get_id (device));
fu_device_set_update_filename (device, filename);
fu_device_set_filename_pending (device, filename);
/* add to database */
if (!fu_pending_add_device (pending, device, error))
@ -1027,14 +1027,13 @@ fu_plugin_runner_update (FuPlugin *plugin,
/* cleanup */
if (device_pending != NULL) {
const gchar *tmp;
FwupdRelease *rel = fu_device_get_release (device_pending);
/* update pending database */
fu_pending_set_state (pending, device,
FWUPD_UPDATE_STATE_SUCCESS, NULL);
/* delete cab file */
tmp = fwupd_release_get_filename (rel);
tmp = fu_device_get_filename_pending (device_pending);
if (tmp != NULL && g_str_has_prefix (tmp, LIBEXECDIR)) {
g_autoptr(GError) error_local = NULL;
g_autoptr(GFile) file = NULL;
@ -1101,8 +1100,6 @@ fu_plugin_runner_get_results (FuPlugin *plugin, FuDevice *device, GError **error
FuPluginPrivate *priv = GET_PRIVATE (plugin);
FuPluginDeviceFunc func = NULL;
FwupdUpdateState update_state;
FwupdRelease *rel;
FwupdDevice *dev;
const gchar *tmp;
g_autoptr(GError) error_local = NULL;
g_autoptr(FuDevice) device_pending = NULL;
@ -1139,8 +1136,7 @@ fu_plugin_runner_get_results (FuPlugin *plugin, FuDevice *device, GError **error
}
/* copy the important parts from the pending device to the real one */
dev = FWUPD_DEVICE (device_pending);
update_state = fwupd_device_get_update_state (dev);
update_state = fu_device_get_update_state (device_pending);
if (update_state == FWUPD_UPDATE_STATE_UNKNOWN ||
update_state == FWUPD_UPDATE_STATE_PENDING) {
g_set_error (error,
@ -1153,16 +1149,15 @@ fu_plugin_runner_get_results (FuPlugin *plugin, FuDevice *device, GError **error
/* copy */
fu_device_set_update_state (device, update_state);
tmp = fwupd_device_get_update_error (dev);
tmp = fu_device_get_update_error (device_pending);
if (tmp != NULL)
fu_device_set_update_error (device, tmp);
tmp = fwupd_device_get_version (dev);
tmp = fu_device_get_version (device_pending);
if (tmp != NULL)
fu_device_set_version (device, tmp);
rel = fu_device_get_release (device_pending);
tmp = fwupd_release_get_version (rel);
tmp = fu_device_get_version_new (device_pending);
if (tmp != NULL)
fu_device_set_update_version (device, tmp);
fu_device_set_version_new (device, tmp);
return TRUE;
}

27
src/fu-self-test.c
View File

@ -327,10 +327,10 @@ fu_plugin_module_func (void)
g_assert (device2 != NULL);
g_assert_cmpint (fu_device_get_update_state (device2), ==, FWUPD_UPDATE_STATE_PENDING);
g_assert_cmpstr (fu_device_get_update_error (device2), ==, NULL);
g_assert_cmpstr (fu_device_get_update_filename (device2), !=, NULL);
g_assert_cmpstr (fu_device_get_filename_pending (device2), !=, NULL);
/* save this; we'll need to delete it later */
pending_cap = g_strdup (fu_device_get_update_filename (device2));
pending_cap = g_strdup (fu_device_get_filename_pending (device2));
/* lets do this online */
ret = fu_plugin_runner_update (plugin, device, blob_cab, NULL,
@ -384,8 +384,6 @@ fu_pending_func (void)
GError *error = NULL;
gboolean ret;
FuDevice *device;
FwupdDevice *dev;
FwupdRelease *rel;
g_autoptr(FuPending) pending = NULL;
g_autofree gchar *dirname = NULL;
g_autofree gchar *filename = NULL;
@ -404,10 +402,10 @@ fu_pending_func (void)
/* add a device */
device = fu_device_new ();
fu_device_set_id (device, "self-test");
fu_device_set_update_filename (device, "/var/lib/dave.cap"),
fu_device_set_filename_pending (device, "/var/lib/dave.cap"),
fu_device_set_name (device, "ColorHug"),
fu_device_set_version (device, "3.0.1"),
fu_device_set_update_version (device, "3.0.2");
fu_device_set_version_new (device, "3.0.2");
ret = fu_pending_add_device (pending, device, &error);
g_assert_no_error (error);
g_assert (ret);
@ -431,16 +429,13 @@ fu_pending_func (void)
device = fu_pending_get_device (pending, "self-test", &error);
g_assert_no_error (error);
g_assert (device != NULL);
dev = FWUPD_DEVICE (device);
g_assert_cmpstr (fwupd_device_get_id (dev), ==, "self-test");
g_assert_cmpstr (fwupd_device_get_name (dev), ==, "ColorHug");
g_assert_cmpstr (fwupd_device_get_version (dev), ==, "3.0.1");
g_assert_cmpint (fwupd_device_get_update_state (dev), ==, FWUPD_UPDATE_STATE_PENDING);
g_assert_cmpstr (fwupd_device_get_update_error (dev), ==, "word");
rel = fu_device_get_release (device);
g_assert (rel != NULL);
g_assert_cmpstr (fwupd_release_get_filename (rel), ==, "/var/lib/dave.cap");
g_assert_cmpstr (fwupd_release_get_version (rel), ==, "3.0.2");
g_assert_cmpstr (fu_device_get_id (device), ==, "self-test");
g_assert_cmpstr (fu_device_get_name (device), ==, "ColorHug");
g_assert_cmpstr (fu_device_get_version (device), ==, "3.0.1");
g_assert_cmpint (fu_device_get_update_state (device), ==, FWUPD_UPDATE_STATE_PENDING);
g_assert_cmpstr (fu_device_get_update_error (device), ==, "word");
g_assert_cmpstr (fu_device_get_filename_pending (device), ==, "/var/lib/dave.cap");
g_assert_cmpstr (fu_device_get_version_new (device), ==, "3.0.2");
g_object_unref (device);
/* get device that does not exist */