Re: [spice-gtk v4 20/24] file-xfer: move to spice-file-transfer-task.c

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



On Thu, 2016-06-23 at 19:37 +0200, Victor Toso wrote:
> This patch moves:
> * GObject boilerplate
> * External API related to SpiceFileTransferTask
> * Internal API needed by channel-main
> * Helpers that belong to this object
> ---
>  src/Makefile.am                     |   2 +
>  src/channel-main.c                  | 696 +----------------------------------
>  src/spice-file-transfer-task-priv.h |  59 +++
>  src/spice-file-transfer-task.c      | 713
> ++++++++++++++++++++++++++++++++++++
>  4 files changed, 776 insertions(+), 694 deletions(-)
>  create mode 100644 src/spice-file-transfer-task-priv.h
>  create mode 100644 src/spice-file-transfer-task.c
> 
> diff --git a/src/Makefile.am b/src/Makefile.am
> index 6fb8507..779d655 100644
> --- a/src/Makefile.am
> +++ b/src/Makefile.am
> @@ -233,6 +233,8 @@ libspice_client_glib_2_0_la_SOURCES =			
> \
>  	spice-channel.c					\
>  	spice-channel-cache.h				\
>  	spice-channel-priv.h				\
> +        spice-file-transfer-task.c                      \
> +        spice-file-transfer-task-priv.h                 \
>  	coroutine.h					\
>  	gio-coroutine.c					\
>  	gio-coroutine.h					\

Looks like there's some alignment issues here.


> diff --git a/src/channel-main.c b/src/channel-main.c
> index 190a366..a0b2748 100644
> --- a/src/channel-main.c
> +++ b/src/channel-main.c
> @@ -29,7 +29,7 @@
>  #include "spice-channel-priv.h"
>  #include "spice-session-priv.h"
>  #include "spice-audio-priv.h"
> -#include "spice-file-transfer-task.h"
> +#include "spice-file-transfer-task-priv.h"
>  
>  /**
>   * SECTION:channel-main
> @@ -54,94 +54,6 @@
>  
>  typedef struct spice_migrate spice_migrate;
>  
> -static guint32 spice_file_transfer_task_get_id(SpiceFileTransferTask *self);
> -static SpiceMainChannel
> *spice_file_transfer_task_get_channel(SpiceFileTransferTask *self);
> -static GCancellable
> *spice_file_transfer_task_get_cancellable(SpiceFileTransferTask *self);
> -static GHashTable *spice_file_transfer_task_create_tasks(GFile **files,
> -                                                         SpiceMainChannel
> *channel,
> -                                                         GFileCopyFlags
> flags,
> -                                                         GCancellable
> *cancellable);
> -static void spice_file_transfer_task_init_task_async(SpiceFileTransferTask
> *self,
> -                                                     GAsyncReadyCallback
> callback,
> -                                                     gpointer userdata);
> -static GFileInfo
> *spice_file_transfer_task_init_task_finish(SpiceFileTransferTask *xfer_task,
> -                                                            GAsyncResult
> *result,
> -                                                            GError **error);
> -static void spice_file_transfer_task_read_async(SpiceFileTransferTask *self,
> -                                                GAsyncReadyCallback callback,
> -                                                gpointer userdata);
> -static gssize spice_file_transfer_task_read_finish(SpiceFileTransferTask
> *self,
> -                                                   GAsyncResult *result,
> -                                                   char **buffer,
> -                                                   GError **error);
> -static guint64 spice_file_transfer_task_get_file_size(SpiceFileTransferTask
> *self);
> -static guint64 spice_file_transfer_task_get_bytes_read(SpiceFileTransferTask
> *self);
> -static void spice_file_transfer_task_debug_info(SpiceFileTransferTask *self);
> -
> -/**
> - * SECTION:file-transfer-task
> - * @short_description: Monitoring file transfers
> - * @title: File Transfer Task
> - * @section_id:
> - * @see_also: #SpiceMainChannel
> - * @stability: Stable
> - * @include: spice-client.h
> - *
> - * SpiceFileTransferTask is an object that represents a particular file
> - * transfer between the client and the guest. The properties and signals of
> the
> - * object can be used to monitor the status and result of the transfer. The
> - * Main Channel's #SpiceMainChannel::new-file-transfer signal will be emitted
> - * whenever a new file transfer task is initiated.
> - *
> - * Since: 0.31
> - */
> -
> -struct _SpiceFileTransferTask
> -{
> -    GObject parent;
> -
> -    uint32_t                       id;
> -    gboolean                       pending;
> -    GFile                          *file;
> -    SpiceMainChannel               *channel;
> -    GFileInputStream               *file_stream;
> -    GFileCopyFlags                 flags;
> -    GCancellable                   *cancellable;
> -    GAsyncReadyCallback            callback;
> -    gpointer                       user_data;
> -    char                           *buffer;
> -    uint64_t                       read_bytes;
> -    GFileInfo                      *file_info;
> -    uint64_t                       file_size;
> -    gint64                         start_time;
> -    gint64                         last_update;
> -    GError                         *error;
> -};
> -
> -struct _SpiceFileTransferTaskClass
> -{
> -    GObjectClass parent_class;
> -};
> -
> -G_DEFINE_TYPE(SpiceFileTransferTask, spice_file_transfer_task, G_TYPE_OBJECT)
> -
> -#define FILE_XFER_CHUNK_SIZE (VD_AGENT_MAX_DATA_SIZE * 32)
> -
> -enum {
> -    PROP_TASK_ID = 1,
> -    PROP_TASK_CHANNEL,
> -    PROP_TASK_CANCELLABLE,
> -    PROP_TASK_FILE,
> -    PROP_TASK_PROGRESS,
> -};
> -
> -enum {
> -    SIGNAL_FINISHED,
> -    LAST_TASK_SIGNAL
> -};
> -
> -static guint task_signals[LAST_TASK_SIGNAL];
> -
>  typedef enum {
>      DISPLAY_UNDEFINED,
>      DISPLAY_DISABLED,
> @@ -267,7 +179,6 @@ static void migrate_channel_event_cb(SpiceChannel
> *channel, SpiceChannelEvent ev
>                                       gpointer data);
>  static gboolean main_migrate_handshake_done(gpointer data);
>  static void spice_main_channel_send_migration_handshake(SpiceChannel
> *channel);
> -static void spice_file_transfer_task_completed(SpiceFileTransferTask *self,
> GError *error);
>  static void file_xfer_flushed(SpiceMainChannel *channel, gboolean success);
>  static void file_xfer_read_async_cb(GObject *source_object,
>                                      GAsyncResult *res,
> @@ -1840,44 +1751,6 @@ static void main_handle_agent_disconnected(SpiceChannel
> *channel, SpiceMsgIn *in
>      agent_stopped(SPICE_MAIN_CHANNEL(channel));
>  }
>  
> -/* main context */
> -static void spice_file_transfer_task_close_stream_cb(GObject      *object,
> -                                                     GAsyncResult *close_res,
> -                                                     gpointer      user_data)
> -{
> -    SpiceFileTransferTask *self;
> -    GError *error = NULL;
> -
> -    self = user_data;
> -
> -    if (object) {
> -        GInputStream *stream = G_INPUT_STREAM(object);
> -        g_input_stream_close_finish(stream, close_res, &error);
> -        if (error) {
> -            /* This error dont need to report to user, just print a log */
> -            SPICE_DEBUG("close file error: %s", error->message);
> -            g_clear_error(&error);
> -        }
> -    }
> -
> -    if (self->error == NULL && spice_util_get_debug()) {
> -        gint64 now = g_get_monotonic_time();
> -        gchar *basename = g_file_get_basename(self->file);
> -        double seconds = (double) (now - self->start_time) /
> G_TIME_SPAN_SECOND;
> -        gchar *file_size_str = g_format_size(self->file_size);
> -        gchar *transfer_speed_str = g_format_size(self->file_size / seconds);
> -
> -        g_warn_if_fail(self->read_bytes == self->file_size);
> -        SPICE_DEBUG("transferred file %s of %s size in %.1f seconds (%s/s)",
> -                    basename, file_size_str, seconds, transfer_speed_str);
> -
> -        g_free(basename);
> -        g_free(file_size_str);
> -        g_free(transfer_speed_str);
> -    }
> -    g_object_unref(self);
> -}
> -
>  static void file_xfer_data_flushed_cb(GObject *source_object,
>                                        GAsyncResult *res,
>                                        gpointer user_data)
> @@ -1990,6 +1863,7 @@ static void file_xfer_handle_status(SpiceMainChannel
> *channel,
>      spice_file_transfer_task_completed(xfer_task, error);
>  }
>  
> +
>  /* any context: the message is not flushed immediately,
>     you can wakeup() the channel coroutine or send_msg_queue() */
>  static void agent_max_clipboard(SpiceMainChannel *self)
> @@ -2933,38 +2807,6 @@ void spice_main_set_display_enabled(SpiceMainChannel
> *channel, int id, gboolean
>      spice_main_update_display_enabled(channel, id, enabled, TRUE);
>  }
>  
> -static void spice_file_transfer_task_completed(SpiceFileTransferTask *self,
> -                                               GError *error)
> -{
> -    /* In case of multiple errors we only report the first error */
> -    if (self->error)
> -        g_clear_error(&error);
> -    if (error) {
> -        gchar *path = g_file_get_path(self->file);
> -        SPICE_DEBUG("File %s xfer failed: %s",
> -                    path, error->message);
> -        g_free(path);
> -        self->error = error;
> -    }
> -
> -    if (self->pending)
> -        return;
> -
> -    if (!self->file_stream) {
> -        spice_file_transfer_task_close_stream_cb(NULL, NULL, self);
> -        goto signal;
> -    }
> -
> -    g_input_stream_close_async(G_INPUT_STREAM(self->file_stream),
> -                               G_PRIORITY_DEFAULT,
> -                               self->cancellable,
> -                               spice_file_transfer_task_close_stream_cb,
> -                               self);
> -    self->pending = TRUE;
> -signal:
> -    g_signal_emit(self, task_signals[SIGNAL_FINISHED], 0, self->error);
> -}
> -
>  
>  static void file_xfer_init_task_async_cb(GObject *obj, GAsyncResult *res,
> gpointer data)
>  {
> @@ -3146,10 +2988,6 @@ static void
> file_transfer_operation_send_progress(SpiceFileTransferTask *xfer_ta
>                                     xfer_op->progress_callback_data);
>  }
>  
> -static SpiceFileTransferTask *spice_file_transfer_task_new(SpiceMainChannel
> *channel,
> -                                                           GFile *file,
> -                                                           GCancellable
> *cancellable);
> -
>  /**
>   * spice_main_file_copy_async:
>   * @channel: a #SpiceMainChannel
> @@ -3269,533 +3107,3 @@ gboolean spice_main_file_copy_finish(SpiceMainChannel
> *channel,
>  
>      return g_task_propagate_boolean(task, error);
>  }
> -
> -static guint32 spice_file_transfer_task_get_id(SpiceFileTransferTask *self)
> -{
> -    g_return_val_if_fail(self != NULL, 0);
> -    return self->id;
> -}
> -
> -static SpiceMainChannel
> *spice_file_transfer_task_get_channel(SpiceFileTransferTask *self)
> -{
> -    g_return_val_if_fail(self != NULL, NULL);
> -    return self->channel;
> -}
> -
> -static GCancellable
> *spice_file_transfer_task_get_cancellable(SpiceFileTransferTask *self)
> -{
> -    g_return_val_if_fail(self != NULL, NULL);
> -    return self->cancellable;
> -}
> -
> -static guint64 spice_file_transfer_task_get_file_size(SpiceFileTransferTask
> *self)
> -{
> -    g_return_val_if_fail(self != NULL, 0);
> -    return self->file_size;
> -}
> -
> -static guint64 spice_file_transfer_task_get_bytes_read(SpiceFileTransferTask
> *self)
> -{
> -    g_return_val_if_fail(self != NULL, 0);
> -    return self->read_bytes;
> -}
> -
> -/* Helper function which only creates a SpiceFileTransferTask per GFile
> - * in @files and returns a HashTable mapping task-id to the task itself
> - * Note that the HashTable does not free its values uppon destruction:
> - * The reference created here should be freed by
> - * spice_file_transfer_task_completed */
> -static GHashTable *spice_file_transfer_task_create_tasks(GFile **files,
> -                                                         SpiceMainChannel
> *channel,
> -                                                         GFileCopyFlags
> flags,
> -                                                         GCancellable
> *cancellable)
> -{
> -    GHashTable *xfer_ht;
> -    gint i;
> -
> -    g_return_val_if_fail(files != NULL && files[0] != NULL, NULL);
> -
> -    xfer_ht = g_hash_table_new(g_direct_hash, g_direct_equal);
> -    for (i = 0; files[i] != NULL && !g_cancellable_is_cancelled(cancellable);
> i++) {
> -        SpiceFileTransferTask *xfer_task;
> -        guint32 task_id;
> -        GCancellable *task_cancellable = cancellable;
> -
> -        /* if a cancellable object was not provided for the overall
> operation,
> -         * create a separate object for each file so that they can be
> cancelled
> -         * separately  */
> -        if (!task_cancellable)
> -            task_cancellable = g_cancellable_new();
> -
> -        xfer_task = spice_file_transfer_task_new(channel, files[i],
> task_cancellable);
> -        xfer_task->flags = flags;
> -
> -        task_id = spice_file_transfer_task_get_id(xfer_task);
> -        g_hash_table_insert(xfer_ht, GUINT_TO_POINTER(task_id), xfer_task);
> -
> -        /* if we created a per-task cancellable above, free it */
> -        if (!cancellable)
> -            g_object_unref(task_cancellable);
> -    }
> -    return xfer_ht;
> -}
> -
> -static void spice_file_transfer_task_query_info_cb(GObject *obj,
> -                                                   GAsyncResult *res,
> -                                                   gpointer user_data)
> -{
> -    SpiceFileTransferTask *self;
> -    GFileInfo *info;
> -    GTask *task;
> -    GError *error = NULL;
> -
> -    task = G_TASK(user_data);
> -    self = g_task_get_source_object(task);
> -
> -    g_return_if_fail(self->pending == TRUE);
> -    self->pending = FALSE;
> -
> -    info = g_file_query_info_finish(G_FILE(obj), res, &error);
> -    if (error || self->error) {
> -        error = (error == NULL) ? self->error : error;
> -        g_task_return_error(task, error);
> -        return;
> -    }
> -
> -    self->file_info = info;
> -    self->file_size =
> -        g_file_info_get_attribute_uint64(info,
> G_FILE_ATTRIBUTE_STANDARD_SIZE);
> -
> -    /* SpiceFileTransferTask's init is done, handshake for file-trasfer will
> -     * start soon. First "progress" can be emitted ~ 0% */
> -    g_object_notify(G_OBJECT(self), "progress");
> -
> -    g_task_return_boolean(task, TRUE);
> -}
> -
> -static void spice_file_transfer_task_read_file_cb(GObject *obj,
> -                                                  GAsyncResult *res,
> -                                                  gpointer user_data)
> -{
> -    SpiceFileTransferTask *self;
> -    GTask *task;
> -    GError *error = NULL;
> -
> -    task = G_TASK(user_data);
> -    self = g_task_get_source_object(task);
> -
> -    g_return_if_fail(self->pending == TRUE);
> -
> -    self->file_stream = g_file_read_finish(G_FILE(obj), res, &error);
> -    if (error || self->error) {
> -        self->pending = FALSE;
> -        error = (error == NULL) ? self->error : error;
> -        g_task_return_error(task, error);
> -        return;
> -    }
> -
> -    g_file_query_info_async(self->file,
> -                            "standard::*",
> -                            G_FILE_QUERY_INFO_NONE,
> -                            G_PRIORITY_DEFAULT,
> -                            self->cancellable,
> -                            spice_file_transfer_task_query_info_cb,
> -                            task);
> -}
> -
> -static void spice_file_transfer_task_init_task_async(SpiceFileTransferTask
> *self,
> -                                                     GAsyncReadyCallback
> callback,
> -                                                     gpointer userdata)
> -{
> -    GTask *task;
> -
> -    g_return_if_fail(self != NULL);
> -    g_return_if_fail(self->pending == FALSE);
> -
> -    task = g_task_new(self, self->cancellable, callback, userdata);
> -
> -    self->pending = TRUE;
> -    g_file_read_async(self->file,
> -                      G_PRIORITY_DEFAULT,
> -                      self->cancellable,
> -                      spice_file_transfer_task_read_file_cb,
> -                      task);
> -}
> -
> -static GFileInfo
> *spice_file_transfer_task_init_task_finish(SpiceFileTransferTask *self,
> -                                                            GAsyncResult
> *result,
> -                                                            GError **error)
> -{
> -    GTask *task = G_TASK(result);
> -
> -    g_return_val_if_fail(self != NULL, NULL);
> -
> -    if (g_task_propagate_boolean(task, error))
> -        return self->file_info;
> -
> -    return NULL;
> -}
> -
> -static void spice_file_transfer_task_read_stream_cb(GObject *source_object,
> -                                                    GAsyncResult *res,
> -                                                    gpointer userdata)
> -{
> -    SpiceFileTransferTask *self;
> -    GTask *task;
> -    gssize nbytes;
> -    GError *error = NULL;
> -
> -    task = G_TASK(userdata);
> -    self = g_task_get_source_object(task);
> -
> -    g_return_if_fail(self->pending == TRUE);
> -    self->pending = FALSE;
> -
> -    nbytes = g_input_stream_read_finish(G_INPUT_STREAM(self->file_stream),
> res, &error);
> -    if (error || self->error) {
> -        error = (error == NULL) ? self->error : error;
> -        g_task_return_error(task, error);
> -        return;
> -    }
> -
> -    /* The progress here means the amount of data we have _read_ and not what
> -     * was actually sent to the agent. On the next "progress", the previous
> data
> -     * read was sent. This means that when user see 100%, we are sending the
> -     * last chunk to the guest */
> -    self->read_bytes += nbytes;
> -    g_object_notify(G_OBJECT(self), "progress");
> -
> -    g_task_return_int(task, nbytes);
> -}
> -
> -/* Any context */
> -static void spice_file_transfer_task_read_async(SpiceFileTransferTask *self,
> -                                                GAsyncReadyCallback callback,
> -                                                gpointer userdata)
> -{
> -    GTask *task;
> -
> -    g_return_if_fail(self != NULL);
> -    if (self->pending) {
> -        g_task_report_new_error(self, callback, userdata,
> -                                spice_file_transfer_task_read_async,
> -                                SPICE_CLIENT_ERROR,
> -                                SPICE_CLIENT_ERROR_FAILED,
> -                                "Cannot read data in pending state");
> -        return;
> -    }
> -
> -    task = g_task_new(self, self->cancellable, callback, userdata);
> -
> -    if (self->read_bytes == self->file_size) {
> -        /* channel-main might can request data after reading the whole file
> as
> -         * it expects EOF. Let's return immediately its request as we don't
> want
> -         * to reach a state where agent says file-transfer SUCCEED but we are
> in
> -         * a PENDING state in SpiceFileTransferTask due reading in idle */
> -        g_task_return_int(task, 0);
> -        return;
> -    }
> -
> -    self->pending = TRUE;
> -    g_input_stream_read_async(G_INPUT_STREAM(self->file_stream),
> -                              self->buffer,
> -                              FILE_XFER_CHUNK_SIZE,
> -                              G_PRIORITY_DEFAULT,
> -                              self->cancellable,
> -                              spice_file_transfer_task_read_stream_cb,
> -                              task);
> -}
> -
> -static gssize spice_file_transfer_task_read_finish(SpiceFileTransferTask
> *self,
> -                                                   GAsyncResult *result,
> -                                                   char **buffer,
> -                                                   GError **error)
> -{
> -    gssize nbytes;
> -    GTask *task = G_TASK(result);
> -
> -    g_return_val_if_fail(self != NULL, -1);
> -
> -    nbytes = g_task_propagate_int(task, error);
> -    if (nbytes >= 0 && buffer != NULL)
> -        *buffer = self->buffer;
> -
> -    return nbytes;
> -}
> -
> -static void spice_file_transfer_task_debug_info(SpiceFileTransferTask *self)
> -{
> -    const GTimeSpan interval = 20 * G_TIME_SPAN_SECOND;
> -    gint64 now = g_get_monotonic_time();
> -
> -    if (interval < now - self->last_update) {
> -        gchar *basename = g_file_get_basename(self->file);
> -        self->last_update = now;
> -        SPICE_DEBUG("transferred %.2f%% of the file %s",
> -                    100.0 * self->read_bytes / self->file_size, basename);
> -        g_free(basename);
> -    }
> -}
> -
> -static void
> -spice_file_transfer_task_get_property(GObject *object,
> -                                      guint property_id,
> -                                      GValue *value,
> -                                      GParamSpec *pspec)
> -{
> -    SpiceFileTransferTask *self = SPICE_FILE_TRANSFER_TASK(object);
> -
> -    switch (property_id)
> -    {
> -        case PROP_TASK_ID:
> -            g_value_set_uint(value, self->id);
> -            break;
> -        case PROP_TASK_FILE:
> -            g_value_set_object(value, self->file);
> -            break;
> -        case PROP_TASK_PROGRESS:
> -            g_value_set_double(value,
> spice_file_transfer_task_get_progress(self));
> -            break;
> -        default:
> -            G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
> -    }
> -}
> -
> -static void
> -spice_file_transfer_task_set_property(GObject *object,
> -                                      guint property_id,
> -                                      const GValue *value,
> -                                      GParamSpec *pspec)
> -{
> -    SpiceFileTransferTask *self = SPICE_FILE_TRANSFER_TASK(object);
> -
> -    switch (property_id)
> -    {
> -        case PROP_TASK_ID:
> -            self->id = g_value_get_uint(value);
> -            break;
> -        case PROP_TASK_FILE:
> -            self->file = g_value_dup_object(value);
> -            break;
> -        case PROP_TASK_CHANNEL:
> -            self->channel = g_value_dup_object(value);
> -            break;
> -        case PROP_TASK_CANCELLABLE:
> -            self->cancellable = g_value_dup_object(value);
> -            break;
> -        default:
> -            G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
> -    }
> -}
> -
> -static void
> -spice_file_transfer_task_dispose(GObject *object)
> -{
> -    SpiceFileTransferTask *self = SPICE_FILE_TRANSFER_TASK(object);
> -
> -    g_clear_object(&self->file);
> -    g_clear_object(&self->file_info);
> -
> -    G_OBJECT_CLASS(spice_file_transfer_task_parent_class)->dispose(object);
> -}
> -
> -static void
> -spice_file_transfer_task_finalize(GObject *object)
> -{
> -    SpiceFileTransferTask *self = SPICE_FILE_TRANSFER_TASK(object);
> -
> -    g_free(self->buffer);
> -
> -    G_OBJECT_CLASS(spice_file_transfer_task_parent_class)->finalize(object);
> -}
> -
> -static void
> -spice_file_transfer_task_constructed(GObject *object)
> -{
> -    SpiceFileTransferTask *self = SPICE_FILE_TRANSFER_TASK(object);
> -
> -    if (spice_util_get_debug()) {
> -        gchar *basename = g_file_get_basename(self->file);
> -        self->start_time = g_get_monotonic_time();
> -        self->last_update = self->start_time;
> -
> -        SPICE_DEBUG("transfer of file %s has started", basename);
> -        g_free(basename);
> -    }
> -}
> -
> -static void
> -spice_file_transfer_task_class_init(SpiceFileTransferTaskClass *klass)
> -{
> -    GObjectClass *object_class = G_OBJECT_CLASS(klass);
> -
> -    object_class->get_property = spice_file_transfer_task_get_property;
> -    object_class->set_property = spice_file_transfer_task_set_property;
> -    object_class->finalize = spice_file_transfer_task_finalize;
> -    object_class->dispose = spice_file_transfer_task_dispose;
> -    object_class->constructed = spice_file_transfer_task_constructed;
> -
> -    /**
> -     * SpiceFileTransferTask:id:
> -     *
> -     * The ID of the file transfer task
> -     *
> -     * Since: 0.31
> -     **/
> -    g_object_class_install_property(object_class, PROP_TASK_ID,
> -                                    g_param_spec_uint("id",
> -                                                      "id",
> -                                                      "The id of the task",
> -                                                      0, G_MAXUINT, 0,
> -                                                      G_PARAM_CONSTRUCT_ONLY
> | G_PARAM_READWRITE |
> -                                                      G_PARAM_STATIC_STRINGS)
> );
> -
> -    /**
> -     * SpiceFileTransferTask:channel:
> -     *
> -     * The main channel that owns the file transfer task
> -     *
> -     * Since: 0.31
> -     **/
> -    g_object_class_install_property(object_class, PROP_TASK_CHANNEL,
> -                                    g_param_spec_object("channel",
> -                                                        "channel",
> -                                                        "The channel
> transferring the file",
> -                                                        SPICE_TYPE_MAIN_CHANN
> EL,
> -                                                        G_PARAM_CONSTRUCT_ONL
> Y | G_PARAM_READWRITE |
> -                                                        G_PARAM_STATIC_STRING
> S));
> -
> -    /**
> -     * SpiceFileTransferTask:cancellable:
> -     *
> -     * A cancellable object used to cancel the file transfer
> -     *
> -     * Since: 0.31
> -     **/
> -    g_object_class_install_property(object_class, PROP_TASK_CANCELLABLE,
> -                                    g_param_spec_object("cancellable",
> -                                                        "cancellable",
> -                                                        "The object used to
> cancel the task",
> -                                                        G_TYPE_CANCELLABLE,
> -                                                        G_PARAM_CONSTRUCT_ONL
> Y | G_PARAM_READWRITE |
> -                                                        G_PARAM_STATIC_STRING
> S));
> -
> -    /**
> -     * SpiceFileTransferTask:file:
> -     *
> -     * The file that is being transferred in this file transfer task
> -     *
> -     * Since: 0.31
> -     **/
> -    g_object_class_install_property(object_class, PROP_TASK_FILE,
> -                                    g_param_spec_object("file",
> -                                                        "File",
> -                                                        "The file being
> transferred",
> -                                                        G_TYPE_FILE,
> -                                                        G_PARAM_CONSTRUCT_ONL
> Y | G_PARAM_READWRITE |
> -                                                        G_PARAM_STATIC_STRING
> S));
> -
> -    /**
> -     * SpiceFileTransferTask:progress:
> -     *
> -     * The current state of the file transfer. This value indicates a
> -     * percentage, and ranges from 0 to 100. Listen for change notifications
> on
> -     * this property to be updated whenever the file transfer progress
> changes.
> -     *
> -     * Since: 0.31
> -     **/
> -    g_object_class_install_property(object_class, PROP_TASK_PROGRESS,
> -                                    g_param_spec_double("progress",
> -                                                        "Progress",
> -                                                        "The percentage of
> the file transferred",
> -                                                        0.0, 100.0, 0.0,
> -                                                        G_PARAM_READABLE |
> -                                                        G_PARAM_STATIC_STRING
> S));
> -
> -    /**
> -     * SpiceFileTransferTask::finished:
> -     * @task: the file transfer task that emitted the signal
> -     * @error: (transfer none): the error state of the transfer. Will be
> %NULL
> -     * if the file transfer was successful.
> -     *
> -     * The #SpiceFileTransferTask::finished signal is emitted when the file
> -     * transfer has completed transferring to the guest.
> -     *
> -     * Since: 0.31
> -     **/
> -    task_signals[SIGNAL_FINISHED] = g_signal_new("finished",
> SPICE_TYPE_FILE_TRANSFER_TASK,
> -                                            G_SIGNAL_RUN_FIRST,
> -                                            0, NULL, NULL,
> -                                            g_cclosure_marshal_VOID__BOXED,
> -                                            G_TYPE_NONE, 1,
> -                                            G_TYPE_ERROR);
> -}
> -
> -static void
> -spice_file_transfer_task_init(SpiceFileTransferTask *self)
> -{
> -    self->buffer = g_malloc0(FILE_XFER_CHUNK_SIZE);
> -}
> -
> -static SpiceFileTransferTask *
> -spice_file_transfer_task_new(SpiceMainChannel *channel, GFile *file,
> GCancellable *cancellable)
> -{
> -    static uint32_t xfer_id = 1;    /* Used to identify task id */
> -
> -    return g_object_new(SPICE_TYPE_FILE_TRANSFER_TASK,
> -                        "id", xfer_id++,
> -                        "file", file,
> -                        "channel", channel,
> -                        "cancellable", cancellable,
> -                        NULL);
> -}
> -
> -/**
> - * spice_file_transfer_task_get_progress:
> - * @self: a file transfer task
> - *
> - * Convenience function for retrieving the current progress of this file
> - * transfer task.
> - *
> - * Returns: A percentage value between 0 and 100
> - *
> - * Since: 0.31
> - **/
> -double spice_file_transfer_task_get_progress(SpiceFileTransferTask *self)
> -{
> -    if (self->file_size == 0)
> -        return 0.0;
> -
> -    return (double)self->read_bytes / self->file_size;
> -}
> -
> -/**
> - * spice_file_transfer_task_cancel:
> - * @self: a file transfer task
> - *
> - * Cancels the file transfer task. Note that depending on how the file
> transfer
> - * was initiated, multiple file transfer tasks may share a single
> - * #SpiceFileTransferTask::cancellable object, so canceling one task may
> result
> - * in the cancellation of other tasks.
> - *
> - * Since: 0.31
> - **/
> -void spice_file_transfer_task_cancel(SpiceFileTransferTask *self)
> -{
> -    g_cancellable_cancel(self->cancellable);
> -}
> -
> -/**
> - * spice_file_transfer_task_get_filename:
> - * @self: a file transfer task
> - *
> - * Gets the name of the file being transferred in this task
> - *
> - * Returns: (transfer none): The basename of the file
> - *
> - * Since: 0.31
> - **/
> -char* spice_file_transfer_task_get_filename(SpiceFileTransferTask *self)
> -{
> -    return g_file_get_basename(self->file);
> -}
> diff --git a/src/spice-file-transfer-task-priv.h b/src/spice-file-transfer-
> task-priv.h
> new file mode 100644
> index 0000000..df3ea93
> --- /dev/null
> +++ b/src/spice-file-transfer-task-priv.h
> @@ -0,0 +1,59 @@
> +/*
> +   Copyright (C) 2016 Red Hat, Inc.
> +
> +   This library is free software; you can redistribute it and/or
> +   modify it under the terms of the GNU Lesser General Public
> +   License as published by the Free Software Foundation; either
> +   version 2.1 of the License, or (at your option) any later version.
> +
> +   This library 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
> +   Lesser General Public License for more details.
> +
> +   You should have received a copy of the GNU Lesser General Public
> +   License along with this library; if not, see <http://www.gnu.org/licenses/
> >.
> +*/
> +
> +#ifndef __SPICE_FILE_TRANSFER_TASK_PRIV_H__
> +#define __SPICE_FILE_TRANSFER_TASK_PRIV_H__
> +
> +#include "config.h"
> +
> +#include <spice/vd_agent.h>
> +
> +#include "spice-client.h"
> +#include "channel-main.h"
> +#include "spice-file-transfer-task.h"
> +#include "spice-channel-priv.h"
> +
> +G_BEGIN_DECLS
> +
> +void spice_file_transfer_task_completed(SpiceFileTransferTask *self, GError
> *error);
> +guint32 spice_file_transfer_task_get_id(SpiceFileTransferTask *self);
> +SpiceMainChannel *spice_file_transfer_task_get_channel(SpiceFileTransferTask
> *self);
> +GCancellable *spice_file_transfer_task_get_cancellable(SpiceFileTransferTask
> *self);
> +GHashTable *spice_file_transfer_task_create_tasks(GFile **files,
> +                                                  SpiceMainChannel *channel,
> +                                                  GFileCopyFlags flags,
> +                                                  GCancellable *cancellable);
> +void spice_file_transfer_task_init_task_async(SpiceFileTransferTask *self,
> +                                              GAsyncReadyCallback callback,
> +                                              gpointer userdata);
> +GFileInfo *spice_file_transfer_task_init_task_finish(SpiceFileTransferTask
> *xfer_task,
> +                                                     GAsyncResult *result,
> +                                                     GError **error);
> +void spice_file_transfer_task_read_async(SpiceFileTransferTask *self,
> +                                         GAsyncReadyCallback callback,
> +                                         gpointer userdata);
> +gssize spice_file_transfer_task_read_finish(SpiceFileTransferTask *self,
> +                                            GAsyncResult *result,
> +                                            char **buffer,
> +                                            GError **error);
> +guint64 spice_file_transfer_task_get_file_size(SpiceFileTransferTask *self);
> +guint64 spice_file_transfer_task_get_bytes_read(SpiceFileTransferTask *self);
> +void spice_file_transfer_task_debug_info(SpiceFileTransferTask *self);
> +
> +G_END_DECLS
> +
> +#endif /* __SPICE_FILE_TRANSFER_TASK_PRIV_H__ */
> diff --git a/src/spice-file-transfer-task.c b/src/spice-file-transfer-task.c
> new file mode 100644
> index 0000000..8bfb1ae
> --- /dev/null
> +++ b/src/spice-file-transfer-task.c
> @@ -0,0 +1,713 @@
> +/*
> +   Copyright (C) 2016 Red Hat, Inc.
> +
> +   This library is free software; you can redistribute it and/or
> +   modify it under the terms of the GNU Lesser General Public
> +   License as published by the Free Software Foundation; either
> +   version 2.1 of the License, or (at your option) any later version.
> +
> +   This library 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
> +   Lesser General Public License for more details.
> +
> +   You should have received a copy of the GNU Lesser General Public
> +   License along with this library; if not, see <http://www.gnu.org/licenses/
> >.
> +*/
> +
> +#include "config.h"
> +
> +#include "spice-file-transfer-task-priv.h"
> +
> +/**
> + * SECTION:file-transfer-task
> + * @short_description: Monitoring file transfers
> + * @title: File Transfer Task
> + * @section_id:
> + * @see_also: #SpiceMainChannel
> + * @stability: Stable
> + * @include: spice-client.h
> + *
> + * SpiceFileTransferTask is an object that represents a particular file
> + * transfer between the client and the guest. The properties and signals of
> the
> + * object can be used to monitor the status and result of the transfer. The
> + * Main Channel's #SpiceMainChannel::new-file-transfer signal will be emitted
> + * whenever a new file transfer task is initiated.
> + *
> + * Since: 0.31
> + */
> +
> +struct _SpiceFileTransferTask
> +{
> +    GObject parent;
> +
> +    uint32_t                       id;
> +    gboolean                       pending;
> +    GFile                          *file;
> +    SpiceMainChannel               *channel;
> +    GFileInputStream               *file_stream;
> +    GFileCopyFlags                 flags;
> +    GCancellable                   *cancellable;
> +    GAsyncReadyCallback            callback;
> +    gpointer                       user_data;
> +    char                           *buffer;
> +    uint64_t                       read_bytes;
> +    GFileInfo                      *file_info;
> +    uint64_t                       file_size;
> +    gint64                         start_time;
> +    gint64                         last_update;
> +    GError                         *error;
> +};
> +
> +struct _SpiceFileTransferTaskClass
> +{
> +    GObjectClass parent_class;
> +};
> +
> +G_DEFINE_TYPE(SpiceFileTransferTask, spice_file_transfer_task, G_TYPE_OBJECT)
> +
> +#define FILE_XFER_CHUNK_SIZE (VD_AGENT_MAX_DATA_SIZE * 32)
> +
> +enum {
> +    PROP_TASK_ID = 1,
> +    PROP_TASK_CHANNEL,
> +    PROP_TASK_CANCELLABLE,
> +    PROP_TASK_FILE,
> +    PROP_TASK_PROGRESS,
> +};
> +
> +enum {
> +    SIGNAL_FINISHED,
> +    LAST_TASK_SIGNAL
> +};
> +
> +static guint task_signals[LAST_TASK_SIGNAL];
> +
> +/****************************************************************************
> ***
> + * Helpers
> +
> ******************************************************************************
> /
> +
> +static SpiceFileTransferTask *
> +spice_file_transfer_task_new(SpiceMainChannel *channel, GFile *file,
> GCancellable *cancellable)
> +{
> +    static uint32_t xfer_id = 1;    /* Used to identify task id */
> +
> +    return g_object_new(SPICE_TYPE_FILE_TRANSFER_TASK,
> +                        "id", xfer_id++,
> +                        "file", file,
> +                        "channel", channel,
> +                        "cancellable", cancellable,
> +                        NULL);
> +}
> +
> +static void spice_file_transfer_task_query_info_cb(GObject *obj,
> +                                                   GAsyncResult *res,
> +                                                   gpointer user_data)
> +{
> +    SpiceFileTransferTask *self;
> +    GFileInfo *info;
> +    GTask *task;
> +    GError *error = NULL;
> +
> +    task = G_TASK(user_data);
> +    self = g_task_get_source_object(task);
> +
> +    g_return_if_fail(self->pending == TRUE);
> +    self->pending = FALSE;
> +
> +    info = g_file_query_info_finish(G_FILE(obj), res, &error);
> +    if (error || self->error) {
> +        error = (error == NULL) ? self->error : error;
> +        g_task_return_error(task, error);
> +        return;
> +    }
> +
> +    self->file_info = info;
> +    self->file_size =
> +        g_file_info_get_attribute_uint64(info,
> G_FILE_ATTRIBUTE_STANDARD_SIZE);
> +
> +    /* SpiceFileTransferTask's init is done, handshake for file-trasfer will
> +     * start soon. First "progress" can be emitted ~ 0% */
> +    g_object_notify(G_OBJECT(self), "progress");
> +
> +    g_task_return_boolean(task, TRUE);
> +}
> +
> +static void spice_file_transfer_task_read_file_cb(GObject *obj,
> +                                                  GAsyncResult *res,
> +                                                  gpointer user_data)
> +{
> +    SpiceFileTransferTask *self;
> +    GTask *task;
> +    GError *error = NULL;
> +
> +    task = G_TASK(user_data);
> +    self = g_task_get_source_object(task);
> +
> +    g_return_if_fail(self->pending == TRUE);
> +
> +    self->file_stream = g_file_read_finish(G_FILE(obj), res, &error);
> +    if (error || self->error) {
> +        self->pending = FALSE;
> +        error = (error == NULL) ? self->error : error;
> +        g_task_return_error(task, error);
> +        return;
> +    }
> +
> +    g_file_query_info_async(self->file,
> +                            "standard::*",
> +                            G_FILE_QUERY_INFO_NONE,
> +                            G_PRIORITY_DEFAULT,
> +                            self->cancellable,
> +                            spice_file_transfer_task_query_info_cb,
> +                            task);
> +}
> +
> +static void spice_file_transfer_task_read_stream_cb(GObject *source_object,
> +                                                    GAsyncResult *res,
> +                                                    gpointer userdata)
> +{
> +    SpiceFileTransferTask *self;
> +    GTask *task;
> +    gssize nbytes;
> +    GError *error = NULL;
> +
> +    task = G_TASK(userdata);
> +    self = g_task_get_source_object(task);
> +
> +    g_return_if_fail(self->pending == TRUE);
> +    self->pending = FALSE;
> +
> +    nbytes = g_input_stream_read_finish(G_INPUT_STREAM(self->file_stream),
> res, &error);
> +    if (error || self->error) {
> +        error = (error == NULL) ? self->error : error;
> +        g_task_return_error(task, error);
> +        return;
> +    }
> +
> +    /* The progress here means the amount of data we have _read_ and not what
> +     * was actually sent to the agent. On the next "progress", the previous
> data
> +     * read was sent. This means that when user see 100%, we are sending the
> +     * last chunk to the guest */
> +    self->read_bytes += nbytes;
> +    g_object_notify(G_OBJECT(self), "progress");
> +
> +    g_task_return_int(task, nbytes);
> +}
> +
> +/* main context */
> +static void spice_file_transfer_task_close_stream_cb(GObject      *object,
> +                                                     GAsyncResult *close_res,
> +                                                     gpointer      user_data)
> +{
> +    SpiceFileTransferTask *self;
> +    GError *error = NULL;
> +
> +    self = user_data;
> +
> +    if (object) {
> +        GInputStream *stream = G_INPUT_STREAM(object);
> +        g_input_stream_close_finish(stream, close_res, &error);
> +        if (error) {
> +            /* This error dont need to report to user, just print a log */
> +            SPICE_DEBUG("close file error: %s", error->message);
> +            g_clear_error(&error);
> +        }
> +    }
> +
> +    if (self->error == NULL && spice_util_get_debug()) {
> +        gint64 now = g_get_monotonic_time();
> +        gchar *basename = g_file_get_basename(self->file);
> +        double seconds = (double) (now - self->start_time) /
> G_TIME_SPAN_SECOND;
> +        gchar *file_size_str = g_format_size(self->file_size);
> +        gchar *transfer_speed_str = g_format_size(self->file_size / seconds);
> +
> +        g_warn_if_fail(self->read_bytes == self->file_size);
> +        SPICE_DEBUG("transferred file %s of %s size in %.1f seconds (%s/s)",
> +                    basename, file_size_str, seconds, transfer_speed_str);
> +
> +        g_free(basename);
> +        g_free(file_size_str);
> +        g_free(transfer_speed_str);
> +    }
> +    g_object_unref(self);
> +}
> +
> +
> +/****************************************************************************
> ***
> + * Internal API
> +
> ******************************************************************************
> /
> +
> +G_GNUC_INTERNAL
> +void spice_file_transfer_task_completed(SpiceFileTransferTask *self,
> +                                        GError *error)
> +{
> +    /* In case of multiple errors we only report the first error */
> +    if (self->error)
> +        g_clear_error(&error);
> +    if (error) {
> +        gchar *path = g_file_get_path(self->file);
> +        SPICE_DEBUG("File %s xfer failed: %s",
> +                    path, error->message);
> +        g_free(path);
> +        self->error = error;
> +    }
> +
> +    if (self->pending)
> +        return;
> +
> +    if (!self->file_stream) {
> +        spice_file_transfer_task_close_stream_cb(NULL, NULL, self);
> +        goto signal;
> +    }
> +
> +    g_input_stream_close_async(G_INPUT_STREAM(self->file_stream),
> +                               G_PRIORITY_DEFAULT,
> +                               self->cancellable,
> +                               spice_file_transfer_task_close_stream_cb,
> +                               self);
> +    self->pending = TRUE;
> +signal:
> +    g_signal_emit(self, task_signals[SIGNAL_FINISHED], 0, self->error);
> +}
> +
> +G_GNUC_INTERNAL
> +guint32 spice_file_transfer_task_get_id(SpiceFileTransferTask *self)
> +{
> +    g_return_val_if_fail(self != NULL, 0);
> +    return self->id;
> +}
> +
> +G_GNUC_INTERNAL
> +SpiceMainChannel *spice_file_transfer_task_get_channel(SpiceFileTransferTask
> *self)
> +{
> +    g_return_val_if_fail(self != NULL, NULL);
> +    return self->channel;
> +}
> +
> +G_GNUC_INTERNAL
> +GCancellable *spice_file_transfer_task_get_cancellable(SpiceFileTransferTask
> *self)
> +{
> +    g_return_val_if_fail(self != NULL, NULL);
> +    return self->cancellable;
> +}
> +
> +G_GNUC_INTERNAL
> +guint64 spice_file_transfer_task_get_file_size(SpiceFileTransferTask *self)
> +{
> +    g_return_val_if_fail(self != NULL, 0);
> +    return self->file_size;
> +}
> +
> +G_GNUC_INTERNAL
> +guint64 spice_file_transfer_task_get_bytes_read(SpiceFileTransferTask *self)
> +{
> +    g_return_val_if_fail(self != NULL, 0);
> +    return self->read_bytes;
> +}
> +
> +/* Helper function which only creates a SpiceFileTransferTask per GFile
> + * in @files and returns a HashTable mapping task-id to the task itself
> + * Note that the HashTable does not free its values uppon destruction:
> + * The reference created here should be freed by
> + * spice_file_transfer_task_completed */
> +G_GNUC_INTERNAL
> +GHashTable *spice_file_transfer_task_create_tasks(GFile **files,
> +                                                  SpiceMainChannel *channel,
> +                                                  GFileCopyFlags flags,
> +                                                  GCancellable *cancellable)
> +{
> +    GHashTable *xfer_ht;
> +    gint i;
> +
> +    g_return_val_if_fail(files != NULL && files[0] != NULL, NULL);
> +
> +    xfer_ht = g_hash_table_new(g_direct_hash, g_direct_equal);
> +    for (i = 0; files[i] != NULL && !g_cancellable_is_cancelled(cancellable);
> i++) {
> +        SpiceFileTransferTask *xfer_task;
> +        guint32 task_id;
> +        GCancellable *task_cancellable = cancellable;
> +
> +        /* if a cancellable object was not provided for the overall
> operation,
> +         * create a separate object for each file so that they can be
> cancelled
> +         * separately  */
> +        if (!task_cancellable)
> +            task_cancellable = g_cancellable_new();
> +
> +        xfer_task = spice_file_transfer_task_new(channel, files[i],
> task_cancellable);
> +        xfer_task->flags = flags;
> +
> +        task_id = spice_file_transfer_task_get_id(xfer_task);
> +        g_hash_table_insert(xfer_ht, GUINT_TO_POINTER(task_id), xfer_task);
> +
> +        /* if we created a per-task cancellable above, free it */
> +        if (!cancellable)
> +            g_object_unref(task_cancellable);
> +    }
> +    return xfer_ht;
> +}
> +
> +G_GNUC_INTERNAL
> +void spice_file_transfer_task_init_task_async(SpiceFileTransferTask *self,
> +                                              GAsyncReadyCallback callback,
> +                                              gpointer userdata)
> +{
> +    GTask *task;
> +
> +    g_return_if_fail(self != NULL);
> +    g_return_if_fail(self->pending == FALSE);
> +
> +    task = g_task_new(self, self->cancellable, callback, userdata);
> +
> +    self->pending = TRUE;
> +    g_file_read_async(self->file,
> +                      G_PRIORITY_DEFAULT,
> +                      self->cancellable,
> +                      spice_file_transfer_task_read_file_cb,
> +                      task);
> +}
> +
> +G_GNUC_INTERNAL
> +GFileInfo *spice_file_transfer_task_init_task_finish(SpiceFileTransferTask
> *self,
> +                                                     GAsyncResult *result,
> +                                                     GError **error)
> +{
> +    GTask *task = G_TASK(result);
> +
> +    g_return_val_if_fail(self != NULL, NULL);
> +
> +    if (g_task_propagate_boolean(task, error))
> +        return self->file_info;
> +
> +    return NULL;
> +}
> +
> +/* Any context */
> +G_GNUC_INTERNAL
> +void spice_file_transfer_task_read_async(SpiceFileTransferTask *self,
> +                                         GAsyncReadyCallback callback,
> +                                         gpointer userdata)
> +{
> +    GTask *task;
> +
> +    g_return_if_fail(self != NULL);
> +    if (self->pending) {
> +        g_task_report_new_error(self, callback, userdata,
> +                                spice_file_transfer_task_read_async,
> +                                SPICE_CLIENT_ERROR,
> +                                SPICE_CLIENT_ERROR_FAILED,
> +                                "Cannot read data in pending state");
> +        return;
> +    }
> +
> +    task = g_task_new(self, self->cancellable, callback, userdata);
> +
> +    if (self->read_bytes == self->file_size) {
> +        /* channel-main might can request data after reading the whole file
> as
> +         * it expects EOF. Let's return immediately its request as we don't
> want
> +         * to reach a state where agent says file-transfer SUCCEED but we are
> in
> +         * a PENDING state in SpiceFileTransferTask due reading in idle */
> +        g_task_return_int(task, 0);
> +        return;
> +    }
> +
> +    self->pending = TRUE;
> +    g_input_stream_read_async(G_INPUT_STREAM(self->file_stream),
> +                              self->buffer,
> +                              FILE_XFER_CHUNK_SIZE,
> +                              G_PRIORITY_DEFAULT,
> +                              self->cancellable,
> +                              spice_file_transfer_task_read_stream_cb,
> +                              task);
> +}
> +
> +G_GNUC_INTERNAL
> +gssize spice_file_transfer_task_read_finish(SpiceFileTransferTask *self,
> +                                            GAsyncResult *result,
> +                                            char **buffer,
> +                                            GError **error)
> +{
> +    gssize nbytes;
> +    GTask *task = G_TASK(result);
> +
> +    g_return_val_if_fail(self != NULL, -1);
> +
> +    nbytes = g_task_propagate_int(task, error);
> +    if (nbytes >= 0 && buffer != NULL)
> +        *buffer = self->buffer;
> +
> +    return nbytes;
> +}
> +
> +G_GNUC_INTERNAL
> +void spice_file_transfer_task_debug_info(SpiceFileTransferTask *self)
> +{
> +    const GTimeSpan interval = 20 * G_TIME_SPAN_SECOND;
> +    gint64 now = g_get_monotonic_time();
> +
> +    if (interval < now - self->last_update) {
> +        gchar *basename = g_file_get_basename(self->file);
> +        self->last_update = now;
> +        SPICE_DEBUG("transferred %.2f%% of the file %s",
> +                    100.0 * self->read_bytes / self->file_size, basename);
> +        g_free(basename);
> +    }
> +}
> +
> +/****************************************************************************
> ***
> + * External API
> +
> ******************************************************************************
> /
> +
> +/**
> + * spice_file_transfer_task_get_progress:
> + * @self: a file transfer task
> + *
> + * Convenience function for retrieving the current progress of this file
> + * transfer task.
> + *
> + * Returns: A percentage value between 0 and 100
> + *
> + * Since: 0.31
> + **/
> +double spice_file_transfer_task_get_progress(SpiceFileTransferTask *self)
> +{
> +    if (self->file_size == 0)
> +        return 0.0;
> +
> +    return (double)self->read_bytes / self->file_size;
> +}
> +
> +/**
> + * spice_file_transfer_task_cancel:
> + * @self: a file transfer task
> + *
> + * Cancels the file transfer task. Note that depending on how the file
> transfer
> + * was initiated, multiple file transfer tasks may share a single
> + * #SpiceFileTransferTask::cancellable object, so canceling one task may
> result
> + * in the cancellation of other tasks.
> + *
> + * Since: 0.31
> + **/
> +void spice_file_transfer_task_cancel(SpiceFileTransferTask *self)
> +{
> +    g_cancellable_cancel(self->cancellable);
> +}
> +
> +/**
> + * spice_file_transfer_task_get_filename:
> + * @self: a file transfer task
> + *
> + * Gets the name of the file being transferred in this task
> + *
> + * Returns: (transfer none): The basename of the file
> + *
> + * Since: 0.31
> + **/
> +char* spice_file_transfer_task_get_filename(SpiceFileTransferTask *self)
> +{
> +    return g_file_get_basename(self->file);
> +}
> +
> +/****************************************************************************
> ***
> + * GObject
> +
> ******************************************************************************
> /
> +
> +static void
> +spice_file_transfer_task_get_property(GObject *object,
> +                                      guint property_id,
> +                                      GValue *value,
> +                                      GParamSpec *pspec)
> +{
> +    SpiceFileTransferTask *self = SPICE_FILE_TRANSFER_TASK(object);
> +
> +    switch (property_id)
> +    {
> +        case PROP_TASK_ID:
> +            g_value_set_uint(value, self->id);
> +            break;
> +        case PROP_TASK_FILE:
> +            g_value_set_object(value, self->file);
> +            break;
> +        case PROP_TASK_PROGRESS:
> +            g_value_set_double(value,
> spice_file_transfer_task_get_progress(self));
> +            break;
> +        default:
> +            G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
> +    }
> +}
> +
> +static void
> +spice_file_transfer_task_set_property(GObject *object,
> +                                      guint property_id,
> +                                      const GValue *value,
> +                                      GParamSpec *pspec)
> +{
> +    SpiceFileTransferTask *self = SPICE_FILE_TRANSFER_TASK(object);
> +
> +    switch (property_id)
> +    {
> +        case PROP_TASK_ID:
> +            self->id = g_value_get_uint(value);
> +            break;
> +        case PROP_TASK_FILE:
> +            self->file = g_value_dup_object(value);
> +            break;
> +        case PROP_TASK_CHANNEL:
> +            self->channel = g_value_dup_object(value);
> +            break;
> +        case PROP_TASK_CANCELLABLE:
> +            self->cancellable = g_value_dup_object(value);
> +            break;
> +        default:
> +            G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
> +    }
> +}
> +
> +static void
> +spice_file_transfer_task_dispose(GObject *object)
> +{
> +    SpiceFileTransferTask *self = SPICE_FILE_TRANSFER_TASK(object);
> +
> +    g_clear_object(&self->file);
> +    g_clear_object(&self->file_info);
> +
> +    G_OBJECT_CLASS(spice_file_transfer_task_parent_class)->dispose(object);
> +}
> +
> +static void
> +spice_file_transfer_task_finalize(GObject *object)
> +{
> +    SpiceFileTransferTask *self = SPICE_FILE_TRANSFER_TASK(object);
> +
> +    g_free(self->buffer);
> +
> +    G_OBJECT_CLASS(spice_file_transfer_task_parent_class)->finalize(object);
> +}
> +
> +static void
> +spice_file_transfer_task_constructed(GObject *object)
> +{
> +    SpiceFileTransferTask *self = SPICE_FILE_TRANSFER_TASK(object);
> +
> +    if (spice_util_get_debug()) {
> +        gchar *basename = g_file_get_basename(self->file);
> +        self->start_time = g_get_monotonic_time();
> +        self->last_update = self->start_time;
> +
> +        SPICE_DEBUG("transfer of file %s has started", basename);
> +        g_free(basename);
> +    }
> +}
> +
> +static void
> +spice_file_transfer_task_class_init(SpiceFileTransferTaskClass *klass)
> +{
> +    GObjectClass *object_class = G_OBJECT_CLASS(klass);
> +
> +    object_class->get_property = spice_file_transfer_task_get_property;
> +    object_class->set_property = spice_file_transfer_task_set_property;
> +    object_class->finalize = spice_file_transfer_task_finalize;
> +    object_class->dispose = spice_file_transfer_task_dispose;
> +    object_class->constructed = spice_file_transfer_task_constructed;
> +
> +    /**
> +     * SpiceFileTransferTask:id:
> +     *
> +     * The ID of the file transfer task
> +     *
> +     * Since: 0.31
> +     **/
> +    g_object_class_install_property(object_class, PROP_TASK_ID,
> +                                    g_param_spec_uint("id",
> +                                                      "id",
> +                                                      "The id of the task",
> +                                                      0, G_MAXUINT, 0,
> +                                                      G_PARAM_CONSTRUCT_ONLY
> | G_PARAM_READWRITE |
> +                                                      G_PARAM_STATIC_STRINGS)
> );
> +
> +    /**
> +     * SpiceFileTransferTask:channel:
> +     *
> +     * The main channel that owns the file transfer task
> +     *
> +     * Since: 0.31
> +     **/
> +    g_object_class_install_property(object_class, PROP_TASK_CHANNEL,
> +                                    g_param_spec_object("channel",
> +                                                        "channel",
> +                                                        "The channel
> transferring the file",
> +                                                        SPICE_TYPE_MAIN_CHANN
> EL,
> +                                                        G_PARAM_CONSTRUCT_ONL
> Y | G_PARAM_READWRITE |
> +                                                        G_PARAM_STATIC_STRING
> S));
> +
> +    /**
> +     * SpiceFileTransferTask:cancellable:
> +     *
> +     * A cancellable object used to cancel the file transfer
> +     *
> +     * Since: 0.31
> +     **/
> +    g_object_class_install_property(object_class, PROP_TASK_CANCELLABLE,
> +                                    g_param_spec_object("cancellable",
> +                                                        "cancellable",
> +                                                        "The object used to
> cancel the task",
> +                                                        G_TYPE_CANCELLABLE,
> +                                                        G_PARAM_CONSTRUCT_ONL
> Y | G_PARAM_READWRITE |
> +                                                        G_PARAM_STATIC_STRING
> S));
> +
> +    /**
> +     * SpiceFileTransferTask:file:
> +     *
> +     * The file that is being transferred in this file transfer task
> +     *
> +     * Since: 0.31
> +     **/
> +    g_object_class_install_property(object_class, PROP_TASK_FILE,
> +                                    g_param_spec_object("file",
> +                                                        "File",
> +                                                        "The file being
> transferred",
> +                                                        G_TYPE_FILE,
> +                                                        G_PARAM_CONSTRUCT_ONL
> Y | G_PARAM_READWRITE |
> +                                                        G_PARAM_STATIC_STRING
> S));
> +
> +    /**
> +     * SpiceFileTransferTask:progress:
> +     *
> +     * The current state of the file transfer. This value indicates a
> +     * percentage, and ranges from 0 to 100. Listen for change notifications
> on
> +     * this property to be updated whenever the file transfer progress
> changes.
> +     *
> +     * Since: 0.31
> +     **/
> +    g_object_class_install_property(object_class, PROP_TASK_PROGRESS,
> +                                    g_param_spec_double("progress",
> +                                                        "Progress",
> +                                                        "The percentage of
> the file transferred",
> +                                                        0.0, 100.0, 0.0,
> +                                                        G_PARAM_READABLE |
> +                                                        G_PARAM_STATIC_STRING
> S));
> +
> +    /**
> +     * SpiceFileTransferTask::finished:
> +     * @task: the file transfer task that emitted the signal
> +     * @error: (transfer none): the error state of the transfer. Will be
> %NULL
> +     * if the file transfer was successful.
> +     *
> +     * The #SpiceFileTransferTask::finished signal is emitted when the file
> +     * transfer has completed transferring to the guest.
> +     *
> +     * Since: 0.31
> +     **/
> +    task_signals[SIGNAL_FINISHED] = g_signal_new("finished",
> SPICE_TYPE_FILE_TRANSFER_TASK,
> +                                            G_SIGNAL_RUN_FIRST,
> +                                            0, NULL, NULL,
> +                                            g_cclosure_marshal_VOID__BOXED,
> +                                            G_TYPE_NONE, 1,
> +                                            G_TYPE_ERROR);
> +}
> +
> +static void
> +spice_file_transfer_task_init(SpiceFileTransferTask *self)
> +{
> +    self->buffer = g_malloc0(FILE_XFER_CHUNK_SIZE);
> +}

Acked-by: Jonathon Jongsma <jjongsma@xxxxxxxxxx>

_______________________________________________
Spice-devel mailing list
Spice-devel@xxxxxxxxxxxxxxxxxxxxx
https://lists.freedesktop.org/mailman/listinfo/spice-devel





[Index of Archives]     [Linux ARM Kernel]     [Linux ARM]     [Linux Omap]     [Fedora ARM]     [IETF Annouce]     [Security]     [Bugtraq]     [Linux]     [Linux OMAP]     [Linux MIPS]     [ECOS]     [Asterisk Internet PBX]     [Linux API]     [Monitors]