Changeset 1817

Show
Ignore:
Timestamp:
04/22/07 13:46:08
Author:
pvanhoof
Message:

Further implementing of queues

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/ChangeLog

    r1815 r1817  
    33        * Created a TnyGenericSendQueue which implements TnySendQueue in a 
    44        generic way (doesn't strictly depend on the libtinymail-camel impl 
    5         libraries)             * unfinished implementation * 
     5        libraries like the TnyCamelSendQueue type) 
    66 
    77        * This was a minor API change (new type added) 
  • trunk/libtinymail-camel/tny-camel-send-queue.c

    r1781 r1817  
    4040        (G_TYPE_INSTANCE_GET_PRIVATE ((o), TNY_TYPE_CAMEL_SEND_QUEUE, TnyCamelSendQueuePriv)) 
    4141 
    42 typedef struct 
    43 
     42typedef struct { 
    4443        TnySendQueue *self; 
    4544        TnyMsg *msg; 
    4645        GError *error; 
    4746        gint i, total; 
    48  
    4947} ErrorInfo; 
    5048 
     
    5351{ 
    5452        ErrorInfo *info = data; 
    55  
    5653        g_signal_emit (info->self, tny_send_queue_signals [TNY_SEND_QUEUE_ERROR_HAPPENED],  
    5754                                0, info->msg, info->error, info->i, info->total); 
    58  
    5955        return FALSE; 
    6056} 
  • trunk/libtinymail-queues/tny-generic-send-queue-priv.h

    r1816 r1817  
    2929        TnyFolder *outbox, *sentbox; 
    3030        TnyTransportAccount *account; 
     31        gboolean cancelled; 
    3132}; 
    3233 
  • trunk/libtinymail-queues/tny-generic-send-queue.c

    r1816 r1817  
    3131#include "tny-generic-send-queue-priv.h" 
    3232 
     33 
     34typedef struct { 
     35        TnySendQueue *self; 
     36        TnyMsg *msg; 
     37        GError *error; 
     38        gint i, total; 
     39} ErrorInfo; 
     40 
     41static gboolean  
     42emit_error_on_mainloop (gpointer data) 
     43{ 
     44        ErrorInfo *info = data; 
     45        g_signal_emit (info->self, tny_send_queue_signals [TNY_SEND_QUEUE_ERROR_HAPPENED],  
     46                0, info->msg, info->error, info->i, info->total); 
     47        return FALSE; 
     48} 
     49 
     50 
     51static void 
     52destroy_error_info (gpointer data) 
     53{ 
     54        ErrorInfo *info = data; 
     55        if (info->msg) 
     56                g_object_unref (G_OBJECT (info->msg)); 
     57        if (info->self) 
     58                g_object_unref (G_OBJECT (info->self)); 
     59        if (info->error) 
     60                g_error_free (info->error); 
     61        g_slice_free (ErrorInfo, info); 
     62} 
     63 
     64static void 
     65emit_error (TnySendQueue *self, TnyMsg *msg, GError *error, int i, int total) 
     66{ 
     67        ErrorInfo *info = g_slice_new0 (ErrorInfo); 
     68        if (error != NULL) 
     69                info->error = g_error_copy ((const GError *) error); 
     70        if (self) 
     71                info->self = TNY_SEND_QUEUE (g_object_ref (G_OBJECT (self))); 
     72        if (msg) 
     73                info->msg = TNY_MSG (g_object_ref (G_OBJECT (msg))); 
     74        info->i = i; 
     75        info->total = total; 
     76        g_idle_add_full (G_PRIORITY_DEFAULT_IDLE, 
     77                emit_error_on_mainloop, info, destroy_error_info); 
     78        return; 
     79} 
     80 
    3381typedef struct { 
    3482        TnyGenericSendQueue *self; 
    3583        TnyMsg *msg; 
    36         GError **err
     84        gint i, total
    3785} GenericSendInfo; 
    3886 
     
    4290{ 
    4391        GenericSendInfo *info = (GenericSendInfo *) arguments; 
     92        TnySendQueue *self = (TnySendQueue *) info->self; 
    4493        TnyGenericSendQueuePriv *priv = TNY_GENERIC_SEND_QUEUE_GET_PRIVATE (info->self); 
    45         TnyList *list = tny_simple_list_new (); 
     94        TnyList *list; 
     95        GError *err = NULL; 
    4696 
    4797        g_mutex_lock (priv->lock); 
    4898 
    49         tny_transport_account_send (priv->account, info->msg, info->err); 
    50         /* TODO handle err */ 
    51  
    52         if (info->err == NULL) 
     99        if (priv->cancelled) 
    53100        { 
     101                g_mutex_unlock (priv->lock); 
     102                return; 
     103        } 
     104 
     105        list = tny_simple_list_new (); 
     106        tny_transport_account_send (priv->account, info->msg, &err); 
     107        if (err != NULL) { 
     108                emit_error (self, info->msg, err, info->i, info->total); 
     109                g_error_free (err); 
     110        } else { 
     111                TnyFolder *outbox, *sentbox; 
     112 
     113                outbox = tny_send_queue_get_outbox (TNY_SEND_QUEUE (info->self)); 
     114                sentbox = tny_send_queue_get_sentbox (TNY_SEND_QUEUE (info->self)); 
     115 
    54116                tny_list_prepend (list, G_OBJECT (info->msg)); 
    55                 tny_folder_transfer_msgs (priv->outbox, list, priv->sentbox, TRUE, info->err); 
     117                tny_folder_transfer_msgs (outbox, list, sentbox, TRUE, &err); 
    56118                g_object_unref (list); 
    57                 /* TODO handle err */ 
    58         } 
    59  
     119                if (err != NULL) { 
     120                        emit_error (self, info->msg, err, info->i, info->total); 
     121                        g_error_free (err); 
     122                } 
     123 
     124                g_object_unref (outbox); 
     125                g_object_unref (sentbox); 
     126        } 
    60127        g_object_unref (info->msg); 
    61128 
     
    69136{ 
    70137        GenericSendInfo *info = o_async_worker_task_get_arguments (task); 
     138        TnyGenericSendQueuePriv *priv = TNY_GENERIC_SEND_QUEUE_GET_PRIVATE (info->self); 
    71139 
    72140        g_object_unref (info->self); 
     
    79147        TnyGenericSendQueuePriv *priv = TNY_GENERIC_SEND_QUEUE_GET_PRIVATE (self); 
    80148        TnyIterator *iter; 
    81         TnyList *list = tny_simple_list_new (); 
     149        TnyList *list; 
     150        gint i=1, total; 
     151 
     152        TnyFolder *outbox; 
    82153 
    83154        g_mutex_lock (priv->lock); 
    84155 
    85         tny_folder_add_msg (priv->outbox, msg, err); 
    86         /* TODO: handle err */ 
    87  
    88         tny_folder_get_headers (priv->outbox, list, FALSE, err); 
    89         /* TODO: handle err */ 
    90  
     156        outbox = tny_send_queue_get_outbox (self); 
     157 
     158        tny_folder_add_msg (outbox, msg, err); 
     159 
     160        if (err!= NULL && *err != NULL) { 
     161                g_object_unref (G_OBJECT (outbox)); 
     162                g_mutex_unlock (priv->lock); 
     163                return; 
     164        } 
     165 
     166        list = tny_simple_list_new (); 
     167        tny_folder_get_headers (outbox, list, FALSE, err); 
     168 
     169        if (err != NULL && *err != NULL) 
     170        { 
     171                g_object_unref (G_OBJECT (outbox)); 
     172                g_object_unref (G_OBJECT (list)); 
     173                g_mutex_unlock (priv->lock); 
     174                return; 
     175        } 
     176 
     177        total = tny_list_get_length (list); 
    91178        iter = tny_list_create_iterator (list); 
    92179 
     
    96183                GenericSendInfo *info = g_slice_new (GenericSendInfo); 
    97184                TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter)); 
    98  
     185                guint item = 0; 
     186 
     187                info->msg = NULL; 
     188                info->i = i; 
     189                info->total = total; 
    99190                info->self = TNY_GENERIC_SEND_QUEUE (g_object_ref (self)); 
    100191                info->msg = tny_folder_get_msg (priv->outbox, header, err); 
    101192 
    102                 /* TODO: Handle err */ 
    103  
    104                 info->err = err; 
     193                if (err != NULL && *err != NULL) 
     194                { 
     195                        g_object_unref (G_OBJECT (task)); 
     196                        g_object_unref (G_OBJECT (info->self)); 
     197                        if (info->msg) 
     198                                g_object_unref (G_OBJECT (info->msg)); 
     199                        g_object_unref (G_OBJECT (header)); 
     200                        g_object_unref (G_OBJECT (iter)); 
     201                        g_object_unref (G_OBJECT (list)); 
     202                        g_slice_free (GenericSendInfo, info); 
     203                        g_object_unref (G_OBJECT (outbox)); 
     204                        g_mutex_unlock (priv->lock); 
     205                        return; 
     206                } 
     207 
    105208                o_async_worker_task_set_arguments (task, info); 
    106209                o_async_worker_task_set_func (task, generic_send_task); 
    107210                o_async_worker_task_set_callback (task, generic_send_callback); 
    108211 
    109                 o_async_worker_add (priv->queue, task); 
     212                item = o_async_worker_add (priv->queue, task); 
    110213 
    111214                g_object_unref (header); 
    112                 tny_iterator_next (iter); 
     215                tny_iterator_next (iter);  
     216                i++; 
    113217        } 
    114218 
    115219        g_object_unref (iter); 
    116220        g_object_unref (list); 
     221        g_object_unref (G_OBJECT (outbox)); 
    117222 
    118223        g_mutex_unlock (priv->lock); 
     
    124229tny_generic_send_queue_cancel (TnySendQueue *self, gboolean remove, GError **err) 
    125230{ 
    126         /* TODO */ 
     231        TnyGenericSendQueuePriv *priv = TNY_GENERIC_SEND_QUEUE_GET_PRIVATE (self); 
     232 
     233        priv->cancelled = TRUE; 
     234        o_async_worker_join (priv->queue); 
     235 
     236        g_mutex_lock (priv->lock); 
     237        if (remove) 
     238        { 
     239                TnyFolder *outbox; 
     240                TnyList *headers = tny_simple_list_new (); 
     241                TnyIterator *iter; 
     242 
     243                outbox = tny_send_queue_get_outbox (self); 
     244 
     245                tny_folder_get_headers (outbox, headers, TRUE, err); 
     246 
     247                if (err != NULL && *err != NULL) 
     248                { 
     249                        g_object_unref (G_OBJECT (headers)); 
     250                        g_object_unref (G_OBJECT (outbox)); 
     251                        priv->cancelled = FALSE; 
     252                        g_mutex_unlock (priv->lock); 
     253                        return; 
     254                } 
     255 
     256                iter = tny_list_create_iterator (headers); 
     257 
     258                while (!tny_iterator_is_done (iter)) 
     259                { 
     260                        TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter)); 
     261                        tny_folder_remove_msg (outbox, header, err); 
     262 
     263                        if (err != NULL && *err != NULL) 
     264                        { 
     265                                g_object_unref (G_OBJECT (header)); 
     266                                g_object_unref (G_OBJECT (iter)); 
     267                                g_object_unref (G_OBJECT (headers)); 
     268                                g_object_unref (G_OBJECT (outbox)); 
     269                                priv->cancelled = FALSE; 
     270                                g_mutex_unlock (priv->lock); 
     271                                return; 
     272                        } 
     273 
     274                        g_object_unref (G_OBJECT (header)); 
     275                        tny_iterator_next (iter); 
     276                } 
     277                g_object_unref (G_OBJECT (iter)); 
     278                g_object_unref (G_OBJECT (headers)); 
     279 
     280                tny_folder_sync (outbox, TRUE, err); 
     281 
     282                g_object_unref (G_OBJECT (outbox)); 
     283        } 
     284 
     285        priv->cancelled = FALSE; 
     286        g_mutex_unlock (priv->lock); 
     287 
     288        return; 
    127289} 
    128290 
     
    173335        TnyGenericSendQueuePriv *priv = TNY_GENERIC_SEND_QUEUE_GET_PRIVATE (object); 
    174336 
     337        priv->cancelled = TRUE; 
     338        o_async_worker_join (priv->queue); 
     339 
    175340        g_mutex_lock (priv->lock); 
    176         o_async_worker_join (priv->queue); 
    177341        g_object_unref (G_OBJECT (priv->queue)); 
    178342        g_object_unref (G_OBJECT (priv->sentbox)); 
     
    198362        priv->sentbox = NULL; 
    199363        priv->outbox = NULL; 
     364        priv->cancelled = FALSE; 
    200365        g_mutex_unlock (priv->lock); 
    201366 
  • trunk/po/Makefile.in.in

    r504 r1817  
    2626prefix = @prefix@ 
    2727exec_prefix = @exec_prefix@ 
     28datarootdir = @datarootdir@ 
    2829datadir = @datadir@ 
    2930libdir = @libdir@ 
     
    4142GMSGFMT = @GMSGFMT@ 
    4243MSGFMT = @MSGFMT@ 
     44MSGFMT_OPTS = @MSGFMT_OPTS@ 
    4345XGETTEXT = @XGETTEXT@ 
    4446MSGMERGE = msgmerge 
     
    7981.po.gmo: 
    8082        file=$(srcdir)/`echo $* | sed 's,.*/,,'`.gmo \ 
    81           && rm -f $$file && $(GMSGFMT) -c -o $$file $< 
     83          && rm -f $$file && $(GMSGFMT) $(MSGFMT_OPTS) -o $$file $< 
    8284 
    8385.po.cat: