New subject: [ABRT PATCH 2/2] applet: mark problems as ignored and don't notify ignored problems

Tuesday, 12 March 2013

- the current implementation stores a set of ignored problems in a csv
  file
- each ignored problem corresponds to a single line in the file
- each line has the following format 'PROBLEM ID;UUID;DUPHASH'
- the matching function returns logical true if any line value equals to
  the corresponding problem value

- related to rhbz#909968 and rhbz#905412

Signed-off-by: Jakub Filak <jfilak(a)redhat.com&gt;
---
 src/include/libabrt.h      |  56 +++++++++
 src/lib/Makefile.am        |   3 +-
 src/lib/ignored_problems.c | 274 +++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 332 insertions(+), 1 deletion(-)
 create mode 100644 src/lib/ignored_problems.c

diff --git a/src/include/libabrt.h b/src/include/libabrt.h
index 16008b1..75e4d64 100644
--- a/src/include/libabrt.h
+++ b/src/include/libabrt.h
@@ -139,6 +139,62 @@ problem_data_t *get_problem_data_dbus(const char *problem_dir_path);
 */
 GList *get_problems_over_dbus(bool authorize);
 
+/**
+  @struct ignored_problems
+  @brief An opaque structure holding a list of ignored problems
+*/
+typedef struct ignored_problems ignored_problems_t;
+
+/**
+  @brief Initializes a new instance of ignored problems
+
+  @param file_path A malloced string hodling a path to a file containing the list of
ignored problems. Function takes ownership of the malloced memory, whic will be freed in
ignored_problems_free()
+  @see ignored_problems_free()
+  @return Fully initialized instance of ignored problems struct which must be destroyed
by ignored_problems_free()
+*/
+ignored_problems_t *ignored_problems_new(char *file_path);
+
+/**
+  @brief Destroys an instance of ignored problems
+
+  This function never fails. Supports the common behaviour where it accepts
+  NULL pointers.
+
+  @param set A destroyed instance
+*/
+void ignored_problems_free(ignored_problems_t *set);
+
+/**
+  @brief Adds a problem to the ignored problems
+
+  This function never fails. All errors will be logged.
+
+  @param set An instance of ignored problems to which the problem will be added
+  @param problem_id An identfier of a problem which will be added to an ignored set
+*/
+void ignored_problems_add(ignored_problems_t *set, const char *problem_id);
+
+/**
+  @brief Removes a problem from the ignored problems
+
+  This function never fails. All errors will be logged.
+
+  @param set An instance of ignored problems from which the problem will be added
+  @param problem_id An identifier of a problem which will be removed from an ignored
problems struct
+*/
+void ignored_problems_remove(ignored_problems_t *set, const char *problem_id);
+
+/**
+  @brief Checks if a problem is in the ignored problems
+
+  This function never fails. All errors will be logged. If any error occures,
+  the function returns 0 value.
+
+  @param set An instance of ignored problems in which the problem will be searched
+  @param problem_id An identfier of a problem
+  @return Non 0 value if the problem is ignored; otherwise returns 0 value.
+*/
+bool ignored_problems_contains(ignored_problems_t *set, const char *problem_id);
 
 #ifdef __cplusplus
 }
diff --git a/src/lib/Makefile.am b/src/lib/Makefile.am
index 89ce517..4b1ddb9 100644
--- a/src/lib/Makefile.am
+++ b/src/lib/Makefile.am
@@ -12,7 +12,8 @@ libabrt_la_SOURCES = \
     abrt_glib.c \
     migrate_dirs.c \
     check_recent_crash_file.c \
-    problem_api.c
+    problem_api.c \
+    ignored_problems.c
 
 libabrt_la_CPPFLAGS = \
     -I$(srcdir)/../include \
diff --git a/src/lib/ignored_problems.c b/src/lib/ignored_problems.c
new file mode 100644
index 0000000..454f1f3
--- /dev/null
+++ b/src/lib/ignored_problems.c
@@ -0,0 +1,274 @@
+/*
+    Copyright (C) 2013  ABRT Team
+    Copyright (C) 2013  RedHat inc.
+
+    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 of the License, 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.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+#include "libabrt.h"
+
+#define IGN_COLUMN_DELIMITER ';'
+#define IGN_TEMP_FILE_TEMPLATE "/tmp/abrt_ignored_problems_XXXXXX"
+#define IGN_DD_OPEN_FLAGS (DD_OPEN_READONLY | DD_FAIL_QUIETLY_ENOENT |
DD_FAIL_QUIETLY_EACCES)
+#define IGN_DD_LOAD_TEXT_FLAGS (DD_LOAD_TEXT_RETURN_NULL_ON_FAILURE |
DD_FAIL_QUIETLY_ENOENT | DD_FAIL_QUIETLY_EACCES)
+
+struct ignored_problems
+{
+    char *ign_set_file_path;
+};
+
+ignored_problems_t *ignored_problems_new(char *set_file_path)
+{
+    ignored_problems_t *set = (ignored_problems_t *)xmalloc(sizeof(*set));
+    set->ign_set_file_path = set_file_path;
+
+    return set;
+}
+
+void ignored_problems_free(ignored_problems_t *set)
+{
+    if (NULL == set)
+        return;
+
+    free(set->ign_set_file_path);
+    free(set);
+}
+
+static bool ignored_problems_eq(ignored_problems_t *set,
+        const char *problem_id, const char *uuid, const char *duphash,
+        char *line, unsigned line_num)
+{
+    char *ignored = line;
+    char *ignored_end = strchr(ignored, IGN_COLUMN_DELIMITER);
+
+    if (ignored_end != NULL)
+        ignored_end[0] = '\0';
+
+    if (strcmp(problem_id, ignored) == 0)
+    {
+        VERB1 log("Ignored id equals to '%s'", problem_id);
+        return true;
+    }
+
+    if (ignored_end == NULL)
+    {
+        VERB1 log("Missing UUID as 2nd column at line %d in ignored problems file
'%s'",
+                line_num, set->ign_set_file_path);
+        return false;
+    }
+
+    ignored_end[0] = IGN_COLUMN_DELIMITER;
+    ignored = ignored_end + 1;
+    ignored_end = strchr(ignored, IGN_COLUMN_DELIMITER);
+
+    if (ignored_end != NULL)
+        ignored_end[0] = '\0';
+
+    if (uuid != NULL && strcmp(uuid, ignored) == 0)
+    {
+        VERB1 log("Ignored uuid '%s' equals uuid from of problem
'%s'", ignored, problem_id);
+        return true;
+    }
+
+    if (ignored_end == NULL)
+    {
+        VERB1 log("Missing DUPHASH as 3rd column at line %d in ignored problems file
'%s'",
+                line_num, set->ign_set_file_path);
+
+        return false;
+    }
+
+    ignored_end[0] = IGN_COLUMN_DELIMITER;
+    ignored = ignored_end + 1;
+
+    if (duphash != NULL && strcmp(duphash, ignored) == 0)
+    {
+        VERB1 log("Ignored uuid '%s' equals uuid from of problem
'%s'", ignored, problem_id);
+        return true;
+    }
+
+    return false;
+}
+
+void ignored_problems_add(ignored_problems_t *set, const char *problem_id)
+{
+    if (ignored_problems_contains(set, problem_id))
+    {
+        VERB1 log("Not adding problem '%s' to ignored problems",
problem_id);
+        return;
+    }
+
+    struct dump_dir *dd = dd_opendir(problem_id, IGN_DD_OPEN_FLAGS);
+
+    if (!dd)
+    {
+        VERB1 log("Can't add the problem '%s' to the ignored problems
because of " \
+            "an error while opening the problem", problem_id);
+
+        return;
+    }
+
+    FILE *fp = fopen(set->ign_set_file_path, "a");
+    if (!fp)
+    {
+        VERB1 perror_msg("Can't open the ignored problems '%s' and add
the problem '%s'",
+                set->ign_set_file_path, problem_id);
+
+        dd_close(dd);
+        return;
+    }
+
+    char *uuid = dd_load_text_ext(dd, FILENAME_UUID, IGN_DD_LOAD_TEXT_FLAGS);
+    char *duphash = dd_load_text_ext(dd, FILENAME_DUPHASH, IGN_DD_LOAD_TEXT_FLAGS);
+
+    fprintf(fp, "%s;%s;%s\n", problem_id, (uuid ? uuid : ""),
+                              (duphash ? duphash : ""));
+
+    free(duphash);
+    free(uuid);
+    fclose(fp);
+    dd_close(dd);
+}
+
+void ignored_problems_remove(ignored_problems_t *set, const char *problem_id)
+{
+    if (false == ignored_problems_contains(set, problem_id))
+    {
+        VERB1 log("Not removing problem '%s' from ignored problems",
problem_id);
+        return;
+    }
+
+    VERB1 log("Removing problem '%s' from ignored problems",
problem_id);
+
+    char *uuid = NULL;
+    char *duphash = NULL;
+    struct dump_dir *dd = dd_opendir(problem_id, IGN_DD_OPEN_FLAGS);
+
+    if (dd)
+    {
+        uuid = dd_load_text_ext(dd, FILENAME_UUID, IGN_DD_LOAD_TEXT_FLAGS);
+        duphash = dd_load_text_ext(dd, FILENAME_DUPHASH, IGN_DD_LOAD_TEXT_FLAGS);
+    }
+    else
+    {
+        VERB1 log("Can't use neither UUID nor DUPHASH for identification of
" \
+            "the problem '%s' to remove it from the ignored problems "
\
+            "becuase of an error while opennig the problem", problem_id);
+    }
+
+    FILE *fp = fopen(set->ign_set_file_path, "r");
+    if (!fp)
+    {
+        VERB1 perror_msg("Can't open the ignored problems '%s' and
determine " \
+                   "if the problem '%s' belongs to it",
+                   set->ign_set_file_path, problem_id);
+        if (dd)
+        {
+            free(uuid);
+            free(duphash);
+            dd_close(dd);
+        }
+        return;
+    }
+
+    char result_name[] = IGN_TEMP_FILE_TEMPLATE;
+    int result = mkstemp(result_name);
+
+    unsigned line_num = 0;
+    char *line;
+    while ((line = xmalloc_fgetline(fp)) != NULL)
+    {
+        ++line_num;
+
+        if (!ignored_problems_eq(set, problem_id, uuid, duphash, line, line_num))
+        {
+            ssize_t len = strlen(line);
+            line[len] = '\n';
+            full_write(result, line, len + 1);
+        }
+
+        free(line);
+    }
+
+    close(result);
+    fclose(fp);
+
+    if (dd)
+    {
+        free(duphash);
+        free(uuid);
+        dd_close(dd);
+    }
+
+    if (rename(result_name, set->ign_set_file_path) < 0)
+    {
+        VERB1 perror_msg("Can't remove remove the problem '%s' from the
ignored " \
+                   "problems '%s' because an error while moving an updated
" \
+                   "file '%s'",
+                   problem_id, set->ign_set_file_path, result_name);
+    }
+}
+
+bool ignored_problems_contains(ignored_problems_t *set, const char *problem_id)
+{
+    struct dump_dir *dd = dd_opendir(problem_id, IGN_DD_OPEN_FLAGS);
+
+    if (!dd)
+    {
+        VERB1 log("Can't determine if the problem '%s' belongs to the
ignored " \
+            "problems because of an error while opening the problem",
+            problem_id);
+
+        return false;
+    }
+
+    FILE *fp = fopen(set->ign_set_file_path, "r");
+    if (!fp)
+    {
+        VERB1 perror_msg("Can't open the ignored problems '%s' and
determine " \
+                   "if the problem '%s' belongs to it",
+                   set->ign_set_file_path, problem_id);
+
+        dd_close(dd);
+        return false;
+    }
+
+    char *uuid = dd_load_text_ext(dd, FILENAME_UUID, IGN_DD_LOAD_TEXT_FLAGS);
+    char *duphash = dd_load_text_ext(dd, FILENAME_DUPHASH, IGN_DD_LOAD_TEXT_FLAGS);
+
+    bool result = false;
+    unsigned line_num = 0;
+    while (result == false)
+    {
+        char *line = xmalloc_fgetline(fp);
+
+        if (line == NULL)
+            break;
+
+        ++line_num;
+
+        if (ignored_problems_eq(set, problem_id, uuid, duphash, line, line_num))
+            result = true;
+
+        free(line);
+    }
+
+    free(duphash);
+    free(uuid);
+    fclose(fp);
+    dd_close(dd);
+
+    return result;
+}
-- 
1.8.1.4


    

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

[ABRT PATCH 1/2] introduce helpers for management of list of ignored problems