void
storage_block_update_pv (StorageBlock *self,
StorageVolumeGroup *group,
GVariant *pv_info)
{
StorageDaemon *daemon;
g_return_if_fail (STORAGE_IS_BLOCK (self));
daemon = storage_daemon_get ();
if (group)
{
if (self->iface_physical_volume == NULL)
{
self->iface_physical_volume = storage_physical_volume_new ();
storage_physical_volume_update (self->iface_physical_volume, group, pv_info);
storage_daemon_publish (daemon, storage_block_get_object_path (self), FALSE, self->iface_physical_volume);
}
else
{
storage_physical_volume_update (self->iface_physical_volume, group, pv_info);
}
}
else
{
if (self->iface_physical_volume != NULL)
{
storage_daemon_unpublish (daemon, storage_block_get_object_path (self), self->iface_physical_volume);
g_object_unref (self->iface_physical_volume);
self->iface_physical_volume = NULL;
}
}
}
static void
on_manager_ready (GObject *source,
GAsyncResult *res,
gpointer user_data)
{
StorageDaemon *self = user_data;
self->manager = storage_manager_new_finish (source, res);
storage_daemon_publish (self, "/org/freedesktop/UDisks2/Manager", FALSE, self->manager);
self->name_owner_id = g_bus_own_name_on_connection (self->connection,
"com.redhat.storaged",
self->name_flags,
on_name_acquired,
on_name_lost,
self,
NULL);
}
void
storage_block_update_lv (StorageBlock *self,
StorageLogicalVolume *lv)
{
const gchar *logical_volume_path;
StorageDaemon *daemon;
g_return_if_fail (STORAGE_IS_BLOCK (self));
daemon = storage_daemon_get ();
if (lv == NULL)
{
if (self->iface_logical_volume)
{
storage_daemon_unpublish (daemon, storage_block_get_object_path (self), self->iface_logical_volume);
g_object_unref (self->iface_logical_volume);
self->iface_logical_volume = NULL;
}
}
else
{
logical_volume_path = storage_logical_volume_get_object_path (lv);
if (self->iface_logical_volume)
{
lvm_logical_volume_block_set_logical_volume (self->iface_logical_volume,
logical_volume_path);
}
else
{
self->iface_logical_volume = lvm_logical_volume_block_skeleton_new ();
lvm_logical_volume_block_set_logical_volume (self->iface_logical_volume,
logical_volume_path);
storage_daemon_publish (daemon, storage_block_get_object_path (self), FALSE, self->iface_logical_volume);
}
}
}
static void
update_with_variant (GPid pid,
GVariant *info,
GError *error,
gpointer user_data)
{
struct UpdateData *data = user_data;
StorageVolumeGroup *self = data->self;
GVariantIter *iter;
GHashTableIter volume_iter;
gpointer key, value;
GHashTable *new_lvs;
gboolean needs_polling = FALSE;
StorageDaemon *daemon;
gchar *path;
daemon = storage_daemon_get ();
if (!error)
volume_group_update_props (self, info, &needs_polling);
/* After basic props, publish group, if not already done */
if (self->need_publish)
{
self->need_publish = FALSE;
path = storage_util_build_object_path ("/org/freedesktop/UDisks2/lvm",
storage_volume_group_get_name (self), NULL);
storage_daemon_publish (daemon, path, FALSE, self);
g_free (path);
}
if (error)
{
g_message ("Failed to update LVM volume group %s: %s",
storage_volume_group_get_name (self), error->message);
g_object_unref (self);
return;
}
if (self->info && g_variant_equal (self->info, info))
{
g_debug ("%s updated without changes", self->name);
g_object_unref (self);
return;
}
if (self->info)
g_variant_unref (self->info);
self->info = g_variant_ref (info);
new_lvs = g_hash_table_new (g_str_hash, g_str_equal);
if (g_variant_lookup (info, "lvs", "aa{sv}", &iter))
{
GVariant *lv_info = NULL;
while (g_variant_iter_loop (iter, "@a{sv}", &lv_info))
{
const gchar *name;
StorageLogicalVolume *volume;
g_variant_lookup (lv_info, "name", "&s", &name);
update_operations (name, lv_info, &needs_polling);
if (lv_is_pvmove_volume (name))
needs_polling = TRUE;
if (!lv_is_visible (name))
continue;
volume = g_hash_table_lookup (self->logical_volumes, name);
if (volume == NULL)
{
volume = storage_logical_volume_new (self, name);
storage_logical_volume_update (volume, self, lv_info, &needs_polling);
g_hash_table_insert (self->logical_volumes, g_strdup (name), g_object_ref (volume));
}
else
storage_logical_volume_update (volume, self, lv_info, &needs_polling);
g_hash_table_insert (new_lvs, (gchar *)name, volume);
}
g_variant_iter_free (iter);
}
g_hash_table_iter_init (&volume_iter, self->logical_volumes);
while (g_hash_table_iter_next (&volume_iter, &key, &value))
{
const gchar *name = key;
StorageLogicalVolume *volume = value;
if (!g_hash_table_contains (new_lvs, name))
{
/* Volume unpublishes itself */
g_object_run_dispose (G_OBJECT (volume));
g_hash_table_iter_remove (&volume_iter);
}
}
lvm_volume_group_set_needs_polling (LVM_VOLUME_GROUP (self), needs_polling);
/* Update physical volumes. */
g_hash_table_remove_all (self->physical_volumes);
if (g_variant_lookup (info, "pvs", "aa{sv}", &iter))
{
const gchar *name;
GVariant *pv_info;
while (g_variant_iter_next (iter, "@a{sv}", &pv_info))
{
if (g_variant_lookup (pv_info, "device", "&s", &name))
g_hash_table_insert (self->physical_volumes, g_strdup (name), pv_info);
else
g_variant_unref (pv_info);
}
}
/* Make sure above is published before updating blocks to point at volume group */
update_all_blocks (self);
if (data->done)
data->done (self, data->done_user_data);
g_hash_table_destroy (new_lvs);
g_object_unref (self);
g_free (data);
}
