aboutsummaryrefslogtreecommitdiffstats
path: root/camel/camel-session.c
diff options
context:
space:
mode:
author8 <NotZed@Ximian.com>2001-09-19 05:43:00 +0800
committerMichael Zucci <zucchi@src.gnome.org>2001-09-19 05:43:00 +0800
commit8347ce1403c68a408a3b9952f6486b5ac584104b (patch)
tree3df009be2f1e694e277133818acb872904d10392 /camel/camel-session.c
parent390621f624b0be7485abdba29d0fe46c905156c8 (diff)
downloadgsoc2013-evolution-8347ce1403c68a408a3b9952f6486b5ac584104b.tar.gz
gsoc2013-evolution-8347ce1403c68a408a3b9952f6486b5ac584104b.tar.zst
gsoc2013-evolution-8347ce1403c68a408a3b9952f6486b5ac584104b.zip
If filter inbox is set on the store, and we're opening inbox '', then
2001-09-18 <NotZed@Ximian.com> * providers/local/camel-maildir-folder.c (camel_maildir_folder_new): If filter inbox is set on the store, and we're opening inbox '', then enable filtering on new messages. * providers/local/camel-local-folder.c (camel_local_folder_construct): After loading the summary, check it, and only abort if that fails. Also maintain the changes count. * providers/local/camel-local-summary.c (camel_local_summary_load): Remove summary_check code from here. (camel_local_summary_check): Sync index/summary here, if we were successful. * providers/local/camel-spool-folder.c (camel_spool_folder_new): If we have filter-new-messages-on-inbox set and we just opened inbox, turn on filtering on this folder. (camel_spool_folder_construct): Keep track of changes for the folder, so that filter-new-messages works right (?) * providers/local/camel-spool-store.c (get_folder): Pass 'INBOX' as the folder name, not the path. * camel-folder-search.c (search_not): Modified patch from <peterw@ximian.com> since the summary is messageinfo's, not strings. ** Ok so the problem with the stuff below is that maildir/spool 'summary_load' throws away all events, including recents, joy eh? * providers/local/camel-maildir-summary.c (maildir_summary_check): Add new messages to the recent changeinfo. * providers/local/camel-spool-summary.c: Mark 'new' message as recent, for later processing if required (i.e. 'filter new messages'). * camel-store.c (construct): new function, cascade up construct method and check for 'filter' param, and set accordingly for any one that might want it. * providers/imap/camel-imap-store.c (construct): map the param_filter_inbox flag to the store->flags as CAMEL_STORE_FILTER_INBOX. * camel-store.h (CAMEL_STORE_FILTER_INBOX): new flag to tell it to filter inbox. * providers/imap/camel-imap-folder.h: Removed do_filtering flag from CamelImapFolder. * providers/imap/camel-imap-folder.c (imap_update_summary): Remove the 'recents' parameter, use the 'changes' parameter instead to convey this info. (camel_imap_folder_changed): Changed for update_summary api change. Now always just emit the changed event if we have any changes to report, filtering code removed, handled upstream. (filter_proc): (filter_free): Removed old filtering code. (camel_imap_folder_new): Set the filter_recent flag on the folder if we're the inbox and filtering of inbox is enabled. * camel-folder.c (folder_changed): If we have 'recent' messages, and are set to filter recents, then freeze the folder and launch a thread to do the processing (or similar if threading not enabled). (thaw): Make sure we emit the changed signal outside of owning the lock and if things have changed. Also, no longer bother downgrading folder_changed events to message_changed events. * camel-folder.h (struct _CamelFolder): Added filter_recent flag -> signifies all recent messages in folder should be filtered. * camel-session.c: (camel_session_thread_msg_new, camel_session_thread_msg_free, camel_session_thread_queue, camel_session_thread_wait): code to handle async operations as part of camel processing. (camel_session_finalise): free thread_lock, destroy thread, active hash, etc. (camel_session_init): init thread, active hash, etc. (camel_session_class_init): Init virtual functions. (session_thread_msg_new, session_thread_msg_free, session_thread_destroy, session_thread_received, session_thread_queue, session_thread_wait): default implementation of session threads stuff. 2001-09-17 <NotZed@Ximian.com> * camel-folder.c (camel_folder_change_info_recent_uid): New function to add a 'recent' uid to the change info. (camel_folder_change_info_clear): Clear recent list. (camel_folder_change_info_free): Free recent list. (camel_folder_change_info_new): Setup recent list. * camel-folder.h: Added a uid_recent item to the folder_changed event data. * providers/local/camel-maildir-store.c (scan_dir): Free new in the right block. * providers/local/camel-local-provider.c: Add local config entries to filter on new messages in spool and maildir provider. * camel-vee-folder.c (vee_folder_construct): Remove the assertion which stops ? in names from being allowed. svn path=/trunk/; revision=12956
Diffstat (limited to 'camel/camel-session.c')
-rw-r--r--camel/camel-session.c186
1 files changed, 184 insertions, 2 deletions
diff --git a/camel/camel-session.c b/camel/camel-session.c
index a6e70bcd98..06b7bb8799 100644
--- a/camel/camel-session.c
+++ b/camel/camel-session.c
@@ -61,6 +61,12 @@ static char *get_storage_path (CamelSession *session,
CamelService *service,
CamelException *ex);
+#ifdef ENABLE_THREADS
+static void *session_thread_msg_new(CamelSession *session, CamelSessionThreadOps *ops, unsigned int size);
+static void session_thread_msg_free(CamelSession *session, CamelSessionThreadMsg *msg);
+static int session_thread_queue(CamelSession *session, CamelSessionThreadMsg *msg, int flags);
+static void session_thread_wait(CamelSession *session, int id);
+#endif
/* The vfolder provider is always avilable */
static CamelProvider vee_provider = {
@@ -87,6 +93,10 @@ camel_session_init (CamelSession *session)
session->priv = g_malloc0(sizeof(*session->priv));
#ifdef ENABLE_THREADS
session->priv->lock = g_mutex_new();
+ session->priv->thread_lock = g_mutex_new();
+ session->priv->thread_id = 1;
+ session->priv->thread_active = g_hash_table_new(NULL, NULL);
+ session->priv->thread_queue = NULL;
#endif
}
@@ -105,6 +115,12 @@ camel_session_finalise (CamelObject *o)
{
CamelSession *session = (CamelSession *)o;
+#ifdef ENABLE_THREADS
+ g_hash_table_destroy(session->priv->thread_active);
+ if (session->priv->thread_queue)
+ e_thread_destroy(session->priv->thread_queue);
+#endif
+
g_free(session->storage_path);
g_hash_table_foreach_remove (session->providers,
camel_session_destroy_provider, NULL);
@@ -112,8 +128,8 @@ camel_session_finalise (CamelObject *o)
#ifdef ENABLE_THREADS
g_mutex_free(session->priv->lock);
-#endif
-
+ g_mutex_free(session->priv->thread_lock);
+#endif
g_free(session->priv);
}
@@ -127,6 +143,13 @@ camel_session_class_init (CamelSessionClass *camel_session_class)
camel_session_class->get_service = get_service;
camel_session_class->get_storage_path = get_storage_path;
+#ifdef ENABLE_THREADS
+ camel_session_class->thread_msg_new = session_thread_msg_new;
+ camel_session_class->thread_msg_free = session_thread_msg_free;
+ camel_session_class->thread_queue = session_thread_queue;
+ camel_session_class->thread_wait = session_thread_wait;
+#endif
+
if (vee_provider.service_cache == NULL) {
vee_provider.object_types[CAMEL_PROVIDER_STORE] = camel_vee_store_get_type ();
vee_provider.service_cache = g_hash_table_new (camel_url_hash, camel_url_equal);
@@ -686,3 +709,162 @@ camel_session_get_filter_driver (CamelSession *session,
{
return CS_CLASS (session)->get_filter_driver (session, type, ex);
}
+
+#ifdef ENABLE_THREADS
+
+static void *session_thread_msg_new(CamelSession *session, CamelSessionThreadOps *ops, unsigned int size)
+{
+ CamelSessionThreadMsg *m;
+
+ g_assert(size >= sizeof(*m));
+
+ m = g_malloc0(size);
+ m->ops = ops;
+
+ CAMEL_SESSION_LOCK(session, thread_lock);
+ m->id = session->priv->thread_id++;
+ g_hash_table_insert(session->priv->thread_active, (void *)m->id, m);
+ CAMEL_SESSION_UNLOCK(session, thread_lock);
+
+ return m;
+}
+
+static void session_thread_msg_free(CamelSession *session, CamelSessionThreadMsg *msg)
+{
+ g_assert(msg->ops != NULL);
+
+ printf("free message %p session %p\n", msg, session);
+
+ CAMEL_SESSION_LOCK(session, thread_lock);
+ g_hash_table_remove(session->priv->thread_active, (void *)msg->id);
+ CAMEL_SESSION_UNLOCK(session, thread_lock);
+
+ printf("free msg, ops->free = %p\n", msg->ops->free);
+
+ if (msg->ops->free)
+ msg->ops->free(session, msg);
+ g_free(msg);
+}
+
+static void session_thread_destroy(EThread *thread, CamelSessionThreadMsg *msg, CamelSession *session)
+{
+ printf("destroy message %p session %p\n", msg, session);
+ session_thread_msg_free(session, msg);
+}
+
+static void session_thread_received(EThread *thread, CamelSessionThreadMsg *msg, CamelSession *session)
+{
+ printf("receive message %p session %p\n", msg, session);
+ if (msg->ops->receive)
+ msg->ops->receive(session, msg);
+}
+
+static int session_thread_queue(CamelSession *session, CamelSessionThreadMsg *msg, int flags)
+{
+ int id;
+
+ CAMEL_SESSION_LOCK(session, thread_lock);
+ if (session->priv->thread_queue == NULL) {
+ session->priv->thread_queue = e_thread_new(E_THREAD_QUEUE);
+ e_thread_set_msg_destroy(session->priv->thread_queue, (EThreadFunc)session_thread_destroy, session);
+ e_thread_set_msg_received(session->priv->thread_queue, (EThreadFunc)session_thread_received, session);
+ }
+ CAMEL_SESSION_UNLOCK(session, thread_lock);
+
+ id = msg->id;
+ e_thread_put(session->priv->thread_queue, &msg->msg);
+
+ return id;
+}
+
+static void session_thread_wait(CamelSession *session, int id)
+{
+ int wait;
+
+ /* we just busy wait, only other alternative is to setup a reply port? */
+ do {
+ CAMEL_SESSION_LOCK(session, thread_lock);
+ wait = g_hash_table_lookup(session->priv->thread_active, (void *)id) != NULL;
+ CAMEL_SESSION_UNLOCK(session, thread_lock);
+ if (wait) {
+ usleep(20000);
+ }
+ } while (wait);
+}
+
+/**
+ * camel_session_thread_msg_new:
+ * @session:
+ * @ops:
+ * @size:
+ *
+ * Create a new thread message, using ops as the receive/reply/free
+ * ops, of @size bytes.
+ *
+ * @ops points to the operations used to recieve/process and finally
+ * free the message.
+ **/
+void *camel_session_thread_msg_new(CamelSession *session, CamelSessionThreadOps *ops, unsigned int size)
+{
+ g_assert(CAMEL_IS_SESSION(session));
+ g_assert(ops != NULL);
+ g_assert(size >= sizeof(CamelSessionThreadMsg));
+
+ return CS_CLASS (session)->thread_msg_new(session, ops, size);
+}
+
+/**
+ * camel_session_thread_msg_free:
+ * @session:
+ * @msg:
+ *
+ * Free a @msg. Note that the message must have been allocated using
+ * msg_new, and must nto have been submitted to any queue function.
+ **/
+void camel_session_thread_msg_free(CamelSession *session, CamelSessionThreadMsg *msg)
+{
+ g_assert(CAMEL_IS_SESSION(session));
+ g_assert(msg != NULL);
+ g_assert(msg->ops != NULL);
+
+ return CS_CLASS (session)->thread_msg_free(session, msg);
+}
+
+/**
+ * camel_session_thread_queue:
+ * @session:
+ * @msg:
+ * @flags: queue type flags, currently 0.
+ *
+ * Queue a thread message in another thread for processing.
+ * The operation should be (but needn't) run in a queued manner
+ * with other operations queued in this manner.
+ *
+ * Return value: The id of the operation queued.
+ **/
+int camel_session_thread_queue(CamelSession *session, CamelSessionThreadMsg *msg, int flags)
+{
+ g_assert(CAMEL_IS_SESSION(session));
+ g_assert(msg != NULL);
+
+ return CS_CLASS (session)->thread_queue(session, msg, flags);
+}
+
+/**
+ * camel_session_thread_wait:
+ * @session:
+ * @id:
+ *
+ * Wait on an operation to complete (by id).
+ **/
+void camel_session_thread_wait(CamelSession *session, int id)
+{
+ g_assert(CAMEL_IS_SESSION(session));
+
+ if (id == -1)
+ return;
+
+ return CS_CLASS (session)->thread_wait(session, id);
+}
+
+#endif