コード例 #1
0
static gboolean
handle_create_thin_pool_volume (CockpitStorageVolumeGroup *object,
                                GDBusMethodInvocation *invocation,
                                const gchar *arg_name,
                                guint64 arg_size)
{
  StorageVolumeGroup *group = STORAGE_VOLUME_GROUP(object);
  GError *error = NULL;
  gs_free gchar *result = NULL;

  if (!auth_check_sender_role (invocation, COCKPIT_ROLE_STORAGE_ADMIN))
    return TRUE;

  if (!lvm_volume_group_call_create_thin_pool_volume_sync (group->lvm_volume_group,
                                                           arg_name,
                                                           arg_size,
                                                           null_asv (),
                                                           &result,
                                                           NULL,
                                                           &error))
    {
      g_dbus_error_strip_remote_error (error);
      g_dbus_method_invocation_return_error (invocation,
                                             COCKPIT_ERROR,
                                             COCKPIT_ERROR_FAILED,
                                             "%s", error->message);
      g_error_free (error);
    }
  else
    cockpit_storage_volume_group_complete_create_thin_pool_volume (object, invocation);

  return TRUE;
}
コード例 #2
0
static gboolean
handle_delete (CockpitStorageVolumeGroup *object,
               GDBusMethodInvocation *invocation)
{
  StorageVolumeGroup *group = STORAGE_VOLUME_GROUP(object);
  StorageProvider *provider = storage_object_get_provider (group->object);
  GError *error = NULL;

  if (!auth_check_sender_role (invocation, COCKPIT_ROLE_STORAGE_ADMIN))
    return TRUE;

  if (!storage_cleanup_volume_group (provider,
                                     group->lvm_volume_group,
                                     &error)
      || !lvm_volume_group_call_delete_sync (group->lvm_volume_group,
                                             TRUE,
                                             null_asv (),
                                             NULL,
                                             &error))
    {
      g_dbus_error_strip_remote_error (error);
      g_dbus_method_invocation_return_error (invocation,
                                             COCKPIT_ERROR,
                                             COCKPIT_ERROR_FAILED,
                                             "%s", error->message);
      g_error_free (error);
    }
  else
    cockpit_storage_volume_group_complete_delete (object, invocation);

  return TRUE;
}
コード例 #3
0
static gboolean
handle_deactivate (CockpitStorageLogicalVolume *object,
                   GDBusMethodInvocation *invocation)
{
  StorageLogicalVolume *volume = STORAGE_LOGICAL_VOLUME(object);
  GError *error = NULL;

  if (!auth_check_sender_role (invocation, COCKPIT_ROLE_STORAGE_ADMIN))
    return TRUE;

  if (!lvm_logical_volume_call_deactivate_sync (volume->lvm_logical_volume,
                                                null_asv (),
                                                NULL,
                                                &error))
    {
      g_dbus_error_strip_remote_error (error);
      g_dbus_method_invocation_return_error (invocation,
                                             COCKPIT_ERROR,
                                             COCKPIT_ERROR_FAILED,
                                             "%s", error->message);
      g_error_free (error);
    }
  else
    cockpit_storage_logical_volume_complete_deactivate (object, invocation);

  return TRUE;
}
コード例 #4
0
static gboolean
handle_create_thin_volume (CockpitStorageVolumeGroup *object,
                           GDBusMethodInvocation *invocation,
                           const gchar *arg_name,
                           guint64 arg_size,
                           const gchar *arg_pool)
{
  StorageVolumeGroup *group = STORAGE_VOLUME_GROUP(object);
  GError *error = NULL;
  gs_free gchar *result = NULL;
  const gchar *pool_path = "/";

  if (!auth_check_sender_role (invocation, COCKPIT_ROLE_STORAGE_ADMIN))
    return TRUE;

  StorageProvider *provider = storage_object_get_provider (group->object);
  Daemon *daemon = storage_provider_get_daemon (provider);
  GDBusObjectManagerServer *object_manager_server = daemon_get_object_manager (daemon);
  GDBusObjectManager *object_manager = G_DBUS_OBJECT_MANAGER (object_manager_server);

  StorageObject *pool_object =
    STORAGE_OBJECT (g_dbus_object_manager_get_object (object_manager, arg_pool));
  LvmLogicalVolume *lvm_pool_lvol = storage_object_get_lvm_logical_volume (pool_object);

  if (lvm_pool_lvol)
    pool_path = g_dbus_proxy_get_object_path (G_DBUS_PROXY (lvm_pool_lvol));

  if (!lvm_volume_group_call_create_thin_volume_sync (group->lvm_volume_group,
                                                      arg_name,
                                                      arg_size,
                                                      pool_path,
                                                      null_asv (),
                                                      &result,
                                                      NULL,
                                                      &error))
    {
      g_dbus_error_strip_remote_error (error);
      g_dbus_method_invocation_return_error (invocation,
                                             COCKPIT_ERROR,
                                             COCKPIT_ERROR_FAILED,
                                             "%s", error->message);
      g_error_free (error);
    }
  else
    cockpit_storage_volume_group_complete_create_thin_pool_volume (object, invocation);

  return TRUE;
}
コード例 #5
0
static gboolean
handle_empty_device (CockpitStorageVolumeGroup *object,
                     GDBusMethodInvocation *invocation,
                     const gchar *arg_objpath)
{
  StorageVolumeGroup *group = STORAGE_VOLUME_GROUP(object);
  GError *error = NULL;
  const gchar *block_path = "/";

  if (!auth_check_sender_role (invocation, COCKPIT_ROLE_STORAGE_ADMIN))
    return TRUE;

  StorageProvider *provider = storage_object_get_provider (group->object);
  Daemon *daemon = storage_provider_get_daemon (provider);
  GDBusObjectManagerServer *object_manager_server = daemon_get_object_manager (daemon);
  GDBusObjectManager *object_manager = G_DBUS_OBJECT_MANAGER (object_manager_server);

  StorageObject *block_object =
    STORAGE_OBJECT (g_dbus_object_manager_get_object (object_manager, arg_objpath));
  UDisksBlock *udisks_block = storage_object_get_udisks_block (block_object);

  if (udisks_block)
    block_path = g_dbus_proxy_get_object_path (G_DBUS_PROXY (udisks_block));

  g_dbus_proxy_set_default_timeout (G_DBUS_PROXY (group->lvm_volume_group),
                                    G_MAXINT);

  if (!lvm_volume_group_call_empty_device_sync (group->lvm_volume_group,
                                                block_path,
                                                null_asv (),
                                                NULL,
                                                &error))
    {
      g_dbus_error_strip_remote_error (error);
      g_dbus_method_invocation_return_error (invocation,
                                             COCKPIT_ERROR,
                                             COCKPIT_ERROR_FAILED,
                                             "%s", error->message);
      g_error_free (error);
    }
  else
    cockpit_storage_volume_group_complete_empty_device (object, invocation);

  g_dbus_proxy_set_default_timeout (G_DBUS_PROXY (group->lvm_volume_group),
                                    -1);

  return TRUE;
}
コード例 #6
0
static gboolean
handle_volume_group_create (CockpitStorageManager *object,
                            GDBusMethodInvocation *invocation,
                            const gchar *arg_name,
                            const gchar *const *arg_blocks)
{
  StorageManager *storage_manager = STORAGE_MANAGER(object);
  GDBusObjectManagerServer *object_manager_server = daemon_get_object_manager (storage_manager->daemon);
  GDBusObjectManager *object_manager = G_DBUS_OBJECT_MANAGER (object_manager_server);

  if (!auth_check_sender_role (invocation, COCKPIT_ROLE_STORAGE_ADMIN))
    return TRUE;

  GError *error = NULL;

  int n_blocks = 0;
  for (int i = 0; arg_blocks[i]; i++)
    n_blocks += 1;

  const gchar *udisks_blocks[n_blocks + 1];

  for (int i = 0; arg_blocks[i]; i++)
    {
      StorageObject *stobj =
        STORAGE_OBJECT (g_dbus_object_manager_get_object (object_manager, arg_blocks[i]));
      UDisksBlock *block = storage_object_get_udisks_block (stobj);
      if (block)
        udisks_blocks[i] = g_dbus_proxy_get_object_path (G_DBUS_PROXY(block));
      else
        udisks_blocks[i] = "XXX";
    }

  udisks_blocks[n_blocks] = NULL;

  if (storage_manager->lvm_manager == NULL)
    {
      g_dbus_method_invocation_return_error (invocation,
                                             COCKPIT_ERROR,
                                             COCKPIT_ERROR_FAILED,
                                             "storaged daemon is not running");
      return TRUE;
    }

  if (!lvm_manager_call_volume_group_create_sync (storage_manager->lvm_manager,
                                                  arg_name,
                                                  udisks_blocks,
                                                  null_asv (),
                                                  NULL,
                                                  NULL,
                                                  &error))
    {
      g_dbus_error_strip_remote_error (error);
      g_dbus_method_invocation_return_error (invocation,
                                             COCKPIT_ERROR,
                                             COCKPIT_ERROR_FAILED,
                                             "%s", error->message);
      g_error_free (error);
      return TRUE;
    }

  cockpit_storage_manager_complete_volume_group_create (object, invocation);
  return TRUE;
}
コード例 #7
0
static gboolean
handle_mdraid_create (CockpitStorageManager *object,
                      GDBusMethodInvocation *invocation,
                      const gchar *const *arg_blocks,
                      const gchar *arg_level,
                      const gchar *arg_name,
                      guint64 arg_chunk)
{
  StorageManager *storage_manager = STORAGE_MANAGER(object);
  GDBusObjectManagerServer *object_manager_server = daemon_get_object_manager (storage_manager->daemon);
  GDBusObjectManager *object_manager = G_DBUS_OBJECT_MANAGER (object_manager_server);

  if (!auth_check_sender_role (invocation, COCKPIT_ROLE_STORAGE_ADMIN))
    return TRUE;

  GError *error = NULL;

  int n_blocks = 0;
  for (int i = 0; arg_blocks[i]; i++)
    n_blocks += 1;

  const gchar *udisks_blocks[n_blocks + 1];

  for (int i = 0; arg_blocks[i]; i++)
    {
      StorageObject *stobj =
        STORAGE_OBJECT (g_dbus_object_manager_get_object (object_manager, arg_blocks[i]));
      UDisksBlock *block = storage_object_get_udisks_block (stobj);
      if (block)
        udisks_blocks[i] = g_dbus_proxy_get_object_path (G_DBUS_PROXY(block));
      else
        udisks_blocks[i] = "XXX";
    }

  udisks_blocks[n_blocks] = NULL;

  UDisksManager *manager = udisks_client_get_manager (storage_manager->udisks);
  if (manager == NULL)
    {
      g_dbus_method_invocation_return_error (invocation,
                                             COCKPIT_ERROR,
                                             COCKPIT_ERROR_FAILED,
                                             "UDisks daemon is not running");
      return TRUE;
    }

  GVariantBuilder options;
  g_variant_builder_init (&options, G_VARIANT_TYPE("a{sv}"));

  if (!udisks_manager_call_mdraid_create_sync (manager,
                                               udisks_blocks,
                                               arg_level,
                                               arg_name,
                                               arg_chunk,
                                               null_asv (),
                                               NULL,
                                               NULL,
                                               &error))
    {
      g_dbus_error_strip_remote_error (error);
      g_dbus_method_invocation_return_error (invocation,
                                             COCKPIT_ERROR,
                                             COCKPIT_ERROR_FAILED,
                                             "%s", error->message);
      g_error_free (error);
      return TRUE;
    }

  cockpit_storage_manager_complete_mdraid_create (object, invocation);
  return TRUE;
}