abrtd: eliminate g_pending_jobs[] map and all corresponding TODOs :)

-6k:

   text   data    bss    dec    hexfilename
 194741   2656   2384 199781  30c65abrt.t1/abrt-0.0.8.5/src/Daemon/.libs/abrtd
 188316   2648   2320 193284  2f304abrt.t2/abrt-0.0.8.5/src/Daemon/.libs/abrtd

Signed-off-by: Denys Vlasenko <vda.linux@googlemail.com>

1 files changed, 56 insertions, 44 deletions

diff --git a/src/Daemon/CrashWatcher.cpp b/src/Daemon/CrashWatcher.cpp
index 1b17af69..1b147ed1 100644
--- a/src/Daemon/CrashWatcher.cpp
+++ b/src/Daemon/CrashWatcher.cpp
@@ -102,48 +102,60 @@ vector_crash_infos_t GetCrashInfos(const std::string &pUID)
     return retval;
 }
 
+/*
+ * "GetJobResult" is a bit of a misnomer.
+ * It actually _creates_ a_ report_ and returns the result.
+ * It is called in two cases:
+ * (1) by CreateReport dbus call -> CreateReportThread(), in the thread
+ * (2) by GetJobResult dbus call
+ * In the second case, it finishes quickly, because previous
+ * CreateReport dbus call already did all the processing, and we just retrieve
+ * the result from dump directory, which is fast.
+ */
+map_crash_report_t GetJobResult(const char* pUUID, const char* pUID)
+{
+    map_crash_info_t crashReport;
+
+    mw_result_t res = CreateCrashReport(pUUID, pUID, crashReport);
+    switch (res)
+    {
+        case MW_OK:
+            break;
+        case MW_IN_DB_ERROR:
+            warn_client(std::string("Did not find crash with UUID ") + pUUID + " in database");
+            break;
+        case MW_PLUGIN_ERROR:
+            warn_client("Particular analyzer plugin isn't loaded or there is an error within plugin(s)");
+            break;
+        case MW_CORRUPTED:
+        case MW_FILE_ERROR:
+        default:
+            warn_client(std::string("Corrupted crash with UUID ") + pUUID + ", deleting");
+            std::string debugDumpDir = DeleteCrashInfo(pUUID, pUID);
+            DeleteDebugDumpDir(debugDumpDir);
+            break;
+    }
+    return crashReport;
+}
+
 typedef struct thread_data_t {
     pthread_t thread_id;
     char* UUID;
     char* UID;
     char* dest;
 } thread_data_t;
-static void *create_report(void *arg)
+static void* create_report(void* arg)
 {
     thread_data_t *thread_data = (thread_data_t *) arg;
-    map_crash_info_t crashReport;
 
-    g_pCommLayer->JobStarted(thread_data->dest, uint64_t(thread_data->thread_id));
+    g_pCommLayer->JobStarted(thread_data->dest);
 
-    log("Creating report...");
     try
     {
-        mw_result_t res;
-        res = CreateCrashReport(thread_data->UUID, thread_data->UID, crashReport);
-        switch (res)
-        {
-            case MW_OK:
-                break;
-            case MW_IN_DB_ERROR:
-                warn_client(std::string("Did not find crash with UUID ") + thread_data->UUID + " in database");
-                break;
-            case MW_PLUGIN_ERROR:
-                warn_client(std::string("Particular analyzer plugin isn't loaded or there is an error within plugin(s)"));
-                break;
-            case MW_CORRUPTED:
-            case MW_FILE_ERROR:
-            default:
-                warn_client(std::string("Corrupted crash with UUID ") + thread_data->UUID + ", deleting");
-                std::string debugDumpDir = DeleteCrashInfo(thread_data->UUID, thread_data->UID);
-                DeleteDebugDumpDir(debugDumpDir);
-                break;
-        }
-        /* only one thread can write */
-        pthread_mutex_lock(&g_pJobsMutex);
-        g_pending_jobs[std::string(thread_data->UID)][uint64_t(thread_data->thread_id)] = crashReport;
-        pthread_mutex_unlock(&g_pJobsMutex);
-
-        g_pCommLayer->JobDone(thread_data->dest, uint64_t(thread_data->thread_id));
+	/* "GetJobResult" is a bit of a misnomer */
+        log("Creating report...");
+        map_crash_info_t crashReport = GetJobResult(thread_data->UUID, thread_data->UID);
+        g_pCommLayer->JobDone(thread_data->dest, thread_data->UUID);
     }
     catch (CABRTException& e)
     {
@@ -167,13 +179,18 @@ static void *create_report(void *arg)
     /* Bogus value. pthreads require us to return void* */
     return NULL;
 }
-uint64_t CreateReport_t(const char* pUUID, const char* pUID, const char* pSender)
+int CreateReportThread(const char* pUUID, const char* pUID, const char* pSender)
 {
     thread_data_t *thread_data = (thread_data_t *)xzalloc(sizeof(thread_data_t));
     thread_data->UUID = xstrdup(pUUID);
     thread_data->UID = xstrdup(pUID);
     thread_data->dest = xstrdup(pSender);
-    if (pthread_create(&thread_data->thread_id, NULL, create_report, (void *)thread_data) != 0)
+//TODO: do we need this?
+//pthread_attr_t attr;
+//pthread_attr_init(&attr);
+//pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
+    int r = pthread_create(&thread_data->thread_id, NULL, create_report, thread_data);
+    if (r != 0)
     {
         free(thread_data->UUID);
         free(thread_data->UID);
@@ -182,10 +199,14 @@ uint64_t CreateReport_t(const char* pUUID, const char* pUID, const char* pSender
         /* The only reason this may happen is system-wide resource starvation,
          * or ulimit is exceeded (someone floods us with CreateReport() dbus calls?)
          */
-        error_msg("cannot create thread");
-        return 0;
+        error_msg("Can't create thread");
+    }
+    else
+    {
+        VERB3 log("Thread %llx created", (unsigned long long)thread_data->thread_id);
     }
-    return uint64_t(thread_data->thread_id);
+//pthread_attr_destroy(&attr);
+    return r;
 }
 
 bool DeleteDebugDump(const std::string& pUUID, const std::string& pUID)
@@ -208,12 +229,3 @@ bool DeleteDebugDump(const std::string& pUUID, const std::string& pUID)
     }
     return true;
 }
-
-map_crash_report_t GetJobResult(uint64_t pJobID, const std::string& pSender)
-{
-    /* FIXME: once we return the result, we should remove it from map to free memory
-       - use some TTL to clean the memory even if client won't get it
-       - if we don't find it in the cache we should try to ask MW to get it again??
-    */
-    return g_pending_jobs[pSender][pJobID];
-}