path: root/src/pop-transaction.c

/* pop-transaction.c - queues actions to be run sequentially
 *
 * Copyright (C) 2007 Ray Strode <rstrode@redhat.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.  
 */
#include "config.h"
#include "pop-transaction.h"

#include <errno.h>
#include <string.h>

#include <glib.h>
#include <glib-object.h>
#include <glib/gi18n.h>

typedef enum 
{
  POP_TRANSACTION_STATE_UNCOMMITED = 0,
  POP_TRANSACTION_STATE_COMMITED,
  POP_TRANSACTION_STATE_PROCESSING,
  POP_TRANSACTION_STATE_ROLLING_BACK,
  POP_TRANSACTION_STATE_FINISHED,
} PopTransactionState;

struct _PopTransactionPrivate
{
  PopTransactionState state;
  PopTransactionStatus status;

  /* FIXME: might be better to keep this as a tree to
   * catch dependencies when one action adds another
   */
  GQueue *actions;
  GList  *current_action_node;

  GClosure *completion_closure;
  GMainContext *context;

  guint is_in_action : 1;

  guint process_idle_id;
  guint rollback_idle_id;
  guint wait_id;

  gpointer result;
  GDestroyNotify free_result_func;

  GError *error;
};

typedef struct
{
  PopActionProcessFunc process_func;
  PopActionRollbackFunc rollback_func;
  gpointer              user_data;
  GDestroyNotify        free_func;
} PopAction;

typedef gboolean (* PopTransactionIdleFunc) (PopTransaction *transaction);

static void pop_transaction_finalize (GObject * object);
static void pop_transaction_class_install_signals (PopTransactionClass *
						   transaction_class);
static void pop_transaction_class_install_properties (PopTransactionClass *
						      transaction_class);

static void pop_transaction_set_property (GObject * object,
					  guint prop_id,
					  const GValue * value,
					  GParamSpec * pspec);
static void pop_transaction_get_property (GObject * object,
					  guint prop_id,
					  GValue * value, GParamSpec * pspec);
static void pop_transaction_fail (PopTransaction *transaction);
static void pop_transaction_process_on_idle (PopTransaction *transaction);
static void pop_transaction_rollback_on_idle (PopTransaction *transaction);
static gboolean pop_transaction_rewind (PopTransaction *transaction);
static void pop_action_free (PopAction *action);
static gboolean pop_transaction_is_committed (PopTransaction *transaction);

enum
{
  PROP_0 = 0,
  PROP_STATUS,
  PROP_ERROR,
  PROP_RESULT,
};

enum
{
  PROCESS = 0,
  WAIT,
  RESUME,
  CANCEL,
  FINISH,
  ROLLBACK,
  NUMBER_OF_SIGNALS
};

static guint pop_transaction_signals[NUMBER_OF_SIGNALS];

G_DEFINE_TYPE (PopTransaction, pop_transaction, G_TYPE_OBJECT);

static void
pop_transaction_class_init (PopTransactionClass * transaction_class)
{
  GObjectClass *object_class;

  object_class = G_OBJECT_CLASS (transaction_class);

  object_class->finalize = pop_transaction_finalize;

  pop_transaction_class_install_properties (transaction_class);
  pop_transaction_class_install_signals (transaction_class);

  g_type_class_add_private (transaction_class,
			    sizeof (PopTransactionPrivate));
}

static void
pop_transaction_class_install_signals (PopTransactionClass *
				       transaction_class)
{
  GObjectClass *object_class;

  object_class = G_OBJECT_CLASS (transaction_class);

  pop_transaction_signals[PROCESS] =
    g_signal_new ("process", G_OBJECT_CLASS_TYPE (object_class),
		  G_SIGNAL_RUN_LAST,
		  G_STRUCT_OFFSET (PopTransactionClass, process),
		  NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
  transaction_class->process = NULL;

  pop_transaction_signals[WAIT] =
    g_signal_new ("wait", G_OBJECT_CLASS_TYPE (object_class),
		  G_SIGNAL_RUN_LAST,
		  G_STRUCT_OFFSET (PopTransactionClass, wait),
		  NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
  transaction_class->wait = NULL;

  pop_transaction_signals[RESUME] =
    g_signal_new ("resume", G_OBJECT_CLASS_TYPE (object_class),
		  G_SIGNAL_RUN_LAST,
		  G_STRUCT_OFFSET (PopTransactionClass, resume),
		  NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
  transaction_class->resume = NULL;

  pop_transaction_signals[CANCEL] =
    g_signal_new ("cancel", G_OBJECT_CLASS_TYPE (object_class),
		  G_SIGNAL_RUN_LAST,
		  G_STRUCT_OFFSET (PopTransactionClass, cancel),
		  NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
  transaction_class->cancel = NULL;

  pop_transaction_signals[FINISH] =
    g_signal_new ("finish", G_OBJECT_CLASS_TYPE (object_class),
		  G_SIGNAL_RUN_LAST,
		  G_STRUCT_OFFSET (PopTransactionClass, finish),
		  NULL, NULL, g_cclosure_marshal_VOID__INT, G_TYPE_NONE, 1, G_TYPE_INT);
  transaction_class->finish = NULL;

  pop_transaction_signals[ROLLBACK] =
    g_signal_new ("rollback", G_OBJECT_CLASS_TYPE (object_class),
		  G_SIGNAL_RUN_LAST,
		  G_STRUCT_OFFSET (PopTransactionClass, rollback),
		  NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
  transaction_class->rollback = NULL;
}

static void
pop_transaction_class_install_properties (PopTransactionClass *transaction_class)
{
  GObjectClass *object_class;
  GParamSpec *param_spec;

  object_class = G_OBJECT_CLASS (transaction_class);
  object_class->set_property = pop_transaction_set_property;
  object_class->get_property = pop_transaction_get_property;

  /* FIXME: do the whole enum gtype song and dance
   */
  param_spec = g_param_spec_int ("status", _("Status"),
				 _("Current status of the transaction"),
				 POP_TRANSACTION_STATUS_NOT_FINISHED,
                                 POP_TRANSACTION_STATUS_SUCCEEDED,
                                 POP_TRANSACTION_STATUS_NOT_FINISHED,
                                 G_PARAM_READABLE);
  g_object_class_install_property (object_class, PROP_STATUS, param_spec);

  param_spec = g_param_spec_pointer ("result", _("Result"),
				     _("Output of transaction"),
                                     G_PARAM_READABLE);
  g_object_class_install_property (object_class, PROP_RESULT, param_spec);

  param_spec = g_param_spec_pointer ("error", _("Error"),
				     _("Reason for transaction error"),
                                     G_PARAM_READWRITE);
  g_object_class_install_property (object_class, PROP_ERROR, param_spec);
}

static void
pop_transaction_init (PopTransaction *transaction)
{
  g_assert (POP_IS_TRANSACTION (transaction));

  transaction->priv = G_TYPE_INSTANCE_GET_PRIVATE (transaction,
						   POP_TYPE_TRANSACTION,
						   PopTransactionPrivate);
  transaction->priv->actions = g_queue_new ();

  transaction->priv->status = POP_TRANSACTION_STATUS_NOT_FINISHED;
}

static void
pop_transaction_finalize (GObject *object)
{
  PopTransaction *transaction;
  GObjectClass *parent_class;

  g_assert (POP_IS_TRANSACTION (object));
  transaction = POP_TRANSACTION (object);

  parent_class = G_OBJECT_CLASS (pop_transaction_parent_class);

  g_queue_foreach (transaction->priv->actions, (GFunc) pop_action_free, NULL);
  g_queue_free (transaction->priv->actions);

  pop_transaction_set_result (transaction, NULL, NULL);

  if (parent_class->finalize != NULL)
    parent_class->finalize (object);
}

static void
pop_transaction_set_property (GObject      *object,
			      guint         prop_id,
			      const GValue *value,
                              GParamSpec   *pspec)
{
  PopTransaction *transaction;

  g_assert (POP_IS_TRANSACTION (object));

  transaction = POP_TRANSACTION (object);

  switch (prop_id)
    {
    case PROP_ERROR:
      pop_transaction_set_error (transaction,
                                 (GError *) g_value_get_pointer (value));
      break;

    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
    }
}

static void
pop_transaction_get_property (GObject    *object,
			      guint       prop_id,
			      GValue     *value,
                              GParamSpec *pspec)
{
  PopTransaction *transaction;

  g_assert (POP_IS_TRANSACTION (object));

  transaction = POP_TRANSACTION (object);

  switch (prop_id)
    {
    case PROP_STATUS:
      g_value_set_int (value, pop_transaction_get_status (transaction));
      break;
    case PROP_ERROR:
      g_value_set_pointer (value, pop_transaction_get_error (transaction));
      break;
    case PROP_RESULT:
      g_value_set_pointer (value, pop_transaction_get_result (transaction));
      break;

    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
    }
}

PopTransaction *
pop_transaction_new (void)
{
  PopTransaction *transaction;

  transaction = g_object_new (POP_TYPE_TRANSACTION, NULL);

  return transaction;
}

PopTransactionStatus
pop_transaction_get_status (PopTransaction *transaction)
{
  g_return_val_if_fail (POP_IS_TRANSACTION (transaction),
                        POP_TRANSACTION_STATUS_FAILED);

  return transaction->priv->status;
}

static void
pop_transaction_set_status (PopTransaction       *transaction,
                            PopTransactionStatus  status)
{
  g_return_if_fail (POP_IS_TRANSACTION (transaction));

  if (transaction->priv->status != status)
    {
      transaction->priv->status = status;
      g_object_notify (G_OBJECT (transaction), "status");
    }
}

static PopAction *
pop_action_new (PopActionProcessFunc  action_process_func,
                PopActionRollbackFunc action_rollback_func,
                gpointer              user_data,
                GDestroyNotify        free_func)
{
  PopAction *action;

  action = g_slice_new0 (PopAction);

  action->process_func = action_process_func;
  action->rollback_func = action_rollback_func;
  action->user_data = user_data;
  action->free_func = free_func;
 
  return action;
}

static void
pop_action_free (PopAction *action)
{
  g_assert (action != NULL);

  if (action->free_func != NULL)
    action->free_func (action->user_data);

  g_slice_free (PopAction, action); 
}

void 
pop_transaction_add_action_full (PopTransaction *transaction,
                                 PopActionProcessFunc action_process_func,
                                 PopActionRollbackFunc action_rollback_func,
                                 gpointer              user_data,
                                 GDestroyNotify        free_func)
{
  PopAction *action;

  g_return_if_fail (POP_IS_TRANSACTION (transaction));

  action = pop_action_new (action_process_func, action_rollback_func, user_data, free_func);

  if (transaction->priv->current_action_node == NULL)
    g_queue_push_tail (transaction->priv->actions, action);
  else
    {
      gboolean can_rewind;

      g_queue_insert_before (transaction->priv->actions, 
                             transaction->priv->current_action_node,
                             action);
      can_rewind = pop_transaction_rewind (transaction);

      g_assert (can_rewind);
    }
}

void 
pop_transaction_add_action (PopTransaction        *transaction,
                            PopActionProcessFunc   action_process_func,
                            PopActionRollbackFunc  action_rollback_func,
                            gpointer               user_data)
{
  pop_transaction_add_action_full (transaction, action_process_func, 
                                   action_rollback_func,
                                   user_data, NULL);
}

static PopActionProcessStatus 
pop_transaction_process_subtransaction (PopTransaction *transaction,
                                        PopTransaction *subtransaction)
{
  PopTransactionStatus status;

  g_assert (POP_IS_TRANSACTION (transaction));
  g_assert (POP_IS_TRANSACTION (subtransaction));

  if (!pop_transaction_is_committed (transaction))
    {
      pop_transaction_wait (transaction);
      g_signal_connect_swapped (G_OBJECT (subtransaction), 
                                "finish", G_CALLBACK (pop_transaction_resume), 
                                transaction);

      pop_transaction_commit (transaction);

      return POP_ACTION_PROCESS_STATUS_NOT_FINISHED;
    }

  status = pop_transaction_get_status (subtransaction);

  g_assert (status != POP_TRANSACTION_STATUS_NOT_FINISHED);
  g_assert (status == POP_TRANSACTION_STATUS_CANCELED || 
            status == POP_TRANSACTION_STATUS_FAILED ||
            status == POP_TRANSACTION_STATUS_SUCCEEDED);

  if ((status == POP_TRANSACTION_STATUS_CANCELED) || 
      (status == POP_TRANSACTION_STATUS_FAILED))
    return POP_ACTION_PROCESS_STATUS_FAILED;

  return POP_ACTION_PROCESS_STATUS_SUCCEEDED;
}

static PopActionRollbackStatus 
pop_transaction_rollback_subtransaction (PopTransaction *transaction,
                                         PopTransaction *subtransaction)
{
  PopTransactionStatus status;
 
  status = pop_transaction_get_status (subtransaction);

  /* FIXME: things are a little confusing here.  when you 
   * rollback a transaction it puts the status in NOT_FINISHED
   * and emits a "finish" signal.  That's pretty counter-intuitive.
   *
   * Maybe we need to change the wording a bit, or use a separate signal
   * for when the rollback completes
   */

  g_assert ((status == POP_TRANSACTION_STATUS_SUCCEEDED) ||
            (status == POP_TRANSACTION_STATUS_NOT_FINISHED));

  /* not rolled back yet
   */
  if (status == POP_TRANSACTION_STATUS_SUCCEEDED)
    {
      pop_transaction_wait (transaction);
      pop_transaction_rollback (subtransaction);
      g_signal_connect_swapped (G_OBJECT (subtransaction), 
                                "finish", G_CALLBACK (pop_transaction_resume), 
                                transaction);
      return POP_ACTION_ROLLBACK_STATUS_NOT_FINISHED;
    }

  /* the second time we've been called. After the pop_transaction_resume() 
   */

  return POP_ACTION_ROLLBACK_STATUS_FINISHED;
}

void 
pop_transaction_add_subtransaction (PopTransaction *transaction,
                                    PopTransaction *subtransaction)
{
  g_return_if_fail (POP_IS_TRANSACTION (transaction));
  g_return_if_fail (POP_IS_TRANSACTION (subtransaction));
  g_return_if_fail (!pop_transaction_is_committed (subtransaction));

  pop_transaction_add_action_full (transaction, 
                                   (PopActionProcessFunc) 
                                   pop_transaction_process_subtransaction,
                                   (PopActionRollbackFunc) 
                                   pop_transaction_rollback_subtransaction,
                                   g_object_ref (subtransaction),
                                   (GDestroyNotify) g_object_unref); 
}

void
pop_transaction_resume (PopTransaction *transaction)
{
  g_assert (POP_IS_TRANSACTION (transaction));
  g_assert (transaction->priv->wait_id > 0);

  switch (transaction->priv->state)
    {
      case POP_TRANSACTION_STATE_PROCESSING:
        pop_transaction_process_on_idle (transaction);
      break;

      case POP_TRANSACTION_STATE_ROLLING_BACK:
        pop_transaction_rollback_on_idle (transaction);
      break;
     
      default:
      break;
    }

  g_source_remove (transaction->priv->wait_id);
  transaction->priv->wait_id = 0;

  g_signal_emit (transaction, pop_transaction_signals[RESUME], 0);
}

static gboolean
pop_transaction_is_in_action (PopTransaction *transaction)
{
  g_return_val_if_fail (POP_IS_TRANSACTION (transaction), FALSE);

  if (transaction->priv->is_in_action)
    {
      g_assert (transaction->priv->state >= POP_TRANSACTION_STATE_PROCESSING);
      return TRUE;
    }

  return FALSE;
}

void 
pop_transaction_wait (PopTransaction *transaction)
{
  g_return_if_fail (POP_IS_TRANSACTION (transaction));
  g_return_if_fail (pop_transaction_is_in_action (transaction));

  switch (transaction->priv->state)
    {
      case POP_TRANSACTION_STATE_PROCESSING:
        g_assert (transaction->priv->process_idle_id != 0);
        g_assert (transaction->priv->rollback_idle_id == 0);
        g_source_remove (transaction->priv->process_idle_id);
        transaction->priv->process_idle_id = 0;
      break;

      case POP_TRANSACTION_STATE_ROLLING_BACK:
        g_assert (transaction->priv->rollback_idle_id != 0);
        g_assert (transaction->priv->process_idle_id == 0);
        g_source_remove (transaction->priv->rollback_idle_id);
        transaction->priv->rollback_idle_id = 0;
      break;
    
      default:
      break;
    }

  g_signal_emit (transaction, pop_transaction_signals[WAIT], 0);
}

static gboolean
pop_transaction_on_fd_ready_resume (GIOChannel   *channel,
                                    GIOCondition  condition,
                                    gpointer      data)
{
  PopTransaction *transaction;

  g_assert (POP_IS_TRANSACTION (data)); 

  transaction = POP_TRANSACTION (data);

  pop_transaction_resume (transaction);
  return FALSE;
}

void
pop_transaction_wait_for_fd (PopTransaction *transaction,
                             int             fd,
                             GIOCondition    condition,
                             GDestroyNotify  destroy_notify)
{
  GIOChannel *channel;
  GSource *source;

  g_return_if_fail (POP_IS_TRANSACTION (transaction));
  g_return_if_fail (pop_transaction_is_in_action (transaction));

  pop_transaction_wait (transaction);

  channel = g_io_channel_unix_new (fd);
  g_io_channel_set_buffered (channel, FALSE);
  source = g_io_create_watch (channel, condition);
  g_source_set_callback (source, (GSourceFunc) pop_transaction_on_fd_ready_resume,
                         transaction, NULL);
  transaction->priv->wait_id = g_source_attach (source,
                                                transaction->priv->context);
  g_source_unref (source);
  g_io_channel_unref (channel);
}

static gboolean
pop_transaction_on_timeout_resume (gpointer data)
{
  PopTransaction *transaction;

  g_assert (POP_IS_TRANSACTION (data)); 

  transaction = POP_TRANSACTION (data);

  pop_transaction_resume (transaction);

  return FALSE;
}

void
pop_transaction_wait_a_while (PopTransaction *transaction,
                              int             milliseconds)
{
  GSource *source;

  g_return_if_fail (POP_IS_TRANSACTION (transaction));
  g_return_if_fail (pop_transaction_is_in_action (transaction));

  pop_transaction_wait (transaction);

  source = g_timeout_source_new (milliseconds);
  g_source_set_callback (source, (GSourceFunc) pop_transaction_on_timeout_resume,
                         transaction, NULL);
  transaction->priv->wait_id = g_source_attach (source,
                                                transaction->priv->context);
  g_source_unref (source);
}

static guint
pop_transaction_call_on_idle (PopTransaction         *transaction,
                              PopTransactionIdleFunc  callback)
{
  GSource *source;
  guint idle_id;

  g_assert (POP_IS_TRANSACTION (transaction));

  source = g_idle_source_new ();
  g_object_ref (transaction);
  g_source_set_callback (source, (GSourceFunc) callback, transaction, 
                         (GDestroyNotify) g_object_unref);

  idle_id = g_source_attach (source, transaction->priv->context); 
  g_source_unref (source);

  return idle_id;
}

static gboolean
pop_transaction_is_at_first_action (PopTransaction *transaction)
{
  GList *first_action_node;

  g_assert (POP_IS_TRANSACTION (transaction));
  g_assert (transaction->priv->current_action_node != NULL);

  first_action_node = g_queue_peek_head_link (transaction->priv->actions);

  return first_action_node == transaction->priv->current_action_node;
}

static gboolean
pop_transaction_rewind (PopTransaction *transaction)
{
  g_assert (POP_IS_TRANSACTION (transaction));

  if (pop_transaction_is_at_first_action (transaction))
    return FALSE;

  transaction->priv->current_action_node =
  transaction->priv->current_action_node->prev;

  return TRUE;
}

static gboolean
pop_transaction_seek_forward (PopTransaction *transaction)
{
  g_assert (POP_IS_TRANSACTION (transaction));
  g_assert (transaction->priv->current_action_node != NULL);

  transaction->priv->current_action_node =
  transaction->priv->current_action_node->next;

  return transaction->priv->current_action_node != NULL;
}

static void
pop_transaction_finish (PopTransaction *transaction)
{
  g_assert (POP_IS_TRANSACTION (transaction));

  transaction->priv->state = POP_TRANSACTION_STATE_FINISHED;

  g_signal_emit (transaction, pop_transaction_signals[FINISH], 0, 
                 transaction->priv->status);
}

static gboolean
pop_transaction_process_current_action_and_seek_forward (PopTransaction *transaction)
{
  PopAction *action;
  PopActionProcessStatus status;
  gboolean should_continue;

  g_assert (POP_IS_TRANSACTION (transaction));
  g_assert (transaction->priv->current_action_node != NULL);

  if (transaction->priv->state == POP_TRANSACTION_STATE_COMMITED)
    {
      transaction->priv->state = POP_TRANSACTION_STATE_PROCESSING;
      g_signal_emit (transaction, pop_transaction_signals[PROCESS], 0);
    }

  g_assert (transaction->priv->state == POP_TRANSACTION_STATE_PROCESSING);

  action = (PopAction *) transaction->priv->current_action_node->data;

  transaction->priv->is_in_action = TRUE;
  if (action->process_func != NULL)
    status = action->process_func (transaction, action->user_data);
  else
    status = POP_ACTION_PROCESS_STATUS_SUCCEEDED; 
  transaction->priv->is_in_action = FALSE;

  switch (status)
    {
      case POP_ACTION_PROCESS_STATUS_NOT_FINISHED:
	should_continue = TRUE;
      break;

      case POP_ACTION_PROCESS_STATUS_SUCCEEDED:
        if (!pop_transaction_seek_forward (transaction))
          {
            pop_transaction_set_status (transaction,
                                        POP_TRANSACTION_STATUS_SUCCEEDED);
            pop_transaction_finish (transaction);
	    should_continue = FALSE;
          }
        else
	  should_continue = TRUE;
      break;

      default:
        g_warning ("status %d is not valid processing status\n", (int) status);

        /* Fall through and fail the action because it's not behaving
         */

      case POP_ACTION_PROCESS_STATUS_FAILED:
	should_continue = FALSE;
        pop_transaction_fail (transaction);
      break;
    }

  if (!should_continue)
    {
      g_source_remove (transaction->priv->process_idle_id);
      transaction->priv->process_idle_id = 0;
    }

  return should_continue;
}

static void
pop_transaction_process_on_idle (PopTransaction *transaction)
{
  g_assert (POP_IS_TRANSACTION (transaction));

  transaction->priv->current_action_node = 
      g_queue_peek_head_link (transaction->priv->actions);

  transaction->priv->process_idle_id =
    pop_transaction_call_on_idle (transaction,
		                  pop_transaction_process_current_action_and_seek_forward); 
}

static gboolean
pop_transaction_rollback_current_action_and_rewind (PopTransaction *transaction)
{
  PopAction *action;
  PopActionRollbackStatus status;
  gboolean should_continue;

  g_assert (POP_IS_TRANSACTION (transaction));
  g_assert (transaction->priv->current_action_node != NULL);

  if (transaction->priv->state == POP_TRANSACTION_STATE_PROCESSING)
    transaction->priv->state = POP_TRANSACTION_STATE_ROLLING_BACK;

  g_assert (transaction->priv->state == POP_TRANSACTION_STATE_ROLLING_BACK);

  action = (PopAction *) transaction->priv->current_action_node->data;

  transaction->priv->is_in_action = TRUE;
  if (action->rollback_func != NULL)
    status = action->rollback_func (transaction, action->user_data);
  else
    status = POP_ACTION_ROLLBACK_STATUS_FINISHED;
  transaction->priv->is_in_action = FALSE;

  switch (status)
    {
      case POP_ACTION_ROLLBACK_STATUS_NOT_FINISHED:
        should_continue = TRUE;
      break;

      default:
        g_warning ("status %d is not valid rollback status\n", (int) status);

        /* Fall through and finish the action because it's not behaving
         */

      case POP_ACTION_ROLLBACK_STATUS_FINISHED:
        should_continue = pop_transaction_rewind (transaction);
      break;

       should_continue = FALSE;
      break;
    }

  if (!should_continue)
    {
      g_source_remove (transaction->priv->rollback_idle_id);
      transaction->priv->rollback_idle_id = 0;

      pop_transaction_finish (transaction);
    }

  return should_continue;
}

static void
pop_transaction_rollback_on_idle (PopTransaction *transaction)
{
  g_assert (POP_IS_TRANSACTION (transaction));

  transaction->priv->current_action_node = transaction->priv->current_action_node->prev;

  transaction->priv->rollback_idle_id =
    pop_transaction_call_on_idle (transaction,
                                  pop_transaction_rollback_current_action_and_rewind); 
}

static void
pop_transaction_rollback_and_finish (PopTransaction *transaction)
{
  g_assert (POP_IS_TRANSACTION (transaction));

  if (pop_transaction_is_at_first_action (transaction))
    {
      pop_transaction_finish (transaction);
      return;
    }

  pop_transaction_rollback_on_idle (transaction);
}

static void
pop_transaction_fail (PopTransaction *transaction)
{
  g_assert (POP_IS_TRANSACTION (transaction));

  pop_transaction_set_status (transaction,
                              POP_TRANSACTION_STATUS_FAILED);
  pop_transaction_rollback_and_finish (transaction);
}

static gboolean
pop_transaction_is_attached (PopTransaction *transaction)
{
  g_assert (POP_IS_TRANSACTION (transaction));

  return transaction->priv->context != NULL;
}

void 
pop_transaction_attach (PopTransaction *transaction,
                        GMainContext   *context)
{
  g_return_if_fail (POP_IS_TRANSACTION (transaction));
  g_return_if_fail (!pop_transaction_is_attached (transaction));

  transaction->priv->context = g_main_context_ref (context);
}

static gboolean
pop_transaction_is_empty (PopTransaction *transaction)
{
  g_assert (POP_IS_TRANSACTION (transaction));

  return g_queue_is_empty (transaction->priv->actions);
}

static gboolean
pop_transaction_is_committed (PopTransaction *transaction)
{
  g_assert (POP_IS_TRANSACTION (transaction));

  return transaction->priv->state >= POP_TRANSACTION_STATE_COMMITED;
}

void
pop_transaction_commit (PopTransaction *transaction)
{
  g_return_if_fail (POP_IS_TRANSACTION (transaction));
  g_return_if_fail (!pop_transaction_is_empty (transaction));
  g_return_if_fail (!pop_transaction_is_committed (transaction));

  pop_transaction_process_on_idle (transaction);

  transaction->priv->state = POP_TRANSACTION_STATE_COMMITED;
}

static gboolean
pop_transaction_is_finished (PopTransaction *transaction)
{
  return transaction->priv->state == POP_TRANSACTION_STATE_FINISHED;
}

void 
pop_transaction_cancel (PopTransaction *transaction)
{
  g_return_if_fail (POP_IS_TRANSACTION (transaction));
  g_return_if_fail (!pop_transaction_is_finished (transaction));

  pop_transaction_set_status (transaction,
                              POP_TRANSACTION_STATUS_CANCELED);

  g_signal_emit (transaction, pop_transaction_signals[CANCEL], 0);

  pop_transaction_rollback_and_finish (transaction);
}

void
pop_transaction_rollback (PopTransaction *transaction)
{
  g_return_if_fail (POP_IS_TRANSACTION (transaction));
  g_return_if_fail (pop_transaction_is_finished (transaction));
  g_return_if_fail (pop_transaction_get_status (transaction) == 
                    POP_TRANSACTION_STATUS_SUCCEEDED);

  pop_transaction_set_status (transaction,
                              POP_TRANSACTION_STATUS_NOT_FINISHED);

  g_signal_emit (transaction, pop_transaction_signals[ROLLBACK], 0);

  pop_transaction_rollback_and_finish (transaction);
}

void
pop_transaction_set_result (PopTransaction *transaction,
                            gpointer        result,
                            GDestroyNotify  free_func)
{
  g_return_if_fail (POP_IS_TRANSACTION (transaction));

  
  if (transaction->priv->free_result_func != NULL) 
    transaction->priv->free_result_func (transaction->priv->result);

  transaction->priv->result = result;
  transaction->priv->free_result_func = free_func;
}

gpointer 
pop_transaction_get_result (PopTransaction *transaction)
{
  g_return_val_if_fail (POP_IS_TRANSACTION (transaction), NULL);

  return transaction->priv->result;
}

void 
pop_transaction_set_error (PopTransaction *transaction,
                           const GError   *error)
{
  g_return_if_fail (POP_IS_TRANSACTION (transaction));

  if (transaction->priv->error != error)
    {
      if (transaction->priv->error != NULL)
        g_error_free (transaction->priv->error);

      transaction->priv->error = g_error_copy (error);
      g_object_notify (G_OBJECT (transaction), "error");
    }
}

GError *
pop_transaction_get_error (PopTransaction *transaction)
{
  g_return_val_if_fail (POP_IS_TRANSACTION (transaction), NULL);

  return g_error_copy (transaction->priv->error);
}

#ifdef POP_TRANSACTION_ENABLE_TEST

#include <stdio.h>
#include <unistd.h>

#include <glib.h>

typedef struct 
{
  int fd;
  guint8 *buffer;
  gssize number_of_bytes_to_process;
} InputOutputArguments;

typedef ssize_t (* InputOutputFunc) (int fd, void *buf, size_t count);

static PopActionProcessStatus
proces_io_action (PopTransaction       *transaction,
                  InputOutputFunc       io_func,
                  InputOutputArguments *arguments,
                  GIOCondition          condition)
{
  gboolean is_ready;
  size_t bytes_left, bytes_done;
  ssize_t bytes_done_this_time;

  g_assert (POP_IS_TRANSACTION (transaction));
  g_return_val_if_fail (arguments->fd >= 0,
                        POP_ACTION_PROCESS_STATUS_FAILED);
  g_return_val_if_fail (arguments->buffer != NULL,
                        POP_ACTION_PROCESS_STATUS_FAILED);

  is_ready = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (transaction), 
                              "is-ready"));
  if (is_ready)
    {
      /* pause transaction until fd is ready for reading (or writing 
       * depending on the io_func)
       */
      pop_transaction_wait_for_fd (transaction, arguments->fd, condition,
                                   NULL); 
      g_object_set_data (G_OBJECT (transaction), "bytes-left-to-process", 
		         GINT_TO_POINTER (arguments->number_of_bytes_to_process));
   
      /* when the transaction gets unpaused we want to continue on
       */
      g_object_set_data (G_OBJECT (transaction), "is-ready",
                         GINT_TO_POINTER (TRUE));
      return POP_ACTION_PROCESS_STATUS_NOT_FINISHED;
    }

  bytes_done = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (transaction), 
                                                   "bytes-already-processed")); 
  bytes_left = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (transaction), 
                                                   "bytes-left-to-process")); 

  bytes_done_this_time = io_func (arguments->fd, 
                                  arguments->buffer + bytes_done,
                                  bytes_left);
  if (bytes_done_this_time < 0)
    {
      GError *error; 

      if ((errno == EINTR) || (errno == EAGAIN))
        return POP_ACTION_PROCESS_STATUS_NOT_FINISHED;

      error = g_error_new_literal (G_FILE_ERROR,
                                   g_file_error_from_errno (errno),
                                   g_strerror (errno)); 

      pop_transaction_set_error (transaction, error);
      g_error_free (error);
      return POP_ACTION_PROCESS_STATUS_FAILED;
    }

  g_assert (bytes_done_this_time <= bytes_left);

  bytes_done += bytes_done_this_time;
  bytes_left -= bytes_done_this_time;
  
  g_object_set_data (G_OBJECT (transaction), "bytes-already-processed", 
                     GINT_TO_POINTER (bytes_done));
  g_object_set_data (G_OBJECT (transaction), "bytes-left-to-process", 
                     GINT_TO_POINTER (bytes_left));

  if (bytes_left == 0)
    {
      pop_transaction_set_result (transaction, arguments->buffer, NULL);
      return POP_ACTION_PROCESS_STATUS_SUCCEEDED;
    }

  return POP_ACTION_PROCESS_STATUS_NOT_FINISHED;
} 

static PopActionProcessStatus 
process_read_action (PopTransaction       *transaction,
                     InputOutputArguments *arguments)
{
  return proces_io_action (transaction, (InputOutputFunc) read,
                           arguments, G_IO_IN);
}

static PopActionProcessStatus 
process_write_action (PopTransaction       *transaction,
                      InputOutputArguments *arguments)
{
  return proces_io_action (transaction, (InputOutputFunc) write,
                           arguments, G_IO_OUT);
}

static void
on_transaction_finish (PopTransaction       *transaction,
                       PopTransactionStatus  status,
                       gpointer              data)
{
  GMainLoop *loop;

  loop = (GMainLoop *) data;
  g_print ("transaction completed with status %d\n", status);

  g_main_loop_quit (loop);
}

static PopActionProcessStatus 
preemptive_action (PopTransaction *transaction,
                   gpointer        user_data)
{
  g_print ("Hello World! should get printed I guess before "
           "the transaction continues...so Hello World!\n");
  return POP_ACTION_PROCESS_STATUS_SUCCEEDED;
}

static PopActionProcessStatus 
test_action (PopTransaction *transaction,
             gpointer        user_data)
{
  PopActionProcessStatus status;

  int generation;
  generation = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (transaction),
                                                   "generation"));
  g_print ("Generation %d\n", generation);
  switch (generation)
    {
      case 0:
      g_print ("First instance of test action\n");
      g_print ("Press enter to continue\n");
      pop_transaction_wait_for_fd (transaction, fileno (stdin), G_IO_IN, NULL); 
      status = POP_ACTION_PROCESS_STATUS_NOT_FINISHED;
      break;

      case 1:
      getc (stdin); 
      g_print ("enter detected, will continue in 5 seconds...\n");
      pop_transaction_wait_a_while (transaction, 5 * 1000);
      status = POP_ACTION_PROCESS_STATUS_NOT_FINISHED;
      break;

      case 2:
      g_print ("5 seconds elapsed, finishing first action...\n");
      status = POP_ACTION_PROCESS_STATUS_SUCCEEDED;
      break;

      case 3:
      g_print ("Second instance of test action\n");
      g_print ("waiting on blocking action before continuing.\n");
      pop_transaction_add_action (transaction, preemptive_action, NULL, NULL);
      status = POP_ACTION_PROCESS_STATUS_NOT_FINISHED;
      break;

      case 4:
      g_print ("blocking action complete.\n");
      g_print ("failing anyway because I'm a failure.\n");
      status = POP_ACTION_PROCESS_STATUS_FAILED;
      break;
    }

  generation++;
  g_object_set_data (G_OBJECT (transaction), "generation",
                     GINT_TO_POINTER (generation));
  return status;
}

static PopActionRollbackStatus 
test_action_cleanup (PopTransaction *transaction,
                     gpointer        user_data)
{
  g_print ("cleaning up!\n");
  return POP_ACTION_ROLLBACK_STATUS_FINISHED;
}

int
main (int argc, char **argv)
{
  GMainLoop *loop;
  PopTransaction *transaction;
  int exit_code;

  g_log_set_always_fatal (G_LOG_LEVEL_ERROR
			  | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING);

  g_type_init ();

  loop = g_main_loop_new (NULL, FALSE);

  g_message ("creating instance of 'transaction' object...");
  transaction = pop_transaction_new ();
  g_message ("'transaction' object created successfully");

  g_signal_connect (G_OBJECT (transaction), "finish", 
                    G_CALLBACK (on_transaction_finish),
                    loop);

  g_message ("adding simple test action...");
  pop_transaction_add_action (transaction, test_action, test_action_cleanup, NULL);
  g_message ("done adding simple test action...");

  g_message ("adding duplicate test action...");
  pop_transaction_add_action (transaction, test_action, NULL, NULL);
  g_message ("done adding test action...");

  g_message ("committing transaction to be processed...");
  pop_transaction_commit (transaction);
  g_message ("done committing transaction to be processed...");

  g_message ("running event loop...");
  g_main_loop_run (loop);
  g_message ("done running event loop...");

  g_message ("cleaning up event loop...");
  g_main_loop_unref (loop);
  g_message ("done cleaning up event loop...");

  g_message ("destroying previously created 'transaction' object...");
  g_object_unref (transaction);
  g_message ("'transaction' object destroyed successfully");

  exit_code = 0;

  return exit_code;
}
#endif /* POP_TRANSACTION_ENABLE_TEST */