[PATCH 0/7] track#554 : Unify of GTK and CLI reporters implementation

[Jakub Filak]

This set of patches unify implementation of GTK and CLI reporters. In the first
step, run event on dir API is enriched of callbacks which allows to handle
event messages from various frontends. The following step moves the event
configuration checking from report-gtk to libreport. Next step introduces run
event list API which hides an implementation details of processing of events in
reporter applications. Next step introduces asynchronous API for run event
list. The asynchronous run event list is implement with pthreads. The lasts
steps simply uses newly introduced functions in report-gtk and report-cli.

Jakub Filak (7):
  track#554 : run event on rewritten with callbacks
  track#554 : add validate_event_config used byt validate_event to
    refine complexity
  track#554 : move event configuration checking to common lib
  track#554 : add API for runnig of lists of events
  track#554 : use run event list API in report-cli
  track#554 : run event list in thread API
  track#554 : reworked report-gtk with usage of run event list in
    thread

 libreport.spec.in                   |    3 +
 po/POTFILES.in                      |    1 +
 src/cli/cli.c                       |  160 ++--
 src/gui-wizard-gtk/main.c           |   24 +-
 src/gui-wizard-gtk/wizard.c         | 1544 +++++++++++++++--------------------
 src/gui-wizard-gtk/wizard.glade     |   10 +-
 src/gui-wizard-gtk/wizard.h         |    2 +
 src/include/Makefile.am             |    5 +-
 src/include/event_config.h          |    1 +
 src/include/event_usability.h       |   59 ++
 src/include/run_event.h             |  134 ++-
 src/include/run_event_list.h        |  209 +++++
 src/include/run_event_list_thread.h |  174 ++++
 src/lib/Makefile.am                 |    6 +-
 src/lib/event_config.c              |   12 +-
 src/lib/event_usability.c           |  201 +++++
 src/lib/run_event.c                 |  440 ++++++++--
 src/lib/run_event_list.c            |  618 ++++++++++++++
 src/lib/run_event_list_thread.c     |  284 +++++++
 19 files changed, 2836 insertions(+), 1051 deletions(-)
 create mode 100644 src/include/event_usability.h
 create mode 100644 src/include/run_event_list.h
 create mode 100644 src/include/run_event_list_thread.h
 create mode 100644 src/lib/event_usability.c
 create mode 100644 src/lib/run_event_list.c
 create mode 100644 src/lib/run_event_list_thread.c

-- 
1.7.10.2

[PATCH 1/7] track#554 : run event on rewritten with callbacks

[Jakub Filak]

run event on dir uses callbacks for processing messages produced by
event command process. logging_callback and post_run_callback are still
in run_event_state because this callbacks are used in Python API. run
event on dir uses "observer" in order to allow better logging perforemed
by run event on dir callers
---
 src/include/run_event.h |  134 ++++++++++++++-
 src/lib/run_event.c     |  440 +++++++++++++++++++++++++++++++++++++++--------
 2 files changed, 496 insertions(+), 78 deletions(-)

diff --git a/src/include/run_event.h b/src/include/run_event.h
index 43730ce..32ad089 100644
--- a/src/include/run_event.h
+++ b/src/include/run_event.h
@@ -27,17 +27,20 @@ extern "C" {
 
 struct dump_dir;
 
+typedef int (*res_post_run_callback)(const char *dump_dir_name, void *param);
+typedef char* (*res_logging_callback)(char *log_line, void *param);
+
 struct run_event_state {
     int children_count;
 
     /* Used only for post-create dup detection. TODO: document its API */
-    int (*post_run_callback)(const char *dump_dir_name, void *param);
+    res_post_run_callback post_run_callback;
     void *post_run_param;
 
     /* Can take ownership of log_line, which is malloced. In this case, return NULL.
      * Otherwise should return log_line (it will be freed by caller)
      */
-    char* (*logging_callback)(char *log_line, void *param);
+    res_logging_callback logging_callback;
     void *logging_param;
 
     /* Internal data for async command execution */
@@ -49,6 +52,130 @@ struct run_event_state {
 struct run_event_state *new_run_event_state(void);
 void free_run_event_state(struct run_event_state *state);
 
+/*
+ * Kill child's command process if is running
+ *
+ * @param A not NULL pointer to run_event_state
+ */
+void run_event_state_kill_command(struct run_event_state *state);
+
+/*
+ * This structured holds a callbacks used during process of event run.
+ */
+struct run_event_impl
+{
+    /*
+     * Called when child command proced an alert
+     *
+     * Must not be NULL
+     *
+     * @param msg An alert message produced byt child command
+     * @param args An implementor args
+     */
+    void (* alert)(const char *msg, void *args);
+
+    /*
+     * Called when child ask for some input. A callee
+     * should return a text whithout any new line character.
+     *
+     * Must not be NULL
+     *
+     * @param msg An ask message produced by child command
+     * @param args An implementor args
+     * @return Must allways return string without new lines.
+     */
+    char *(* ask)(const char *msg, void *args);
+
+    /*
+     * Called when child wants to know yes/no decision.
+     *
+     * Must not be NULL
+     *
+     * @param msg An ask message produced by child command
+     * @param args An implementor args
+     * @return Return 0 if an answer is NO, otherwise return nonzero value.
+     */
+    int (* ask_yes_no)(const char *msg, void *args);
+
+    /*
+     * Called when child wants to know yes/no decision.
+     *
+     * Must not be NULL
+     *
+     * @param msg An ask message produced by child command
+     * @param password A password value, can be NULL if nobody is interested in.
+     * @param args An implementor args
+     * @return Return nonzero if a password was obtained, otherwise return 0.
+     */
+    int (* ask_password)(const char *msg, char **password, void *args);
+
+    /*
+     * Implementor's custom data.
+     */
+    void *args;
+};
+
+
+struct run_event_observer
+{
+    /*
+     * Push observer method called after child command starts
+     *
+     * @param pid Child's command process pid
+     * @param args An implementor args
+     */
+    void (* command_started)(pid_t pid, void *args);
+
+    /*
+     * Push observer method called after processing of output line from command
+     *
+     * @param msg A line without formatting defined by communication protocol
+     * @param raw_output Whole line read from command output
+     * @param response A response sent back to a command
+     * @param args An implementor args
+     */
+    void (* command_msg_processed)(const char *msg, const char *raw_output, const char
*response, void *args);
+
+    /*
+     * Push observer method called after child command finish
+     *
+     * @param retval Child's command process return value
+     * @param status Child's command process status
+     * @param err_msg An error message generated by runtime (not OS nor child command).
+     * @param args An implementor args
+     */
+    void (* command_finished)(int retval, int status, const char *err_msg, void *args);
+
+    /*
+     * Implementor's custom data.
+     */
+    void *args;
+};
+
+
+/*
+ * Initializes and returns a text implementation of run event callbacks.
+ * The implementation communicates with user over standard input and output.
+ */
+struct run_event_impl *new_text_run_event_impl();
+/*
+ * Frees run_event callbacks text implementation
+ */
+void free_text_run_event_impl(struct run_event_impl *impl);
+
+
+/*
+ * Initializes and returns a implementation of run event observer.
+ * All function calls are passed to a wrapped implementation.
+ * This implementation stores communication between command process and
+ * parent process in problem event log.
+ */
+struct run_event_observer *new_command_log_run_event_observer(char *dump_dir_name, const
struct run_event_observer *wrapped_impl);
+/*
+ * Frees run_event callbacks event log implementation
+ */
+void free_command_log_run_event_observer(struct run_event_observer *impl);
+
 /* Asynchronous command execution */
 
 /* Returns 0 if no commands found for this dump_dir_name+event, else >0 */
@@ -65,6 +192,9 @@ void free_commands(struct run_event_state *state);
 /* Returns exit code of first failed action, or first nonzero return value
  * of post_run_callback. If all actions are successful, returns 0.
  */
+int run_event_state_on_dir_name(struct run_event_state *state, const char
*dump_dir_name,
+                                const char *event, const struct run_event_impl *impl,
+                                const struct run_event_observer *obs);
 int run_event_on_dir_name(struct run_event_state *state, const char *dump_dir_name, const
char *event);
 int run_event_on_problem_data(struct run_event_state *state, problem_data_t *data, const
char *event);
 
diff --git a/src/lib/run_event.c b/src/lib/run_event.c
index e45ec16..44a6fc2 100644
--- a/src/lib/run_event.c
+++ b/src/lib/run_event.c
@@ -26,6 +26,12 @@ struct run_event_state *new_run_event_state()
     return xzalloc(sizeof(struct run_event_state));
 }
 
+void run_event_state_kill_command(struct run_event_state *state)
+{
+    if (state && state->command_pid > 0)
+        kill(state->command_pid, SIGKILL);
+}
+
 void free_run_event_state(struct run_event_state *state)
 {
     if (state)
@@ -432,101 +438,145 @@ int spawn_next_command(struct run_event_state *state,
     return 0;
 }
 
+int run_event_state_on_dir_name(struct run_event_state *state,
+                                const char *dump_dir_name,
+                                const char *event,
+                                const struct run_event_impl *impl,
+                                const struct run_event_observer *obs)
+{
+#define CALL_OBSERVER(var, method, args) do { if (var && var->method )
var->method args; }while(0)
 
-/* Synchronous command execution:
- */
-int run_event_on_dir_name(struct run_event_state *state,
-                const char *dump_dir_name,
-                const char *event
-) {
-    prepare_commands(state, dump_dir_name, event);
-
-    /* Execute every command in shell */
+    static const int alert_prefix_len = sizeof(REPORT_PREFIX_ALERT)-1;
+    static const int ask_prefix_len = sizeof(REPORT_PREFIX_ASK)-1;
+    static const int ask_yes_no_prefix_len = sizeof(REPORT_PREFIX_ASK_YES_NO)-1;
+    static const int ask_password_prefix_len = sizeof(REPORT_PREFIX_ASK_PASSWORD)-1;
 
+    char buf[257]; /* usually we get one line, no need to have big buf */
+    int r;
     int retval = 0;
     while (spawn_next_command(state, dump_dir_name, event) >= 0)
     {
-        /* Consume log from stdout */
-        FILE *fp = fdopen(state->command_out_fd, "r");
-        if (!fp)
-            die_out_of_memory();
-        char *buf;
-        char *msg;
-
-        int alert_prefix_len = strlen(REPORT_PREFIX_ALERT);
-        int ask_prefix_len = strlen(REPORT_PREFIX_ASK);
-        int ask_yes_no_prefix_len = strlen(REPORT_PREFIX_ASK_YES_NO);
-        int ask_password_prefix_len = strlen(REPORT_PREFIX_ASK_PASSWORD);
-
-        while ((buf = xmalloc_fgetline(fp)) != NULL)
+        CALL_OBSERVER(obs, command_started, (state->command_pid, obs->args));
+        struct strbuf *cmd_output = strbuf_new();
+
+        while ((r = read(state->command_out_fd, buf, sizeof(buf) - 1)) > 0)
         {
-            msg = buf;
+            char *newline;
+            char *raw;
+            buf[r] = '\0';
+            raw = buf;
 
-            /* just cut off prefix, no waiting */
-            if (strncmp(REPORT_PREFIX_ALERT, msg, alert_prefix_len) == 0)
-            {
-                msg += alert_prefix_len;
-                printf("%s\n", msg);
-                fflush(stdout);
-            }
-            /* wait for y/N response on the same line */
-            else if (strncmp(REPORT_PREFIX_ASK_YES_NO, msg, ask_yes_no_prefix_len) == 0)
-            {
-                msg += ask_yes_no_prefix_len;
-                printf("%s [%s/%s] ", msg, _("y"),
_("N"));
-                fflush(stdout);
-                char buf[16];
-                if (!fgets(buf, sizeof(buf), stdin))
-                    buf[0] = '\0';
-
-                if (write(state->command_in_fd, buf, strlen(buf)) < 0)
-                    perror_msg_and_die("write");
-            }
-            /* wait for the string on the same line */
-            else if (strncmp(REPORT_PREFIX_ASK, msg, ask_prefix_len) == 0)
-            {
-                msg += ask_prefix_len;
-                printf("%s ", msg);
-                fflush(stdout);
-                char buf[256];
-                if (!fgets(buf, sizeof(buf), stdin))
-                    buf[0] = '\0';
-
-                if (write(state->command_in_fd, buf, strlen(buf)) < 0)
-                    perror_msg_and_die("write");
-            }
-            /* set echo off and wait for password on the same line */
-            else if (strncmp(REPORT_PREFIX_ASK_PASSWORD, msg, ask_password_prefix_len) ==
0)
+            while ((newline = strchr(raw, '\n')) != NULL)
             {
-                msg += ask_password_prefix_len;
-                printf("%s ", msg);
-                fflush(stdout);
-                char buf[256];
-                bool changed = set_echo(false);
-                if (!fgets(buf, sizeof(buf), stdin))
-                    buf[0] = '\0';
-                if (changed)
-                    set_echo(true);
-
-                if (write(state->command_in_fd, buf, strlen(buf)) < 0)
-                    perror_msg_and_die("write");
+                *newline = '\0';
+                strbuf_append_str(cmd_output, raw);
+                char *msg = cmd_output->buf;
+                int skipped_chars = 0;
+
+
+                /* In the code below:
+                 * response is always malloced,
+                 * log_response is always set to response
+                 * or to constant string.
+                 */
+                char *response = NULL;
+
+                /* just cut off prefix, no waiting */
+                if (strncmp(REPORT_PREFIX_ALERT, msg, alert_prefix_len) == 0)
+                {
+                    skipped_chars = alert_prefix_len;
+                    impl->alert(msg + skipped_chars, impl->args);
+                }
+                /* wait for the string on the same line */
+                else if (strncmp(REPORT_PREFIX_ASK, msg, ask_prefix_len) == 0)
+                {
+                    skipped_chars = ask_prefix_len;
+                    response = impl->ask(msg + skipped_chars, impl->args);
+                }
+                /* wait for y/N response on the same line */
+                else if (strncmp(REPORT_PREFIX_ASK_YES_NO, msg, ask_yes_no_prefix_len) ==
0)
+                {
+                    skipped_chars = ask_yes_no_prefix_len;
+                    if (impl->ask_yes_no(msg + skipped_chars, impl->args))
+                        response = xstrdup("y");
+                    else
+                        response = xstrdup("n");
+                }
+                /* set echo off and wait for password on the same line */
+                else if (strncmp(REPORT_PREFIX_ASK_PASSWORD, msg,
ask_password_prefix_len) == 0)
+                {
+                    skipped_chars = ask_password_prefix_len;
+                    if (!impl->ask_password(msg + skipped_chars, &response,
impl->args))
+                        response = xstrdup("");
+                }
+                /* no special prefix -> forward to log if applicable */
+                /* note that callback may take ownership of buf by returning NULL */
+                else if (state->logging_callback)
+                {
+                        char *log = state->logging_callback(xstrdup(msg),
state->logging_param);
+                        free(log);
+                }
+
+                if (response)
+                {
+                    unsigned len = strlen(response);
+                    response[len++] = '\n';
+
+                    if (full_write(state->command_in_fd, response, len) != len)
+                    {
+                        VERB1 perror_msg("Can't write %u bytes to child's
stdin", len);
+                        free(response);
+                        response = xstrdup("<WRITE ERROR>");
+                    }
+                }
+
+                CALL_OBSERVER(obs, command_msg_processed, (msg + skipped_chars, msg,
response, obs->args));
+
+                free(response);
+                strbuf_clear(cmd_output);
+
+                /* jump to next line */
+                raw = newline + 1;
             }
-            /* no special prefix -> forward to log if applicable
-             * note that callback may take ownership of buf by returning NULL */
-            else if (state->logging_callback)
-                buf = state->logging_callback(buf, state->logging_param);
 
-            free(buf);
+            /* beginning of next line. the line continues by next read() */
+            strbuf_append_str(cmd_output, raw);
         }
-        fclose(fp); /* Got EOF, close. This also closes state->command_out_fd */
 
         /* Wait for child to actually exit, collect status */
         int status;
         safe_waitpid(state->command_pid, &status, 0);
+        state->command_pid = 0;
 
         retval = WEXITSTATUS(status);
         if (WIFSIGNALED(status))
             retval = WTERMSIG(status) + 128;
+
+        char *err_msg = NULL;
+        if (retval != 0)
+        {
+            /* Localize these messages? */
+            if (WIFSIGNALED(status))
+                err_msg = xasprintf("killed by signal %u", WTERMSIG(status));
+            else
+                err_msg = xasprintf("exited with %u", retval);
+        }
+
+        CALL_OBSERVER(obs, command_finished, (retval, status, err_msg, obs->args));
+
+        free(err_msg);
+
+        if (geteuid() == 0)
+        {
+            /* Reset mode/uig/gid to correct values for all files created by event run
*/
+            struct dump_dir *dd = dd_opendir(dump_dir_name, 0);
+            if (dd)
+            {
+                dd_sanitize_mode_and_owner(dd);
+                dd_close(dd);
+            }
+        }
+
         if (retval != 0)
             break;
 
@@ -543,6 +593,244 @@ int run_event_on_dir_name(struct run_event_state *state,
     return retval;
 }
 
+static void text_alert(const char *msg, void *args)
+{
+    printf("%s\n", msg);
+    fflush(stdout);
+}
+
+static char *text_ask(const char *msg, void *args)
+{
+    printf("%s ", msg);
+    fflush(stdout);
+    char buf[256];
+    if (!fgets(buf, sizeof(buf), stdin))
+        buf[0] = '\0';
+    else
+        strtrimch(buf,'\n');
+
+    return xstrdup(buf);
+}
+
+static int text_ask_yes_no(const char *msg, void *args)
+{
+    printf("%s [%s/%s] ", msg, _("y"), _("N"));
+    fflush(stdout);
+    char buf[16];
+    if (!fgets(buf, sizeof(buf), stdin))
+        return false;
+
+    return buf[0] == 'y' && (buf[1] == '\n' || buf[1] ==
'\0');
+}
+
+static int text_ask_password(const char *msg, char **password, void *args)
+{
+    printf("%s ", msg);
+    fflush(stdout);
+    char buf[256];
+    bool changed = set_echo(false);
+    bool got = fgets(buf, sizeof(buf), stdin);
+
+    if (changed)
+        set_echo(true);
+
+    if (got && password)
+    {
+        strtrimch(buf,'\n');
+        *password = xstrdup(buf);
+    }
+
+    return got;
+}
+
+enum event_log_state {
+    ELS_LOGSTATE_FIRSTLINE = 0,
+    ELS_LOGSTATE_BEGLINE,
+    ELS_LOGSTATE_ERRLINE,
+    ELS_LOGSTATE_MIDLINE,
+};
+
+struct log_event_data
+{
+    char *dump_dir_name;
+    struct strbuf *event_log;
+    enum event_log_state event_log_state;
+    const struct run_event_observer *wrapped_obs;
+};
+
+static void save_to_event_log(struct log_event_data *led, const char *str)
+{
+    static const char delim[] = {
+        [ELS_LOGSTATE_FIRSTLINE] = '>',
+        [ELS_LOGSTATE_BEGLINE] = ' ',
+        [ELS_LOGSTATE_ERRLINE] = '*',
+    };
+
+    while (str[0])
+    {
+        char *end = strchrnul(str, '\n');
+        char end_char = *end;
+        if (end_char == '\n')
+            end++;
+        switch (led->event_log_state)
+        {
+            case ELS_LOGSTATE_FIRSTLINE:
+            case ELS_LOGSTATE_BEGLINE:
+            case ELS_LOGSTATE_ERRLINE:
+                /* skip empty lines */
+                if (str[0] == '\n')
+                    goto next_save_to_event_log;
+                strbuf_append_strf(led->event_log, "%s%c %.*s",
+                        iso_date_string(NULL),
+                        delim[led->event_log_state],
+                        (int)(end - str), str
+                );
+                break;
+            case ELS_LOGSTATE_MIDLINE:
+                strbuf_append_strf(led->event_log, "%.*s", (int)(end - str),
str);
+                break;
+        }
+        led->event_log_state = ELS_LOGSTATE_MIDLINE;
+        if (end_char != '\n')
+            break;
+        led->event_log_state = ELS_LOGSTATE_BEGLINE;
+next_save_to_event_log:
+        str = end;
+    }
+}
+
+static void update_event_log_on_disk(const char *str, const char *dump_dir_name)
+{
+    /* Load existing log */
+    struct dump_dir *dd = dd_opendir(dump_dir_name, 0);
+    if (!dd)
+        return;
+    char *event_log = dd_load_text_ext(dd, FILENAME_EVENT_LOG, DD_FAIL_QUIETLY_ENOENT);
+
+    /* Append new log part to existing log */
+    unsigned len = strlen(event_log);
+    if (len != 0 && event_log[len - 1] != '\n')
+        event_log = append_to_malloced_string(event_log, "\n");
+    event_log = append_to_malloced_string(event_log, str);
+
+    /* Trim log according to size watermarks */
+    len = strlen(event_log);
+    char *new_log = event_log;
+    if (len > EVENT_LOG_HIGH_WATERMARK)
+    {
+        new_log += len - EVENT_LOG_LOW_WATERMARK;
+        new_log = strchrnul(new_log, '\n');
+        if (new_log[0])
+            new_log++;
+    }
+
+    /* Save */
+    dd_save_text(dd, FILENAME_EVENT_LOG, new_log);
+    free(event_log);
+    dd_close(dd);
+}
+
+static void event_log_command_started(pid_t pid, void *args)
+{
+    struct log_event_data *led = (struct log_event_data *)args;
+
+    if (led->wrapped_obs->command_started)
+        led->wrapped_obs->command_started(pid, led->wrapped_obs->args);
+}
+
+static void event_log_command_msg_processed(const char *msg, const char *raw_input, const
char *rsp, void *args)
+{
+    struct log_event_data *led = (struct log_event_data *)args;
+    save_to_event_log(led, msg);
+
+    if (led->wrapped_obs->command_msg_processed)
+        led->wrapped_obs->command_msg_processed(msg, raw_input, rsp,
led->wrapped_obs->args);
+}
+
+static void event_log_command_finished(int retval, int status, const char *err_msg, void
*args)
+{
+    struct log_event_data *led = (struct log_event_data *)args;
+
+    if (retval != 0 || led->event_log_state == ELS_LOGSTATE_FIRSTLINE)
+    {
+        if (retval != 0) /* If program failed, emit error line */
+            led->event_log_state = ELS_LOGSTATE_ERRLINE;
+
+        save_to_event_log(led, err_msg);
+    }
+
+    /* Append log to FILENAME_EVENT_LOG */
+    update_event_log_on_disk(led->event_log->buf, led->dump_dir_name);
+    strbuf_clear(led->event_log);
+    led->event_log_state = ELS_LOGSTATE_FIRSTLINE;
+
+    if (led->wrapped_obs->command_finished)
+        led->wrapped_obs->command_finished(retval, status, err_msg,
led->wrapped_obs->args);
+}
+
+struct run_event_observer *new_command_log_run_event_observer(char *dump_dir_name, const
struct run_event_observer *wrapped_obs)
+{
+    struct log_event_data *led = xmalloc(sizeof(*led));
+    led->dump_dir_name = xstrdup(dump_dir_name);
+    led->event_log = strbuf_new();
+    led->event_log_state = ELS_LOGSTATE_FIRSTLINE;
+    led->wrapped_obs = wrapped_obs;
+
+    struct run_event_observer *impl = xmalloc(sizeof(*impl));
+    /* cannot use callbacks from wrapped because of args */
+    impl->command_started = event_log_command_started;
+    impl->command_msg_processed = event_log_command_msg_processed;
+    impl->command_finished = event_log_command_finished;
+    impl->args = led;
+
+    return impl;
+}
+
+void free_command_log_run_event_observer(struct run_event_observer *impl)
+{
+    struct log_event_data *led = (struct log_event_data *)impl->args;
+    free(led->dump_dir_name);
+    strbuf_free(led->event_log);
+    free(led);
+    free(impl);
+}
+
+struct run_event_impl *new_text_run_event_impl()
+{
+    struct run_event_impl *impl = xmalloc(sizeof(*impl));
+
+    impl->alert = text_alert;
+    impl->ask = text_ask;
+    impl->ask_yes_no = text_ask_yes_no;
+    impl->ask_password = text_ask_password;
+    impl->args = NULL;
+
+    return impl;
+}
+
+void free_text_run_event_impl(struct run_event_impl *impl)
+{
+    free(impl);
+}
+
+/* Synchronous command execution:
+ */
+int run_event_on_dir_name(struct run_event_state *state,
+                const char *dump_dir_name,
+                const char *event)
+{
+    if (prepare_commands(state, dump_dir_name, event) == 0)
+        return -1;
+
+    struct run_event_impl *impl = new_text_run_event_impl();
+
+    const int ret = run_event_state_on_dir_name(state, dump_dir_name, event, impl,
NULL);
+
+    free_text_run_event_impl(impl);
+
+    return ret;
+}
+
 int run_event_on_problem_data(struct run_event_state *state, problem_data_t *data, const
char *event)
 {
     state->children_count = 0;
-- 
1.7.10.2

[PATCH 1/7] track#554 : run event on rewritten with callbacks

[Denys Vlasenko]

On 06/26/2012 10:37 AM, Jakub Filak wrote:
>  run event on dir uses callbacks for processing messages produced by
>  event command process. logging_callback and post_run_callback are still
>  in run_event_state because this callbacks are used in Python API. run
>  event on dir uses "observer" in order to allow better logging perforemed
>  by run event on dir callers
>  ---
>    src/include/run_event.h |  134 ++++++++++++++-
>    src/lib/run_event.c     |  440 +++++++++++++++++++++++++++++++++++++++--------
>    2 files changed, 496 insertions(+), 78 deletions(-)
>
>  diff --git a/src/include/run_event.h b/src/include/run_event.h
>  index 43730ce..32ad089 100644
>  --- a/src/include/run_event.h
>  +++ b/src/include/run_event.h
>  @@ -27,17 +27,20 @@ extern "C" {
>
>    struct dump_dir;
>
>  +typedef int (*res_post_run_callback)(const char *dump_dir_name, void *param);
>  +typedef char* (*res_logging_callback)(char *log_line, void *param);
>  +
>    struct run_event_state {
>        int children_count;
>
>        /* Used only for post-create dup detection. TODO: document its API */
>  -    int (*post_run_callback)(const char *dump_dir_name, void *param);
>  +    res_post_run_callback post_run_callback;
>        void *post_run_param;
>
>        /* Can take ownership of log_line, which is malloced. In this case, return NULL.
>         * Otherwise should return log_line (it will be freed by caller)
>         */
>  -    char* (*logging_callback)(char *log_line, void *param);
>  +    res_logging_callback logging_callback;
>        void *logging_param;
>
>        /* Internal data for async command execution */
>  @@ -49,6 +52,130 @@ struct run_event_state {
>    struct run_event_state *new_run_event_state(void);
>    void free_run_event_state(struct run_event_state *state);
>
>  +/*
>  + * Kill child's command process if is running
>  + *
>  + * @param A not NULL pointer to run_event_state
>  + */
>  +void run_event_state_kill_command(struct run_event_state *state);
>  +
>  +/*
>  + * This structured holds a callbacks used during process of event run.
>  + */
>  +struct run_event_impl
>  +{
>  +    /*
>  +     * Called when child command proced an alert
>  +     *
>  +     * Must not be NULL
>  +     *
>  +     * @param msg An alert message produced byt child command
>  +     * @param args An implementor args
>  +     */
>  +    void (* alert)(const char *msg, void *args);
>  +
>  +    /*
>  +     * Called when child ask for some input. A callee
>  +     * should return a text whithout any new line character.
>  +     *
>  +     * Must not be NULL
>  +     *
>  +     * @param msg An ask message produced by child command
>  +     * @param args An implementor args
>  +     * @return Must allways return string without new lines.
>  +     */
>  +    char *(* ask)(const char *msg, void *args);
>  +
>  +    /*
>  +     * Called when child wants to know yes/no decision.
>  +     *
>  +     * Must not be NULL
>  +     *
>  +     * @param msg An ask message produced by child command
>  +     * @param args An implementor args
>  +     * @return Return 0 if an answer is NO, otherwise return nonzero value.
>  +     */
>  +    int (* ask_yes_no)(const char *msg, void *args);
>  +
>  +    /*
>  +     * Called when child wants to know yes/no decision.
>  +     *
>  +     * Must not be NULL
>  +     *
>  +     * @param msg An ask message produced by child command
>  +     * @param password A password value, can be NULL if nobody is interested in.
>  +     * @param args An implementor args
>  +     * @return Return nonzero if a password was obtained, otherwise return 0.
>  +     */
>  +    int (* ask_password)(const char *msg, char **password, void *args);
>  +
>  +    /*
>  +     * Implementor's custom data.
>  +     */
>  +    void *args;
>  +};
>  +
>  +
>  +struct run_event_observer
>  +{
>  +    /*
>  +     * Push observer method called after child command starts
>  +     *
>  +     * @param pid Child's command process pid
>  +     * @param args An implementor args
>  +     */
>  +    void (* command_started)(pid_t pid, void *args);
>  +
>  +    /*
>  +     * Push observer method called after processing of output line from command
>  +     *
>  +     * @param msg A line without formatting defined by communication protocol
>  +     * @param raw_output Whole line read from command output
>  +     * @param response A response sent back to a command
>  +     * @param args An implementor args
>  +     */
>  +    void (* command_msg_processed)(const char *msg, const char *raw_output, const char
> *response, void *args);
>  +
>  +    /*
>  +     * Push observer method called after child command finish
>  +     *
>  +     * @param retval Child's command process return value
>  +     * @param status Child's command process status
>  +     * @param err_msg An error message generated by runtime (not OS nor child command).
>  +     * @param args An implementor args
>  +     */
>  +    void (* command_finished)(int retval, int status, const char *err_msg, void *args);
>  +
>  +    /*
>  +     * Implementor's custom data.
>  +     */
>  +    void *args;
>  +}; 
I think it would be simpler if all these callbacks will be in one structure.
As a user, I would be confused having three structs with function ptrs.

>  +struct run_event_impl *new_text_run_event_impl(); 
(in C, func() means "function with unknown params". Use func(void)
  to indicate "function with no params").

Just expose standard text callbacks in *.h file and let user
assign them to the function pointers.

>  +/*
>  + * Initializes and returns a implementation of run event observer.
>  + * All function calls are passed to a wrapped implementation.
>  + * This implementation stores communication between command process and
>  + * parent process in problem event log.
>  + */
>  +struct run_event_observer *new_command_log_run_event_observer(char *dump_dir_name, const
> struct run_event_observer *wrapped_impl); 
Why is it needed?
It's easier to see the need for it if you would add the user
in the same patch.

-- 
vda

[PATCH 2/7] track#554 : add validate_event_config used byt validate_event to refine complexity

[Jakub Filak]

Signed-off-by: Jakub Filak <jfilak(a)redhat.com&gt;
---
 src/include/event_config.h |    1 +
 src/lib/event_config.c     |   12 ++++++++----
 2 files changed, 9 insertions(+), 4 deletions(-)

diff --git a/src/include/event_config.h b/src/include/event_config.h
index 6644b42..c940647 100644
--- a/src/include/event_config.h
+++ b/src/include/event_config.h
@@ -101,6 +101,7 @@ extern GHashTable *g_event_config_list;   // for iterating through
entire list o
 GList *export_event_config(const char *event_name);
 void unexport_event_config(GList *env_list);
 
+GHashTable *validate_event_config(const event_config_t *event_config);
 GHashTable *validate_event(const char *event_name);
 
 #ifdef __cplusplus
diff --git a/src/lib/event_config.c b/src/lib/event_config.c
index 85c0e80..5684e81 100644
--- a/src/lib/event_config.c
+++ b/src/lib/event_config.c
@@ -343,16 +343,15 @@ static char *validate_event_option(event_option_t *opt)
     return NULL;
 }
 
-GHashTable *validate_event(const char *event_name)
+GHashTable *validate_event_config(const event_config_t *event_config)
 {
-    event_config_t *config = get_event_config(event_name);
-    if (!config)
+    if (!event_config)
         return NULL;
 
     GHashTable *errors = g_hash_table_new_full(g_str_hash, g_str_equal, free, free);
     GList *li;
 
-    for (li = config->options; li; li = li->next)
+    for (li = event_config->options; li; li = li->next)
     {
         event_option_t *opt = (event_option_t *)li->data;
         char *err = validate_event_option(opt);
@@ -367,3 +366,8 @@ GHashTable *validate_event(const char *event_name)
 
     return NULL;
 }
+
+GHashTable *validate_event(const char *event_name)
+{
+    return validate_event_config(get_event_config(event_name));
+}
-- 
1.7.10.2

[PATCH 3/7] track#554 : move event configuration checking to common lib

[Jakub Filak]

Signed-off-by: Jakub Filak <jfilak(a)redhat.com&gt;
---
 libreport.spec.in             |    1 +
 po/POTFILES.in                |    1 +
 src/include/Makefile.am       |    3 +-
 src/include/event_usability.h |   59 ++++++++++++
 src/lib/Makefile.am           |    4 +-
 src/lib/event_usability.c     |  201 +++++++++++++++++++++++++++++++++++++++++
 6 files changed, 267 insertions(+), 2 deletions(-)
 create mode 100644 src/include/event_usability.h
 create mode 100644 src/lib/event_usability.c

diff --git a/libreport.spec.in b/libreport.spec.in
index 6f6da01..3f730e3 100644
--- a/libreport.spec.in
+++ b/libreport.spec.in
@@ -296,6 +296,7 @@ gtk-update-icon-cache %{_datadir}/icons/hicolor &>/dev/null ||
:
 %{_includedir}/libreport/problem_data.h
 %{_includedir}/libreport/report.h
 %{_includedir}/libreport/run_event.h
+%{_includedir}/libreport/event_usability.h
 # Private api headers:
 %{_includedir}/libreport/internal_abrt_dbus.h
 %{_includedir}/libreport/internal_libreport.h
diff --git a/po/POTFILES.in b/po/POTFILES.in
index 3203183..88c15f5 100644
--- a/po/POTFILES.in
+++ b/po/POTFILES.in
@@ -14,6 +14,7 @@ src/lib/parse_options.c
 src/lib/curl.c
 src/lib/client.c
 src/lib/run_event.c
+src/lib/event_usability.c
 src/lib/problem_data.c
 src/plugins/abrt_rh_support.c
 src/plugins/report.c
diff --git a/src/include/Makefile.am b/src/include/Makefile.am
index 61b49a3..7aa5f78 100644
--- a/src/include/Makefile.am
+++ b/src/include/Makefile.am
@@ -9,4 +9,5 @@ libreport_include_HEADERS = \
     libreport_curl.h \
     \
     internal_libreport.h \
-    internal_abrt_dbus.h
+    internal_abrt_dbus.h \
+    event_usability.h
diff --git a/src/include/event_usability.h b/src/include/event_usability.h
new file mode 100644
index 0000000..342c125
--- /dev/null
+++ b/src/include/event_usability.h
@@ -0,0 +1,59 @@
+/*
+    Copyright (C) 2009  Abrt team.
+    Copyright (C) 2009  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.
+*/
+#ifndef LIBREPORT_EVENT_USABILITY_CHECK_H_
+#define LIBREPORT_EVENT_USABILITY_CHECK_H_
+
+#include <glib.h>
+#include "problem_data.h"
+#include "event_config.h"
+
+/*
+ * Event usability levels
+ */
+enum event_usability_status
+{
+    EUS_GOOD,       ///< event is usuable
+    EUS_LOW,        ///< event is possibly unusable
+    EUS_UNUSABLE,   ///< event is not usable
+};
+
+/*
+ * Selects the forst usability
+ *
+ * @param f an event usability level
+ * @param s an event usability level
+ * @return returns the worst usability from the two passed
+ */
+enum event_usability_status worst_usability(enum event_usability_status f, enum
event_usability_status s);
+
+/*
+ * Cechcks event config agains problem items an returns event usability level.
+ *
+ * @param ec a checked event config
+ * @param pd a checked problem data
+ * @param not_loaded_items a items not in problem data, thier values are unknown
+ * @param issues a list of found issues
+ * @param min_level a minimal checked level, issues above this level are not reported
+ * @return returns the worst found usability
+ */
+enum event_usability_status check_event_usability(const event_config_t *ec, const
problem_data_t *pd,
+                                                  const GList *not_loaded_items, GList
**issues,
+                                                  enum event_usability_status
min_level);
+
+#endif /* LIBREPORT_EVENT_USABILITY_CHECK_H_ */
diff --git a/src/lib/Makefile.am b/src/lib/Makefile.am
index d2282db..cd1f164 100644
--- a/src/lib/Makefile.am
+++ b/src/lib/Makefile.am
@@ -47,7 +47,9 @@ libreport_la_SOURCES = \
     report.c \
     user_settings.c \
     client.c \
-    utf8.c
+    utf8.c \
+    event_usability.c
+
 libreport_la_CPPFLAGS = \
     -Wall -Wwrite-strings -Werror \
     -I$(srcdir)/../include \
diff --git a/src/lib/event_usability.c b/src/lib/event_usability.c
new file mode 100644
index 0000000..f53168d
--- /dev/null
+++ b/src/lib/event_usability.c
@@ -0,0 +1,201 @@
+/*
+    Copyright (C) 2012  ABRT Team
+    Copyright (C) 2012  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 <errno.h>
+#include <stdlib.h>
+#include "internal_libreport.h"
+#include "event_usability.h"
+
+enum event_usability_status worst_usability(enum event_usability_status f, enum
event_usability_status s)
+{
+    return f > s ? f : s;
+}
+
+static enum event_usability_status check_btrating_usability(const event_config_t *cfg,
const char *rating_str, char **message)
+{
+    enum event_usability_status ret = EUS_GOOD;
+
+    if (rating_str)
+    {
+        char *endptr;
+        errno = 0;
+        long rating = strtol(rating_str, &endptr, 10);
+        char *issue = NULL;
+        if (errno != 0 || endptr == rating_str || *endptr != '\0')
+        {
+            issue = xasprintf("%s '%s'.", _("Reporting disabled
because the rating does not contain a number"), rating_str);
+            ret = EUS_UNUSABLE;
+        }
+        else if (rating == cfg->ec_minimal_rating) /* bt is usable, but not complete,
so show a warning */
+        {
+            issue = xstrdup(_("The backtrace is incomplete, please make sure you
provide the steps to reproduce."));
+            ret = EUS_LOW;
+        }
+        else if (rating < cfg->ec_minimal_rating)
+        {
+            issue = xstrdup(_("Reporting disabled because the backtrace is
unusable."));
+            ret = EUS_UNUSABLE;
+        }
+
+        if (message)
+            *message = issue;
+        else
+            free(issue);
+    }
+
+    return ret;
+}
+
+struct problem_item_source
+{
+    bool (* contain_item)(void *, const char *);
+    void *source;
+};
+
+static char *get_complement_as_comma_list(const struct problem_item_source *source, const
char *input_item_list)
+{
+    if (!input_item_list)
+        return NULL;
+
+    char *item_list = xstrdup(input_item_list);
+    char *result = item_list;
+    char *dst = item_list;
+
+    while (item_list[0])
+    {
+        char *end = strchr(item_list, ',');
+        if (end) *end = '\0';
+        if (!source->contain_item(source->source, item_list))
+        {
+            if (dst != result)
+                *dst++ = ',';
+            dst = stpcpy(dst, item_list);
+        }
+        if (!end)
+            break;
+        *end = ',';
+        item_list = end + 1;
+    }
+    if (result == dst)
+    {
+        free(result);
+        result = NULL;
+    }
+    return result;
+}
+
+static bool contain_item_in_problem_data(void *source, const char *item_name)
+{
+    problem_data_t *pd = (problem_data_t *)source;
+    return !!get_problem_item_content_or_NULL(pd, item_name);
+}
+
+static bool contain_item_in_glist(void *source, const char *item_name)
+{
+    GList *list = (GList *)source;
+    return !!g_list_find_custom(list, (gpointer)item_name, (GCompareFunc)strcmp);
+}
+
+enum event_usability_status check_event_usability(const event_config_t *cfg,
+                                                  const problem_data_t *pd,
+                                                  const GList *not_loaded_items,
+                                                  GList **issues,
+                                                  enum event_usability_status min_level
+                                                  )
+{
+        enum event_usability_status ret = EUS_GOOD;
+
+        if (!cfg)
+            return ret;
+
+        GList* work_issues = NULL;
+
+        struct problem_item_source pd_source;
+        pd_source.contain_item = contain_item_in_problem_data;
+        pd_source.source = (void *)pd;
+
+        struct problem_item_source list_source;
+        list_source.contain_item = contain_item_in_glist;
+        list_source.source = (void *)not_loaded_items;
+
+        /* find missing items */
+        char *existing_missing = get_complement_as_comma_list(&pd_source,
cfg->ec_requires_items);
+        char *created_missing = get_complement_as_comma_list(&list_source,
existing_missing);
+        if (created_missing)
+        {
+            if (worst_usability(EUS_UNUSABLE, min_level) == EUS_UNUSABLE)
+            {
+                ret = EUS_UNUSABLE;
+                work_issues = g_list_prepend(work_issues, xasprintf("%s : %s.",
_("Missing items "), created_missing));
+            }
+        }
+        free(existing_missing);
+        free(created_missing);
+
+#if 0
+        /* find already existing items */
+        if (cfg->ec_creates_items)
+        {
+            existing_missing = get_complement_as_comma_list(&pd_source,
cfg->ec_creates_items);
+            created_missing = get_complement_as_comma_list(&list_source,
existing_missing);
+            if (!created_missing)
+            {
+                if (worst_usability(EUS_LOW, min_level) == EUS_LOW)
+                {
+                    ret = worst_usability(EUS_LOW, ret);
+                    work_issues = g_list_prepend(work_issues, xasprintf("%s :
%s.", _("Items already exist "), cfg->ec_creates_items));
+                }
+            }
+            free(existing_missing);
+            free(created_missing);
+        }
+#endif
+
+        /* if a rating is in not loaded items we cannot assure */
+        /* that a rating is OK at a moment of event run */
+        const char *rating_str = get_problem_item_content_or_NULL((problem_data_t *)pd,
FILENAME_RATING);
+        if ((!rating_str || g_list_find_custom((GList *)not_loaded_items,
FILENAME_RATING, (GCompareFunc)strcmp)))
+        {
+            if (worst_usability(EUS_LOW, min_level) == EUS_LOW)
+            {
+                ret = worst_usability(EUS_LOW, ret);
+                work_issues = g_list_prepend(work_issues, xstrdup(_("Backtrace
rating can't be checked now and can be possibly low at a moment of event
run")));
+            }
+        }
+        else // btrating is in existing items
+        {
+            char *message = NULL;
+            enum event_usability_status bt = check_btrating_usability(cfg, rating_str,
&message);
+            if (worst_usability(bt, min_level) == bt)
+            {
+                ret = worst_usability(bt, ret);
+                if (message)
+                    work_issues = g_list_prepend(work_issues, message);
+            }
+            else
+                free(message);
+        }
+
+        if (issues)
+            *issues = work_issues;
+        else
+            g_list_free(work_issues);
+
+        return ret;
+}
+
-- 
1.7.10.2

[PATCH 4/7] track#554 : add API for runnig of lists of events

[Jakub Filak]

Signed-off-by: Jakub Filak <jfilak(a)redhat.com&gt;
---
 libreport.spec.in            |    1 +
 src/include/Makefile.am      |    3 +-
 src/include/run_event_list.h |  209 ++++++++++++++
 src/lib/Makefile.am          |    3 +-
 src/lib/run_event_list.c     |  618 ++++++++++++++++++++++++++++++++++++++++++
 5 files changed, 832 insertions(+), 2 deletions(-)
 create mode 100644 src/include/run_event_list.h
 create mode 100644 src/lib/run_event_list.c

diff --git a/libreport.spec.in b/libreport.spec.in
index 3f730e3..ea51431 100644
--- a/libreport.spec.in
+++ b/libreport.spec.in
@@ -297,6 +297,7 @@ gtk-update-icon-cache %{_datadir}/icons/hicolor &>/dev/null ||
:
 %{_includedir}/libreport/report.h
 %{_includedir}/libreport/run_event.h
 %{_includedir}/libreport/event_usability.h
+%{_includedir}/libreport/run_event_list.h
 # Private api headers:
 %{_includedir}/libreport/internal_abrt_dbus.h
 %{_includedir}/libreport/internal_libreport.h
diff --git a/src/include/Makefile.am b/src/include/Makefile.am
index 7aa5f78..bca63dd 100644
--- a/src/include/Makefile.am
+++ b/src/include/Makefile.am
@@ -10,4 +10,5 @@ libreport_include_HEADERS = \
     \
     internal_libreport.h \
     internal_abrt_dbus.h \
-    event_usability.h
+    event_usability.h \
+    run_event_list.h
diff --git a/src/include/run_event_list.h b/src/include/run_event_list.h
new file mode 100644
index 0000000..f5fa11f
--- /dev/null
+++ b/src/include/run_event_list.h
@@ -0,0 +1,209 @@
+/*
+    Copyright (C) 2012  ABRT team.
+    Copyright (C) 2012  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.
+*/
+#ifndef LIBREPORT_RUN_EVENT_LIST_H_
+#define LIBREPORT_RUN_EVENT_LIST_H_
+
+#include <glib.h>
+#include "run_event.h"
+#include "event_usability.h"
+
+/* Forward declartion */
+struct event_list_process;
+
+/*
+ * Return value from event list process signal.
+ * Signal handler returns these values in order to adjust process
+ * flow according to current state.
+ */
+enum elp_signal_ret
+{
+    ELPSR_CONTINUE,     ///< A process should continue with next step.
+    ELPSR_NEXT_EVENT,   ///< A process should skip all remaining steps a continue with
next event.
+    ELPSR_FINISH,       ///< A process should skip all remaining events and finis
itself.
+};
+
+/*
+ * Event list process signal function type
+ *
+ * @param process A process that emits a signal.
+ * @return A value that adjusts process flow.
+ */
+typedef enum elp_signal_ret (* elp_signal)(struct event_list_process *process);
+
+/*
+ * All signals used by event list process
+ */
+struct elp_signals_impl
+{
+    /*
+     * Next event was successfully selected and process is about to process it
+     */
+    elp_signal next_event_selected;
+
+    /*
+     * Currently selected event requires review.
+     */
+    elp_signal review_data;
+
+    /*
+     * Currently selected event is about to be run.
+     */
+    elp_signal run_event;
+
+    /*
+     * Currently selected event has finished.
+     */
+    elp_signal event_done;
+
+    /*
+     * No more events to be processed
+     */
+    elp_signal finished;
+
+    /*
+     * Event has some problem with configuration
+     */
+    elp_signal configuration_issue;
+};
+
+/*
+ * Types of event run result
+ */
+enum elp_event_run_status
+{
+    ELP_ERS_NONE,       ///< No run was performed
+    ELP_ERS_SUCCESSFUL, ///< Event finished successfully
+    ELP_ERS_FAILED,     ///< Event failed
+    ELP_ERS_NOT_FOUND,  ///< No processing was found
+};
+
+/*
+ * Structure holds an configuration issue info
+ */
+struct elp_configuration_issue
+{
+    const char *event_name;                 ///< Event with problems
+    enum event_usability_status usability;  ///< Event usability
+    const GList *issues;                    ///< All known configuration issues for an
event
+};
+
+/*
+ * Initializes event list process signal functions.
+ *
+ * @param impl A not NULL pointer to signals
+ */
+void event_list_process_impl_init(struct elp_signals_impl *impl);
+
+/*
+ * Creates an initializes an event list process
+ *
+ * @param events A list of events to be processed, do not take an ownership
+ * @param signals A signal implementation, do not take an ownership
+ * @param run_impl A call backs for event run, do not take an ownership
+ * @param run_obs An observer for event run, do not take an ownership
+ * @param dump_dir_name A dump dir name, do not take an ownership
+ * @param signal_args A custom data available by elp_get_signal_args()
+ * @return An initialized event list process, never returns NULL
+ */
+struct event_list_process *new_event_list_process(const GList *events,
+                                                  const struct elp_signals_impl *impl,
+                                                  const struct run_event_impl *run_impl,
+                                                  const struct run_event_observer
*run_obs,
+                                                  const char *dump_dir_name,
+                                                  void *signal_args);
+
+/*
+ * Frees all used memory by an event list process
+ *
+ * @param process A pointer to process
+ */
+void free_event_list_process(struct event_list_process *process);
+
+/*
+ * Gets an currently selected event.
+ *
+ * @param process A not NULL pointer to process
+ * @return A pointer to event name if some event was selected, otherwise returns NULL
+ */
+const char *elp_get_current_event(const struct event_list_process *process);
+
+/*
+ * Gets an currently selected event.
+ *
+ * @param process A not NULL pointer to process
+ * @return A data passed in new_event_list_process()
+ */
+void *elp_get_signal_args(const struct event_list_process *process);
+
+/*
+ * Gets the last event run result.
+ *
+ * @param process A not NULL pointer to process
+ * @return the last event run result.
+ */
+enum elp_event_run_status elp_get_last_event_status(const struct event_list_process
*process);
+
+/*
+ * Gets the last configuraton issue. This function must be called
+ * only from handler of configuration_issue signal.
+ *
+ * @param process A not NULL pointer to process
+ * @return the last configuration issue.
+ */
+const struct elp_configuration_issue *elp_get_last_configuration_issue(const struct
event_list_process *process);
+
+/*
+ * Sets a post run callback for run_event_state.
+ *
+ * The method is provided only for backward compatibility
+ *
+ * @param process A not NULL pointer to process
+ * @param post_run_callback A pointer to function
+ * @param post_run_param A custom data passed to callback
+ */
+void elp_set_post_run_callback(struct event_list_process *process, res_post_run_callback
post_run_callback, void *post_run_param);
+
+/*
+ * Sets a logging callback for run_event_state.
+ *
+ * The method is provided only for backward compatibility
+ *
+ * @param process A not NULL pointer to process
+ * @param loggin_callback A pointer to function
+ * @param loggin_param A custom data passed to callback
+ */
+void elp_set_logging_callback(struct event_list_process *process, res_logging_callback
logging_callback, void *logging_param);
+
+/*
+ * Forces a process to perform next step.
+ *
+ * @param process A not NULL pointer to process
+ * @return 0 if last step was performed; otherwise returns non 0
+ */
+int elp_next_step(struct event_list_process *process);
+
+/*
+ * Kills an event command process
+ *
+ * @param process A not NULL pointer to process
+ */
+void elp_kill_run(struct event_list_process *process);
+
+#endif /* LIBREPORT_RUN_EVENT_LIST_H_ */
+
diff --git a/src/lib/Makefile.am b/src/lib/Makefile.am
index cd1f164..fd406ce 100644
--- a/src/lib/Makefile.am
+++ b/src/lib/Makefile.am
@@ -48,7 +48,8 @@ libreport_la_SOURCES = \
     user_settings.c \
     client.c \
     utf8.c \
-    event_usability.c
+    event_usability.c \
+	run_event_list.c
 
 libreport_la_CPPFLAGS = \
     -Wall -Wwrite-strings -Werror \
diff --git a/src/lib/run_event_list.c b/src/lib/run_event_list.c
new file mode 100644
index 0000000..559772d
--- /dev/null
+++ b/src/lib/run_event_list.c
@@ -0,0 +1,618 @@
+/*
+    Copyright (C) 2012  ABRT Team
+    Copyright (C) 2012  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 <pthread.h>
+#include <glob.h>
+#include <regex.h>
+#include "run_event.h"
+#include "run_event_list.h"
+#include "event_usability.h"
+#include "internal_libreport.h"
+
+enum elp_process_states
+{
+    __MIN_PROC_STATE__ = 0,
+
+    ELP_INIT = __MIN_PROC_STATE__,
+    ELP_START,
+    ELP_REVIEW_DATA,
+    ELP_RUN_EVENT,
+    ELP_END,
+
+    __MAX_PROC_STATE__ = ELP_END,
+};
+
+struct event_list_process
+{
+    const struct elp_signals_impl *impl;
+    const struct run_event_impl *run_impl;
+    const struct run_event_observer *run_obs;
+    const char *dump_dir_name;
+    void *args;
+
+    enum elp_process_states current;
+    const GList *events;
+    GList *internal_events;
+    GList *next;
+    GList *processed;
+
+    struct run_event_state *run_state;
+
+    res_post_run_callback post_run_callback;
+    void *post_run_param;
+    res_logging_callback logging_callback;
+    void *logging_param;
+
+    pthread_mutex_t run_mut;
+    enum elp_event_run_status last_run;
+
+    struct elp_configuration_issue last_configuration_issue;
+};
+
+void event_list_process_impl_init(struct elp_signals_impl *impl)
+{
+    memset(impl, 0, sizeof(*impl));
+}
+
+struct event_list_process *new_event_list_process(const GList *events,
+                                                  const struct elp_signals_impl *impl,
+                                                  const struct run_event_impl *run_impl,
+                                                  const struct run_event_observer
*run_obs,
+                                                  const char *dump_dir_name,
+                                                  void *signal_args)
+{
+    assert(impl || !"NULL argument");
+    assert(run_impl || !"NULL argument");
+
+    struct event_list_process *process = xmalloc(sizeof(*process));
+
+    process->impl = impl;
+    process->run_impl = run_impl;
+    process->run_obs = run_obs;
+    process->dump_dir_name = dump_dir_name;
+    process->args = signal_args;
+    process->current = __MIN_PROC_STATE__;
+    process->events = events;
+    process->next = NULL;
+    process->internal_events = NULL;
+    process->processed = NULL;
+    process->run_state = NULL;
+
+    pthread_mutex_init(&(process->run_mut), NULL);
+
+    process->last_run = ELP_ERS_NONE;
+
+    process->post_run_callback = NULL;
+    process->post_run_param = NULL;
+    process->logging_callback = NULL;
+    process->logging_param = NULL;
+
+    return process;
+}
+
+void free_event_list_process(struct event_list_process *process)
+{
+    assert(process || !"NULL argument");
+
+    g_list_free(process->internal_events);
+
+    pthread_mutex_destroy(&(process->run_mut));
+
+    free(process);
+}
+
+const char* elp_get_current_event(const struct event_list_process *process)
+{
+    assert(process || !"NULL argument");
+
+    return process->processed ? process->processed->data : NULL;
+}
+
+void *elp_get_signal_args(const struct event_list_process *process)
+{
+    assert(process || !"NULL argument");
+
+    return process->args;
+}
+
+enum elp_event_run_status elp_get_last_event_status(const struct event_list_process
*process)
+{
+    assert(process || !"NULL argument");
+
+    return process->last_run;
+}
+
+void elp_kill_run(struct event_list_process *process)
+{
+    assert(process || !"NULL argument");
+
+    pthread_mutex_lock(&(process->run_mut));
+
+    if (process->run_state)
+        run_event_state_kill_command(process->run_state);
+
+    pthread_mutex_unlock(&(process->run_mut));
+}
+
+void elp_set_post_run_callback(struct event_list_process *process,
+                               res_post_run_callback post_run_callback,
+                               void *post_run_param)
+{
+    assert(process || !"NULL argument");
+
+    pthread_mutex_lock(&(process->run_mut));
+
+    process->post_run_callback = post_run_callback;
+    process->post_run_param = post_run_param;
+
+    pthread_mutex_unlock(&(process->run_mut));
+}
+
+void elp_set_logging_callback(struct event_list_process *process,
+                              res_logging_callback logging_callback,
+                              void *logging_param)
+{
+    assert(process || !"NULL argument");
+
+    pthread_mutex_lock(&(process->run_mut));
+
+    process->logging_callback = logging_callback;
+    process->logging_param = logging_param;
+
+    pthread_mutex_unlock(&(process->run_mut));
+}
+
+const struct elp_configuration_issue *elp_get_last_configuration_issue(const struct
event_list_process *process)
+{
+    return &(process->last_configuration_issue);
+}
+
+static const struct run_event_impl *elp_get_run_impl(struct event_list_process *process)
+{
+    assert(process || !"NULL argument");
+
+    return process->run_impl;
+}
+
+static const struct run_event_observer *elp_get_run_obs(struct event_list_process
*process)
+{
+    assert(process || !"NULL argument");
+
+    return process->run_obs;
+}
+
+static problem_data_t *elp_create_problem_data(const struct event_list_process *process)
+{
+
+    struct dump_dir *dd = dd_opendir(process->dump_dir_name, 0);
+    if (!dd)
+        return NULL;
+
+    problem_data_t *pd = create_problem_data_from_dump_dir(dd);
+    dd_close(dd);
+
+    return pd;
+}
+
+static bool elp_do_need_review(const struct event_list_process *process, const char
*event_name)
+{
+    const event_config_t *const cfg = get_event_config(event_name);
+    if (cfg && !cfg->ec_skip_review)
+        return true;
+
+    problem_data_t *const pd = elp_create_problem_data(process);
+    if (pd)
+        return check_event_usability(cfg, pd, NULL, NULL, EUS_LOW) != EUS_GOOD;
+
+    return true;
+}
+
+static void elp_set_last_configuration_issues(struct event_list_process *process,
+                                              const char *event_name,
+                                              enum event_usability_status status,
+                                              const GList *issues)
+{
+    pthread_mutex_lock(&(process->run_mut));
+
+    process->last_configuration_issue.event_name = event_name;
+    process->last_configuration_issue.usability = status;
+    process->last_configuration_issue.issues = issues;
+
+    pthread_mutex_unlock(&(process->run_mut));
+}
+
+static enum elp_signal_ret elp_event_configuration_issue(struct event_list_process
*process,
+                                                         const char *event_name,
+                                                         enum event_usability_status
status,
+                                                         const GList *issues)
+{
+    enum elp_signal_ret ret = ELPSR_FINISH;
+
+    if (process->impl->configuration_issue)
+    {
+        elp_set_last_configuration_issues(process, event_name, status, issues);
+
+        ret = process->impl->configuration_issue(process);
+
+        elp_set_last_configuration_issues(process, NULL, EUS_GOOD, NULL);
+    }
+
+    return ret;
+}
+
+typedef enum event_usability_status (*validator_fn)(const event_config_t *, const 
problem_data_t *,
+                                                    const GList *, GList **, enum
event_usability_status);
+
+static enum elp_signal_ret elp_validate_event_config(struct event_list_process *process,
+                                                     const event_config_t *cfg,
+                                                     const char *event_name,
+                                                     const problem_data_t *pd,
+                                                     const GList *not_loaded_items,
+                                                     enum event_usability_status
min_level,
+                                                     validator_fn *validators)
+{
+    enum elp_signal_ret resp = ELPSR_CONTINUE;
+
+    if (!cfg)
+        return resp;
+
+    enum event_usability_status status = EUS_GOOD;
+    validator_fn *validator = validators;
+    GList* issues = NULL;
+    while(*validator)
+    {
+        status = worst_usability(status, (*validator)(cfg, pd, not_loaded_items,
&issues, min_level));
+        ++validator;
+    }
+
+    if (status == EUS_UNUSABLE)
+    {
+        resp = elp_event_configuration_issue(process, event_name, status, issues);
+        g_list_free_full(issues, (GDestroyNotify)free);
+
+        if (resp == ELPSR_CONTINUE)
+            error_msg_and_die("Cannot continue with unusable event
'%s'", event_name);
+    }
+
+    return resp;
+}
+
+static enum elp_signal_ret elp_validate_event(struct event_list_process *process,
+                                              const char *event_name,
+                                              const problem_data_t *pd,
+                                              const GList *not_loaded_items,
+                                              enum event_usability_status min_level,
+                                              validator_fn *validators)
+{
+    return elp_validate_event_config(process, get_event_config(event_name), event_name,
pd,
+                                     not_loaded_items, min_level, validators);
+}
+
+static const GList* elp_select_next_event(struct event_list_process *process, const GList
**event_list, const GList *not_loaded_items, enum elp_signal_ret *ret)
+{
+    assert(process || !"NULL argument");
+    assert(event_list || !"NULL argument");
+
+    static validator_fn validators[] = {
+        check_event_usability,
+        NULL,
+    };
+
+    const GList *tmp;
+    tmp = *event_list;
+    *event_list = g_list_next(tmp);
+
+    problem_data_t *pd = elp_create_problem_data(process);
+    if (!pd)
+        return tmp;
+
+    while(tmp)
+    {
+        const enum elp_signal_ret resp = elp_validate_event(process, tmp->data, pd,
+                                                            not_loaded_items,
EUS_UNUSABLE, validators);
+
+        if (ret)
+            *ret = resp;
+
+        if (resp == ELPSR_CONTINUE)
+            break;
+        else if (resp == ELPSR_FINISH)
+        {
+            tmp = *event_list = NULL;
+            break;
+        }
+        else if (resp != ELPSR_NEXT_EVENT)
+        {
+            assert(!"unexpected return value");
+        }
+
+        tmp = *event_list;
+        *event_list = g_list_next(tmp);
+    }
+
+    free_problem_data(pd);
+    return tmp;
+}
+
+static GList* elp_revise_event_list(struct event_list_process *process, const GList
*event_list)
+{
+    GList *revised_list = NULL;
+    GList *created_items = NULL;
+    enum elp_signal_ret ret;
+
+    const GList *event;
+    while ((event = elp_select_next_event(process, &event_list, created_items,
&ret)))
+    {
+        const event_config_t *const cfg = get_event_config(event->data);
+        if (cfg && cfg->ec_creates_items)
+        {
+            /* have to create a copy because of threads */
+            /* TODO : find a better place for following lines */
+            char *item_list = xstrdup(cfg->ec_creates_items);
+            char *bck = item_list;
+            while (item_list[0])
+            {
+                char *end = strchr(item_list, ',');
+                if (end) *end = '\0';
+                created_items = g_list_prepend(created_items, xstrdup(item_list));
+                if (!end)
+                    break;
+                item_list = end + 1;
+            }
+            free(bck);
+        }
+
+        revised_list = g_list_prepend(revised_list, event->data);
+    }
+
+    g_list_free_full(created_items, (GDestroyNotify)free);
+
+    if (ret != ELPSR_FINISH)
+        return g_list_reverse(revised_list);
+
+    g_list_free(revised_list);
+    return NULL;
+}
+
+static GList *elp_next_event(struct event_list_process *process)
+{
+    assert(process || !"NULL argument");
+
+    return (GList *)elp_select_next_event(process, (const GList **)&process->next,
NULL, NULL);
+}
+
+static bool event_list_process_call(struct event_list_process *process,
+                                    elp_signal cb,
+                                    enum elp_process_states ok_state,
+                                    enum elp_signal_ret default_ret)
+{
+    assert(process || !"NULL argument");
+    assert((ok_state >= __MIN_PROC_STATE__ && ok_state <=
__MAX_PROC_STATE__) || !"out of range argument");
+
+    const enum elp_signal_ret ret = cb ? cb(process) : default_ret;
+
+    switch (ret)
+    {
+        case ELPSR_CONTINUE:
+            process->current = ok_state;
+            break;
+        case ELPSR_NEXT_EVENT:
+            process->current = ELP_START;
+            break;
+        case ELPSR_FINISH:
+            process->current = ELP_END;
+            break;
+        default:
+            assert(!"unexpected signal return value");
+            error_msg_and_die("unexpected signal return value %d", ret);
+            break;
+    }
+
+    return ret == ELPSR_CONTINUE;
+}
+
+struct process_run_event_watcher
+{
+    const struct run_event_observer *wrapped_obs;
+    bool failed;
+    bool stopper;
+};
+
+static void process_command_started(pid_t pid, void *args)
+{
+    struct process_run_event_watcher *pre = (struct process_run_event_watcher *)args;
+
+    if (pre->wrapped_obs && pre->wrapped_obs->command_started)
+        pre->wrapped_obs->command_started(pid, pre->wrapped_obs->args);
+}
+
+static void process_command_msg_processed(const char *msg, const char *raw_input, const
char *rsp, void *args)
+{
+    struct process_run_event_watcher *pre = (struct process_run_event_watcher *)args;
+
+    /* TODO : should I move it to client.h ? */
+    if (!pre->stopper)
+        pre->stopper = !strncmp(msg, "THANK_YOU",
sizeof("THANK_YOU") -1);
+
+    if (pre->wrapped_obs && pre->wrapped_obs->command_msg_processed)
+        pre->wrapped_obs->command_msg_processed(msg, raw_input, rsp,
pre->wrapped_obs->args);
+}
+
+static void process_command_finished(int retval, int status, const char *err_msg, void
*args)
+{
+    struct process_run_event_watcher *pre = (struct process_run_event_watcher *)args;
+
+    pre->failed = retval != 0;
+
+    if (pre->wrapped_obs && pre->wrapped_obs->command_finished)
+        pre->wrapped_obs->command_finished(retval, status, err_msg,
pre->wrapped_obs->args);
+}
+
+int elp_next_step(struct event_list_process *process)
+{
+    /* before process start, revise event list and remove not configured and */
+    /* unusable events */
+    if (process->current == ELP_INIT)
+    {
+        process->current = ELP_START;
+
+        /* create internal event list from origin event list */
+        /* it is a copy of original list without unusable events */
+        process->internal_events = process->next = elp_revise_event_list(process,
process->events);
+    }
+
+    /* Process all event from list until reaches event that needs review, event run
failure */
+    /* or the end of the event list */
+    while (1)
+    {
+        if (process->current == ELP_START)
+        {
+            /* selects next event from internal list */
+            process->processed = elp_next_event(process);
+
+            if (!process->processed)
+            {   /* Event list is empty now */
+                process->current = ELP_END;
+            }
+            else
+            {
+                /* If callback next_event_selected is not set the process expects that
*/
+                /* there is no problem to continue thus default response is CONTINUE */
+                /* It callback returns a positive response process state is set to START
*/
+                if (!event_list_process_call(process,
process->impl->next_event_selected, ELP_START, ELPSR_CONTINUE))
+                    return true;
+
+                if (elp_do_need_review(process, elp_get_current_event(process)))
+                    process->current = ELP_REVIEW_DATA;
+                else
+                    process->current = ELP_RUN_EVENT;
+            }
+
+            /* return is not here because we want to continue with next state */
+            /* use case : next_step with start state causes beginning to review */
+            /*            or immediate run of event commands */
+        }
+
+        if (process->current == ELP_REVIEW_DATA)
+        {
+            /* review_data signal has high priority thus if call back is not set, */
+            /* then we expect that data are not reviewed and event is skipped */
+
+            /* return pauses the processing of events because process has to wait on next
*/
+            /* step signaling that review is finished, thus return if positive answer */
+            /* was returned from review_data callback */
+
+            /* if negative answer was returned we want to select next event immediately
*/
+            /* or finish the process */
+            if(event_list_process_call(process, process->impl->review_data,
ELP_RUN_EVENT, ELPSR_NEXT_EVENT))
+                return true;
+        }
+
+        if (process->current == ELP_RUN_EVENT)
+        {
+            /* If callback run_event is not set the process expects that */
+            /* there is no problem to continue thus default response is CONTINUE */
+
+            /* if negative answer was returned we want to select next event immediately
*/
+            /* or finish the process */
+            if (!event_list_process_call(process, process->impl->run_event,
ELP_RUN_EVENT, ELPSR_CONTINUE))
+                return true;
+
+            const char *event_name = elp_get_current_event(process);
+
+            struct process_run_event_watcher process_watcher = {
+                .failed = false,
+                .stopper = false,
+            };
+
+            process_watcher.wrapped_obs = elp_get_run_obs(process);
+
+            struct run_event_observer process_obs = {
+                .command_started = process_command_started,
+                .command_msg_processed = process_command_msg_processed,
+                .command_finished = process_command_finished,
+            };
+
+            process_obs.args = &process_watcher;
+
+            const char *dump_dir_name = process->dump_dir_name;
+
+            pthread_mutex_lock(&(process->run_mut));
+
+            struct run_event_state *run_state = new_run_event_state();
+            process->run_state = run_state;
+            run_state->post_run_callback = process->post_run_callback;
+            run_state->post_run_param = process->post_run_param;
+            run_state->logging_callback = process->logging_callback;
+            run_state->logging_param = process->logging_param;
+
+            pthread_mutex_unlock(&(process->run_mut));
+
+            prepare_commands(run_state, dump_dir_name, event_name);
+            run_event_state_on_dir_name(run_state, dump_dir_name, event_name,
+                                        elp_get_run_impl(process), &process_obs);
+
+            /* take care about stopper occurrence only if event was successful */
+            /* thus default value is not stopper occurrence */
+            bool stopper = false;
+
+            process->last_run = ELP_ERS_FAILED;
+            if (!process_watcher.failed)
+            {
+                if (run_state->children_count == 0)
+                {
+                    process->last_run = ELP_ERS_NOT_FOUND;
+
+                    /* run_event do not provide any callback for not event found
notification */
+                    /* and no event is considered as fail thus setting failed var to TRUE
*/
+                    process_watcher.failed = true;
+                }
+                else
+                {
+                    process->last_run = ELP_ERS_SUCCESSFUL;
+                    stopper = process_watcher.stopper;
+                }
+            }
+
+            /* stopper means that event decided to stop all further processing the */
+            /* thus successful state is ELP_END and default response is ELPSR_FINISH */
+            event_list_process_call(process, process->impl->event_done,
+                                    stopper ? ELP_END : ELP_START,
+                                    stopper ? ELPSR_FINISH : ELPSR_CONTINUE);
+
+            pthread_mutex_lock(&(process->run_mut));
+            free_run_event_state(run_state);
+            process->run_state = NULL;
+            pthread_mutex_unlock(&(process->run_mut));
+
+            /* do not forward to next step if event failed */
+            if (process_watcher.failed)
+                return true;
+        }
+
+        if (process->current == ELP_END)
+        {
+            /* Don't care about result, result can't change anything */
+            event_list_process_call(process, process->impl->finished, ELP_END,
ELPSR_FINISH);
+            return false;
+        }
+    }
+
+    assert(!"cannot get here");
+    return false;
+}
-- 
1.7.10.2

[PATCH 4/7] track#554 : add API for runnig of lists of events

[Denys Vlasenko]

On 06/26/2012 10:37 AM, Jakub Filak wrote:
>  Signed-off-by: Jakub Filak<jfilak(a)redhat.com>
>  ---
>    libreport.spec.in            |    1 +
>    src/include/Makefile.am      |    3 +-
>    src/include/run_event_list.h |  209 ++++++++++++++
>    src/lib/Makefile.am          |    3 +-
>    src/lib/run_event_list.c     |  618 ++++++++++++++++++++++++++++++++++++++++++
>    5 files changed, 832 insertions(+), 2 deletions(-)
>    create mode 100644 src/include/run_event_list.h
>    create mode 100644 src/lib/run_event_list.c
>
>  diff --git a/libreport.spec.in b/libreport.spec.in
>  index 3f730e3..ea51431 100644
>  --- a/libreport.spec.in
>  +++ b/libreport.spec.in
>  @@ -297,6 +297,7 @@ gtk-update-icon-cache %{_datadir}/icons/hicolor&>/dev/null ||
> :
>    %{_includedir}/libreport/report.h
>    %{_includedir}/libreport/run_event.h
>    %{_includedir}/libreport/event_usability.h
>  +%{_includedir}/libreport/run_event_list.h
>    # Private api headers:
>    %{_includedir}/libreport/internal_abrt_dbus.h
>    %{_includedir}/libreport/internal_libreport.h
>  diff --git a/src/include/Makefile.am b/src/include/Makefile.am
>  index 7aa5f78..bca63dd 100644
>  --- a/src/include/Makefile.am
>  +++ b/src/include/Makefile.am
>  @@ -10,4 +10,5 @@ libreport_include_HEADERS = \
>        \
>        internal_libreport.h \
>        internal_abrt_dbus.h \
>  -    event_usability.h
>  +    event_usability.h \
>  +    run_event_list.h
>  diff --git a/src/include/run_event_list.h b/src/include/run_event_list.h
>  new file mode 100644
>  index 0000000..f5fa11f
>  --- /dev/null
>  +++ b/src/include/run_event_list.h
>  @@ -0,0 +1,209 @@
>  +/*
>  +    Copyright (C) 2012  ABRT team.
>  +    Copyright (C) 2012  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.
>  +*/
>  +#ifndef LIBREPORT_RUN_EVENT_LIST_H_
>  +#define LIBREPORT_RUN_EVENT_LIST_H_
>  +
>  +#include<glib.h>
>  +#include "run_event.h"
>  +#include "event_usability.h"
>  +
>  +/* Forward declartion */
>  +struct event_list_process;
>  +
>  +/*
>  + * Return value from event list process signal.
>  + * Signal handler returns these values in order to adjust process
>  + * flow according to current state.
>  + */
>  +enum elp_signal_ret
>  +{
>  +    ELPSR_CONTINUE,     ///<  A process should continue with next step.
>  +    ELPSR_NEXT_EVENT,   ///<  A process should skip all remaining steps a continue
> with next event.
>  +    ELPSR_FINISH,       ///<  A process should skip all remaining events and finis
> itself.
>  +}; 
What is elp[sr]?


>  +/*
>  + * Event list process signal function type 
This does not make sense to me.

>  + *
>  + * @param process A process that emits a signal.
>  + * @return A value that adjusts process flow.
>  + */
>  +typedef enum elp_signal_ret (* elp_signal)(struct event_list_process *process);
>  +
>  +/*
>  + * All signals used by event list process
>  + */
>  +struct elp_signals_impl
>  +{
>  +    /*
>  +     * Next event was successfully selected and process is about to process it
>  +     */
>  +    elp_signal next_event_selected;
>  +
>  +    /*
>  +     * Currently selected event requires review.
>  +     */
>  +    elp_signal review_data;
>  +
>  +    /*
>  +     * Currently selected event is about to be run.
>  +     */
>  +    elp_signal run_event;
>  +
>  +    /*
>  +     * Currently selected event has finished.
>  +     */
>  +    elp_signal event_done;
>  +
>  +    /*
>  +     * No more events to be processed
>  +     */
>  +    elp_signal finished;
>  +
>  +    /*
>  +     * Event has some problem with configuration
>  +     */
>  +    elp_signal configuration_issue;
>  +}; 
This looks like a TON of added complexity for no apparent reason.

For starters, what problem are you solving?



>  +/*
>  + * Types of event run result
>  + */
>  +enum elp_event_run_status
>  +{
>  +    ELP_ERS_NONE,       ///<  No run was performed
>  +    ELP_ERS_SUCCESSFUL, ///<  Event finished successfully
>  +    ELP_ERS_FAILED,     ///<  Event failed
>  +    ELP_ERS_NOT_FOUND,  ///<  No processing was found
>  +}; 
ELP ERS?


>  +/*
>  + * Structure holds an configuration issue info
>  + */
>  +struct elp_configuration_issue
>  +{
>  +    const char *event_name;                 ///<  Event with problems
>  +    enum event_usability_status usability;  ///<  Event usability
>  +    const GList *issues;                    ///<  All known configuration issues for
> an event
>  +};
>  +
>  +/*
>  + * Initializes event list process signal functions.
>  + *
>  + * @param impl A not NULL pointer to signals
>  + */
>  +void event_list_process_impl_init(struct elp_signals_impl *impl); 
I am totally lost by now. What are we doing here?


>  +/*
>  + * Creates an initializes an event list process
>  + *
>  + * @param events A list of events to be processed, do not take an ownership
>  + * @param signals A signal implementation, do not take an ownership
>  + * @param run_impl A call backs for event run, do not take an ownership
>  + * @param run_obs An observer for event run, do not take an ownership
>  + * @param dump_dir_name A dump dir name, do not take an ownership
>  + * @param signal_args A custom data available by elp_get_signal_args()
>  + * @return An initialized event list process, never returns NULL
>  + */
>  +struct event_list_process *new_event_list_process(const GList *events,
>  +                                                  const struct elp_signals_impl *impl,
>  +                                                  const struct run_event_impl
> *run_impl,
>  +                                                  const struct run_event_observer
> *run_obs,
>  +                                                  const char *dump_dir_name,
>  +                                                  void *signal_args);
>  +
>  +/*
>  + * Frees all used memory by an event list process
>  + *
>  + * @param process A pointer to process
>  + */
>  +void free_event_list_process(struct event_list_process *process);
>  +
>  +/*
>  + * Gets an currently selected event.
>  + *
>  + * @param process A not NULL pointer to process
>  + * @return A pointer to event name if some event was selected, otherwise returns NULL
>  + */
>  +const char *elp_get_current_event(const struct event_list_process *process);
>  +
>  +/*
>  + * Gets an currently selected event.
>  + *
>  + * @param process A not NULL pointer to process
>  + * @return A data passed in new_event_list_process()
>  + */
>  +void *elp_get_signal_args(const struct event_list_process *process);
>  +
>  +/*
>  + * Gets the last event run result.
>  + *
>  + * @param process A not NULL pointer to process
>  + * @return the last event run result.
>  + */
>  +enum elp_event_run_status elp_get_last_event_status(const struct event_list_process
> *process);
>  +
>  +/*
>  + * Gets the last configuraton issue. This function must be called
>  + * only from handler of configuration_issue signal.
>  + *
>  + * @param process A not NULL pointer to process
>  + * @return the last configuration issue.
>  + */
>  +const struct elp_configuration_issue *elp_get_last_configuration_issue(const struct
> event_list_process *process);
>  +
>  +/*
>  + * Sets a post run callback for run_event_state.
>  + *
>  + * The method is provided only for backward compatibility
>  + *
>  + * @param process A not NULL pointer to process
>  + * @param post_run_callback A pointer to function
>  + * @param post_run_param A custom data passed to callback
>  + */
>  +void elp_set_post_run_callback(struct event_list_process *process, res_post_run_callback
> post_run_callback, void *post_run_param);
>  +
>  +/*
>  + * Sets a logging callback for run_event_state.
>  + *
>  + * The method is provided only for backward compatibility
>  + *
>  + * @param process A not NULL pointer to process
>  + * @param loggin_callback A pointer to function
>  + * @param loggin_param A custom data passed to callback
>  + */
>  +void elp_set_logging_callback(struct event_list_process *process, res_logging_callback
> logging_callback, void *logging_param);
>  +
>  +/*
>  + * Forces a process to perform next step.
>  + *
>  + * @param process A not NULL pointer to process
>  + * @return 0 if last step was performed; otherwise returns non 0
>  + */
>  +int elp_next_step(struct event_list_process *process);
>  +
>  +/*
>  + * Kills an event command process
>  + *
>  + * @param process A not NULL pointer to process
>  + */
>  +void elp_kill_run(struct event_list_process *process);
>  +
>  +#endif /* LIBREPORT_RUN_EVENT_LIST_H_ */
>  +
>  diff --git a/src/lib/Makefile.am b/src/lib/Makefile.am
>  index cd1f164..fd406ce 100644
>  --- a/src/lib/Makefile.am
>  +++ b/src/lib/Makefile.am
>  @@ -48,7 +48,8 @@ libreport_la_SOURCES = \
>        user_settings.c \
>        client.c \
>        utf8.c \
>  -    event_usability.c
>  +    event_usability.c \
>  +	run_event_list.c
>
>    libreport_la_CPPFLAGS = \
>        -Wall -Wwrite-strings -Werror \
>  diff --git a/src/lib/run_event_list.c b/src/lib/run_event_list.c
>  new file mode 100644
>  index 0000000..559772d
>  --- /dev/null
>  +++ b/src/lib/run_event_list.c
>  @@ -0,0 +1,618 @@
>  +/*
>  +    Copyright (C) 2012  ABRT Team
>  +    Copyright (C) 2012  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<pthread.h>
>  +#include<glob.h>
>  +#include<regex.h>
>  +#include "run_event.h"
>  +#include "run_event_list.h"
>  +#include "event_usability.h"
>  +#include "internal_libreport.h"
>  +
>  +enum elp_process_states
>  +{
>  +    __MIN_PROC_STATE__ = 0, 
__names are reserved for compiler / libc.


>  +
>  +    ELP_INIT = __MIN_PROC_STATE__,
>  +    ELP_START,
>  +    ELP_REVIEW_DATA,
>  +    ELP_RUN_EVENT,
>  +    ELP_END,
>  +
>  +    __MAX_PROC_STATE__ = ELP_END,
>  +};
>  +
>  +struct event_list_process
>  +{
>  +    const struct elp_signals_impl *impl;
>  +    const struct run_event_impl *run_impl;
>  +    const struct run_event_observer *run_obs;
>  +    const char *dump_dir_name;
>  +    void *args;
>  +
>  +    enum elp_process_states current;
>  +    const GList *events;
>  +    GList *internal_events;
>  +    GList *next;
>  +    GList *processed;
>  +
>  +    struct run_event_state *run_state;
>  +
>  +    res_post_run_callback post_run_callback;
>  +    void *post_run_param;
>  +    res_logging_callback logging_callback;
>  +    void *logging_param;
>  +
>  +    pthread_mutex_t run_mut;
>  +    enum elp_event_run_status last_run;
>  +
>  +    struct elp_configuration_issue last_configuration_issue;
>  +};
>  +
>  +void event_list_process_impl_init(struct elp_signals_impl *impl)
>  +{
>  +    memset(impl, 0, sizeof(*impl));
>  +}
>  +
>  +struct event_list_process *new_event_list_process(const GList *events,
>  +                                                  const struct elp_signals_impl *impl,
>  +                                                  const struct run_event_impl
> *run_impl,
>  +                                                  const struct run_event_observer
> *run_obs,
>  +                                                  const char *dump_dir_name,
>  +                                                  void *signal_args)
>  +{
>  +    assert(impl || !"NULL argument");
>  +    assert(run_impl || !"NULL argument");
>  +
>  +    struct event_list_process *process = xmalloc(sizeof(*process));
>  +
>  +    process->impl = impl;
>  +    process->run_impl = run_impl;
>  +    process->run_obs = run_obs;
>  +    process->dump_dir_name = dump_dir_name;
>  +    process->args = signal_args;
>  +    process->current = __MIN_PROC_STATE__;
>  +    process->events = events;
>  +    process->next = NULL;
>  +    process->internal_events = NULL;
>  +    process->processed = NULL;
>  +    process->run_state = NULL;
>  +
>  +    pthread_mutex_init(&(process->run_mut), NULL);
>  +
>  +    process->last_run = ELP_ERS_NONE;
>  +
>  +    process->post_run_callback = NULL;
>  +    process->post_run_param = NULL;
>  +    process->logging_callback = NULL;
>  +    process->logging_param = NULL;
>  +
>  +    return process;
>  +}
>  +
>  +void free_event_list_process(struct event_list_process *process)
>  +{
>  +    assert(process || !"NULL argument");
>  +
>  +    g_list_free(process->internal_events);
>  +
>  +    pthread_mutex_destroy(&(process->run_mut));
>  +
>  +    free(process);
>  +}
>  +
>  +const char* elp_get_current_event(const struct event_list_process *process)
>  +{
>  +    assert(process || !"NULL argument");
>  +
>  +    return process->processed ? process->processed->data : NULL;
>  +}
>  +
>  +void *elp_get_signal_args(const struct event_list_process *process)
>  +{
>  +    assert(process || !"NULL argument");
>  +
>  +    return process->args;
>  +}
>  +
>  +enum elp_event_run_status elp_get_last_event_status(const struct event_list_process
> *process)
>  +{
>  +    assert(process || !"NULL argument");
>  +
>  +    return process->last_run;
>  +}
>  +
>  +void elp_kill_run(struct event_list_process *process)
>  +{
>  +    assert(process || !"NULL argument");
>  +
>  +    pthread_mutex_lock(&(process->run_mut));
>  +
>  +    if (process->run_state)
>  +        run_event_state_kill_command(process->run_state);
>  +
>  +    pthread_mutex_unlock(&(process->run_mut));
>  +}
>  +
>  +void elp_set_post_run_callback(struct event_list_process *process,
>  +                               res_post_run_callback post_run_callback,
>  +                               void *post_run_param)
>  +{
>  +    assert(process || !"NULL argument");
>  +
>  +    pthread_mutex_lock(&(process->run_mut));
>  +
>  +    process->post_run_callback = post_run_callback;
>  +    process->post_run_param = post_run_param;
>  +
>  +    pthread_mutex_unlock(&(process->run_mut));
>  +}
>  +
>  +void elp_set_logging_callback(struct event_list_process *process,
>  +                              res_logging_callback logging_callback,
>  +                              void *logging_param)
>  +{
>  +    assert(process || !"NULL argument");
>  +
>  +    pthread_mutex_lock(&(process->run_mut));
>  +
>  +    process->logging_callback = logging_callback;
>  +    process->logging_param = logging_param;
>  +
>  +    pthread_mutex_unlock(&(process->run_mut));
>  +}
>  +
>  +const struct elp_configuration_issue *elp_get_last_configuration_issue(const struct
> event_list_process *process)
>  +{
>  +    return&(process->last_configuration_issue);
>  +}
>  +
>  +static const struct run_event_impl *elp_get_run_impl(struct event_list_process
> *process)
>  +{
>  +    assert(process || !"NULL argument");
>  +
>  +    return process->run_impl;
>  +}
>  +
>  +static const struct run_event_observer *elp_get_run_obs(struct event_list_process
> *process)
>  +{
>  +    assert(process || !"NULL argument");
>  +
>  +    return process->run_obs;
>  +}
>  +
>  +static problem_data_t *elp_create_problem_data(const struct event_list_process
> *process)
>  +{
>  +
>  +    struct dump_dir *dd = dd_opendir(process->dump_dir_name, 0);
>  +    if (!dd)
>  +        return NULL;
>  +
>  +    problem_data_t *pd = create_problem_data_from_dump_dir(dd);
>  +    dd_close(dd);
>  +
>  +    return pd;
>  +}
>  +
>  +static bool elp_do_need_review(const struct event_list_process *process, const char
> *event_name)
>  +{
>  +    const event_config_t *const cfg = get_event_config(event_name);
>  +    if (cfg&&  !cfg->ec_skip_review)
>  +        return true;
>  +
>  +    problem_data_t *const pd = elp_create_problem_data(process);
>  +    if (pd)
>  +        return check_event_usability(cfg, pd, NULL, NULL, EUS_LOW) != EUS_GOOD;
>  +
>  +    return true;
>  +}
>  +
>  +static void elp_set_last_configuration_issues(struct event_list_process *process,
>  +                                              const char *event_name,
>  +                                              enum event_usability_status status,
>  +                                              const GList *issues)
>  +{
>  +    pthread_mutex_lock(&(process->run_mut));
>  +
>  +    process->last_configuration_issue.event_name = event_name;
>  +    process->last_configuration_issue.usability = status;
>  +    process->last_configuration_issue.issues = issues;
>  +
>  +    pthread_mutex_unlock(&(process->run_mut));
>  +}
>  +
>  +static enum elp_signal_ret elp_event_configuration_issue(struct event_list_process
> *process,
>  +                                                         const char *event_name,
>  +                                                         enum event_usability_status
> status,
>  +                                                         const GList *issues)
>  +{
>  +    enum elp_signal_ret ret = ELPSR_FINISH;
>  +
>  +    if (process->impl->configuration_issue)
>  +    {
>  +        elp_set_last_configuration_issues(process, event_name, status, issues);
>  +
>  +        ret = process->impl->configuration_issue(process);
>  +
>  +        elp_set_last_configuration_issues(process, NULL, EUS_GOOD, NULL);
>  +    }
>  +
>  +    return ret;
>  +}
>  +
>  +typedef enum event_usability_status (*validator_fn)(const event_config_t *, const 
> problem_data_t *,
>  +                                                    const GList *, GList **, enum
> event_usability_status);
>  +
>  +static enum elp_signal_ret elp_validate_event_config(struct event_list_process
> *process,
>  +                                                     const event_config_t *cfg,
>  +                                                     const char *event_name,
>  +                                                     const problem_data_t *pd,
>  +                                                     const GList *not_loaded_items,
>  +                                                     enum event_usability_status
> min_level,
>  +                                                     validator_fn *validators)
>  +{
>  +    enum elp_signal_ret resp = ELPSR_CONTINUE;
>  +
>  +    if (!cfg)
>  +        return resp;
>  +
>  +    enum event_usability_status status = EUS_GOOD;
>  +    validator_fn *validator = validators;
>  +    GList* issues = NULL;
>  +    while(*validator)
>  +    {
>  +        status = worst_usability(status, (*validator)(cfg, pd,
> not_loaded_items,&issues, min_level));
>  +        ++validator;
>  +    }
>  +
>  +    if (status == EUS_UNUSABLE)
>  +    {
>  +        resp = elp_event_configuration_issue(process, event_name, status, issues);
>  +        g_list_free_full(issues, (GDestroyNotify)free);
>  +
>  +        if (resp == ELPSR_CONTINUE)
>  +            error_msg_and_die("Cannot continue with unusable event
> '%s'", event_name);
>  +    }
>  +
>  +    return resp;
>  +}
>  +
>  +static enum elp_signal_ret elp_validate_event(struct event_list_process *process,
>  +                                              const char *event_name,
>  +                                              const problem_data_t *pd,
>  +                                              const GList *not_loaded_items,
>  +                                              enum event_usability_status min_level,
>  +                                              validator_fn *validators)
>  +{
>  +    return elp_validate_event_config(process, get_event_config(event_name), event_name,
> pd,
>  +                                     not_loaded_items, min_level, validators);
>  +}
>  +
>  +static const GList* elp_select_next_event(struct event_list_process *process, const
> GList **event_list, const GList *not_loaded_items, enum elp_signal_ret *ret)
>  +{
>  +    assert(process || !"NULL argument");
>  +    assert(event_list || !"NULL argument");
>  +
>  +    static validator_fn validators[] = {
>  +        check_event_usability,
>  +        NULL,
>  +    };
>  +
>  +    const GList *tmp;
>  +    tmp = *event_list;
>  +    *event_list = g_list_next(tmp);
>  +
>  +    problem_data_t *pd = elp_create_problem_data(process);
>  +    if (!pd)
>  +        return tmp;
>  +
>  +    while(tmp)
>  +    {
>  +        const enum elp_signal_ret resp = elp_validate_event(process, tmp->data, pd,
>  +                                                            not_loaded_items,
> EUS_UNUSABLE, validators);
>  +
>  +        if (ret)
>  +            *ret = resp;
>  +
>  +        if (resp == ELPSR_CONTINUE)
>  +            break;
>  +        else if (resp == ELPSR_FINISH)
>  +        {
>  +            tmp = *event_list = NULL;
>  +            break;
>  +        }
>  +        else if (resp != ELPSR_NEXT_EVENT)
>  +        {
>  +            assert(!"unexpected return value");
>  +        }
>  +
>  +        tmp = *event_list;
>  +        *event_list = g_list_next(tmp);
>  +    }
>  +
>  +    free_problem_data(pd);
>  +    return tmp;
>  +}
>  +
>  +static GList* elp_revise_event_list(struct event_list_process *process, const GList
> *event_list)
>  +{
>  +    GList *revised_list = NULL;
>  +    GList *created_items = NULL;
>  +    enum elp_signal_ret ret;
>  +
>  +    const GList *event;
>  +    while ((event = elp_select_next_event(process,&event_list,
> created_items,&ret)))
>  +    {
>  +        const event_config_t *const cfg = get_event_config(event->data);
>  +        if (cfg&&  cfg->ec_creates_items)
>  +        {
>  +            /* have to create a copy because of threads */
>  +            /* TODO : find a better place for following lines */
>  +            char *item_list = xstrdup(cfg->ec_creates_items);
>  +            char *bck = item_list;
>  +            while (item_list[0])
>  +            {
>  +                char *end = strchr(item_list, ',');
>  +                if (end) *end = '\0';
>  +                created_items = g_list_prepend(created_items, xstrdup(item_list));
>  +                if (!end)
>  +                    break;
>  +                item_list = end + 1;
>  +            }
>  +            free(bck);
>  +        }
>  +
>  +        revised_list = g_list_prepend(revised_list, event->data);
>  +    }
>  +
>  +    g_list_free_full(created_items, (GDestroyNotify)free);
>  +
>  +    if (ret != ELPSR_FINISH)
>  +        return g_list_reverse(revised_list);
>  +
>  +    g_list_free(revised_list);
>  +    return NULL;
>  +}
>  +
>  +static GList *elp_next_event(struct event_list_process *process)
>  +{
>  +    assert(process || !"NULL argument");
>  +
>  +    return (GList *)elp_select_next_event(process, (const GList
> **)&process->next, NULL, NULL);
>  +}
>  +
>  +static bool event_list_process_call(struct event_list_process *process,
>  +                                    elp_signal cb,
>  +                                    enum elp_process_states ok_state,
>  +                                    enum elp_signal_ret default_ret)
>  +{
>  +    assert(process || !"NULL argument");
>  +    assert((ok_state>= __MIN_PROC_STATE__&&  ok_state<=
> __MAX_PROC_STATE__) || !"out of range argument");
>  +
>  +    const enum elp_signal_ret ret = cb ? cb(process) : default_ret;
>  +
>  +    switch (ret)
>  +    {
>  +        case ELPSR_CONTINUE:
>  +            process->current = ok_state;
>  +            break;
>  +        case ELPSR_NEXT_EVENT:
>  +            process->current = ELP_START;
>  +            break;
>  +        case ELPSR_FINISH:
>  +            process->current = ELP_END;
>  +            break;
>  +        default:
>  +            assert(!"unexpected signal return value");
>  +            error_msg_and_die("unexpected signal return value %d", ret);
>  +            break;
>  +    }
>  +
>  +    return ret == ELPSR_CONTINUE;
>  +}
>  +
>  +struct process_run_event_watcher
>  +{
>  +    const struct run_event_observer *wrapped_obs;
>  +    bool failed;
>  +    bool stopper;
>  +};
>  +
>  +static void process_command_started(pid_t pid, void *args)
>  +{
>  +    struct process_run_event_watcher *pre = (struct process_run_event_watcher *)args;
>  +
>  +    if (pre->wrapped_obs&&  pre->wrapped_obs->command_started)
>  +        pre->wrapped_obs->command_started(pid, pre->wrapped_obs->args);
>  +}
>  +
>  +static void process_command_msg_processed(const char *msg, const char *raw_input, const
> char *rsp, void *args)
>  +{
>  +    struct process_run_event_watcher *pre = (struct process_run_event_watcher *)args;
>  +
>  +    /* TODO : should I move it to client.h ? */
>  +    if (!pre->stopper)
>  +        pre->stopper = !strncmp(msg, "THANK_YOU",
> sizeof("THANK_YOU") -1);
>  +
>  +    if (pre->wrapped_obs&&  pre->wrapped_obs->command_msg_processed)
>  +        pre->wrapped_obs->command_msg_processed(msg, raw_input, rsp,
> pre->wrapped_obs->args);
>  +}
>  +
>  +static void process_command_finished(int retval, int status, const char *err_msg, void
> *args)
>  +{
>  +    struct process_run_event_watcher *pre = (struct process_run_event_watcher *)args;
>  +
>  +    pre->failed = retval != 0;
>  +
>  +    if (pre->wrapped_obs&&  pre->wrapped_obs->command_finished)
>  +        pre->wrapped_obs->command_finished(retval, status, err_msg,
> pre->wrapped_obs->args);
>  +}
>  +
>  +int elp_next_step(struct event_list_process *process)
>  +{
>  +    /* before process start, revise event list and remove not configured and */
>  +    /* unusable events */
>  +    if (process->current == ELP_INIT)
>  +    {
>  +        process->current = ELP_START;
>  +
>  +        /* create internal event list from origin event list */
>  +        /* it is a copy of original list without unusable events */
>  +        process->internal_events = process->next = elp_revise_event_list(process,
> process->events);
>  +    }
>  +
>  +    /* Process all event from list until reaches event that needs review, event run
> failure */
>  +    /* or the end of the event list */
>  +    while (1)
>  +    {
>  +        if (process->current == ELP_START)
>  +        {
>  +            /* selects next event from internal list */
>  +            process->processed = elp_next_event(process);
>  +
>  +            if (!process->processed)
>  +            {   /* Event list is empty now */
>  +                process->current = ELP_END;
>  +            }
>  +            else
>  +            {
>  +                /* If callback next_event_selected is not set the process expects that
> */
>  +                /* there is no problem to continue thus default response is CONTINUE */
>  +                /* It callback returns a positive response process state is set to START
> */
>  +                if (!event_list_process_call(process,
> process->impl->next_event_selected, ELP_START, ELPSR_CONTINUE))
>  +                    return true;
>  +
>  +                if (elp_do_need_review(process, elp_get_current_event(process)))
>  +                    process->current = ELP_REVIEW_DATA;
>  +                else
>  +                    process->current = ELP_RUN_EVENT;
>  +            }
>  +
>  +            /* return is not here because we want to continue with next state */
>  +            /* use case : next_step with start state causes beginning to review */
>  +            /*            or immediate run of event commands */
>  +        }
>  +
>  +        if (process->current == ELP_REVIEW_DATA)
>  +        {
>  +            /* review_data signal has high priority thus if call back is not set, */
>  +            /* then we expect that data are not reviewed and event is skipped */
>  +
>  +            /* return pauses the processing of events because process has to wait on
> next */
>  +            /* step signaling that review is finished, thus return if positive answer
> */
>  +            /* was returned from review_data callback */
>  +
>  +            /* if negative answer was returned we want to select next event immediately
> */
>  +            /* or finish the process */
>  +            if(event_list_process_call(process, process->impl->review_data,
> ELP_RUN_EVENT, ELPSR_NEXT_EVENT))
>  +                return true;
>  +        }
>  +
>  +        if (process->current == ELP_RUN_EVENT)
>  +        {
>  +            /* If callback run_event is not set the process expects that */
>  +            /* there is no problem to continue thus default response is CONTINUE */
>  +
>  +            /* if negative answer was returned we want to select next event immediately
> */
>  +            /* or finish the process */
>  +            if (!event_list_process_call(process, process->impl->run_event,
> ELP_RUN_EVENT, ELPSR_CONTINUE))
>  +                return true;
>  +
>  +            const char *event_name = elp_get_current_event(process);
>  +
>  +            struct process_run_event_watcher process_watcher = {
>  +                .failed = false,
>  +                .stopper = false,
>  +            };
>  +
>  +            process_watcher.wrapped_obs = elp_get_run_obs(process);
>  +
>  +            struct run_event_observer process_obs = {
>  +                .command_started = process_command_started,
>  +                .command_msg_processed = process_command_msg_processed,
>  +                .command_finished = process_command_finished,
>  +            };
>  +
>  +            process_obs.args =&process_watcher;
>  +
>  +            const char *dump_dir_name = process->dump_dir_name;
>  +
>  +            pthread_mutex_lock(&(process->run_mut));
>  +
>  +            struct run_event_state *run_state = new_run_event_state();
>  +            process->run_state = run_state;
>  +            run_state->post_run_callback = process->post_run_callback;
>  +            run_state->post_run_param = process->post_run_param;
>  +            run_state->logging_callback = process->logging_callback;
>  +            run_state->logging_param = process->logging_param;
>  +
>  +            pthread_mutex_unlock(&(process->run_mut));
>  +
>  +            prepare_commands(run_state, dump_dir_name, event_name);
>  +            run_event_state_on_dir_name(run_state, dump_dir_name, event_name,
>  +                                        elp_get_run_impl(process),&process_obs);
>  +
>  +            /* take care about stopper occurrence only if event was successful */
>  +            /* thus default value is not stopper occurrence */
>  +            bool stopper = false;
>  +
>  +            process->last_run = ELP_ERS_FAILED;
>  +            if (!process_watcher.failed)
>  +            {
>  +                if (run_state->children_count == 0)
>  +                {
>  +                    process->last_run = ELP_ERS_NOT_FOUND;
>  +
>  +                    /* run_event do not provide any callback for not event found
> notification */
>  +                    /* and no event is considered as fail thus setting failed var to
> TRUE */
>  +                    process_watcher.failed = true;
>  +                }
>  +                else
>  +                {
>  +                    process->last_run = ELP_ERS_SUCCESSFUL;
>  +                    stopper = process_watcher.stopper;
>  +                }
>  +            }
>  +
>  +            /* stopper means that event decided to stop all further processing the */
>  +            /* thus successful state is ELP_END and default response is ELPSR_FINISH */
>  +            event_list_process_call(process, process->impl->event_done,
>  +                                    stopper ? ELP_END : ELP_START,
>  +                                    stopper ? ELPSR_FINISH : ELPSR_CONTINUE);
>  +
>  +            pthread_mutex_lock(&(process->run_mut));
>  +            free_run_event_state(run_state);
>  +            process->run_state = NULL;
>  +            pthread_mutex_unlock(&(process->run_mut));
>  +
>  +            /* do not forward to next step if event failed */
>  +            if (process_watcher.failed)
>  +                return true;
>  +        }
>  +
>  +        if (process->current == ELP_END)
>  +        {
>  +            /* Don't care about result, result can't change anything */
>  +            event_list_process_call(process, process->impl->finished, ELP_END,
> ELPSR_FINISH);
>  +            return false;
>  +        }
>  +    }
>  +
>  +    assert(!"cannot get here");
>  +    return false;
>  +} 
Before these patches:

# grep -r thread .
./src/gui-wizard-gtk/Makefile.am:# -lgthread-2.0
./src/lib/json.c:#include <btparser/thread.h>
./src/lib/json.c:    struct btp_thread *core_bt = btp_load_core_backtrace(pd_item);
./src/lib/json.c:        ureport_add_int(item, "thread", 0);
./src/lib/json.c:    btp_thread_free(core_bt);
./src/lib/json.c:    * ureport_add_item_int(ureport, pd, "crash_thread", NULL);
./src/lib/json.c:    ureport_add_int(ureport, "crash_thread", 0);
./src/plugins/rhbz.c:#include <btparser/thread.h>
./src/plugins/rhbz.c: *     - otherwise preview of crashed thread stack trace is created
./src/plugins/rhbz.c:        /* Get optimized thread stack trace for 10 top most frames
*/
./src/plugins/rhbz.c:        struct btp_thread *thread =
btp_backtrace_get_optimized_thread(backtrace, 10);
./src/plugins/rhbz.c:        if (!thread)
./src/plugins/rhbz.c:            log(_("Can't find crash thread"));
./src/plugins/rhbz.c:        btp_thread_append_to_str(thread, bt, true);
./src/plugins/rhbz.c:        btp_thread_free(thread);


After these patches:

# grep -r thread .
./libreport.spec.in:%{_includedir}/libreport/run_event_list_thread.h
./src/gui-wizard-gtk/wizard.c:#include "run_event_list_thread.h"
./src/gui-wizard-gtk/wizard.c:static pthread_t g_gui_thread_id;
./src/gui-wizard-gtk/wizard.c:        gdk_threads_enter();
./src/gui-wizard-gtk/wizard.c:        gdk_threads_leave();
./src/gui-wizard-gtk/wizard.c:    show_error_as_msgbox_mts(msg,
!pthread_equal(g_gui_thread_id, pthread_self()));
./src/gui-wizard-gtk/wizard.c:static void process_step_done_callback_fn(struct
elp_thread_args *args)
./src/gui-wizard-gtk/wizard.c:static void process_start_callback_fn(struct elp_thread_args
*args)
./src/gui-wizard-gtk/wizard.c:        gdk_threads_enter();
./src/gui-wizard-gtk/wizard.c:        gdk_threads_leave();
./src/gui-wizard-gtk/wizard.c:static void process_finish_callback_fn(struct
elp_thread_args  *args)
./src/gui-wizard-gtk/wizard.c:   
free_event_list_process(elp_thread_args_get_process(args));
./src/gui-wizard-gtk/wizard.c:    gdk_threads_enter();
./src/gui-wizard-gtk/wizard.c:    gdk_threads_leave();
./src/gui-wizard-gtk/wizard.c:        elp_thread_loop_kill_command(g_event_process);
./src/gui-wizard-gtk/wizard.c:    if (g_reviewing_data ||
!elp_thread_is_runnig(g_event_process))
./src/gui-wizard-gtk/wizard.c:        elp_thread_loop_next_step(g_event_process);
./src/gui-wizard-gtk/wizard.c:    gdk_threads_enter();
./src/gui-wizard-gtk/wizard.c:    gdk_threads_leave();
./src/gui-wizard-gtk/wizard.c:    gdk_threads_enter();
./src/gui-wizard-gtk/wizard.c:    gdk_threads_leave();
./src/gui-wizard-gtk/wizard.c:    gdk_threads_enter();
./src/gui-wizard-gtk/wizard.c:    gdk_threads_leave();
./src/gui-wizard-gtk/wizard.c:    gdk_threads_enter();
./src/gui-wizard-gtk/wizard.c:    gdk_threads_leave();
./src/gui-wizard-gtk/wizard.c:    gdk_threads_enter();
./src/gui-wizard-gtk/wizard.c:    gdk_threads_leave();
./src/gui-wizard-gtk/wizard.c:    gdk_threads_enter();
./src/gui-wizard-gtk/wizard.c:    gdk_threads_leave();
./src/gui-wizard-gtk/wizard.c:    gdk_threads_enter();
./src/gui-wizard-gtk/wizard.c:    gdk_threads_leave();
./src/gui-wizard-gtk/wizard.c:    gdk_threads_enter();
./src/gui-wizard-gtk/wizard.c:    gdk_threads_leave();
./src/gui-wizard-gtk/wizard.c:    gdk_threads_enter();
./src/gui-wizard-gtk/wizard.c:    gdk_threads_leave();
./src/gui-wizard-gtk/wizard.c:    gdk_threads_enter();
./src/gui-wizard-gtk/wizard.c:    gdk_threads_leave();
./src/gui-wizard-gtk/wizard.c:    gdk_threads_enter();
./src/gui-wizard-gtk/wizard.c:    gdk_threads_leave();
./src/gui-wizard-gtk/wizard.c:    gdk_threads_enter();
./src/gui-wizard-gtk/wizard.c:    gdk_threads_leave();
./src/gui-wizard-gtk/wizard.c:        gdk_threads_enter();
./src/gui-wizard-gtk/wizard.c:        gdk_threads_leave();
./src/gui-wizard-gtk/wizard.c:    elp_thread_run(g_event_process, proc);
./src/gui-wizard-gtk/wizard.c:        elp_thread_loop_next_step(g_event_process);
./src/gui-wizard-gtk/wizard.c:    gdk_threads_enter();
./src/gui-wizard-gtk/wizard.c:    gdk_threads_leave();
./src/gui-wizard-gtk/wizard.c:    elp_thread_loop_next_step(g_event_process);
./src/gui-wizard-gtk/wizard.c:    elp_thread_args_set_on_step_done(g_event_process,
process_step_done_callback_fn);
./src/gui-wizard-gtk/wizard.c:    elp_thread_args_set_on_start(g_event_process,
process_start_callback_fn);
./src/gui-wizard-gtk/wizard.c:    elp_thread_args_set_on_finish(g_event_process,
process_finish_callback_fn);
./src/gui-wizard-gtk/wizard.c:    g_gui_thread_id = pthread_self();
./src/gui-wizard-gtk/wizard.c:        g_source_attach((GSource*)gtk_assistant_source,
g_main_context_get_thread_default());
./src/gui-wizard-gtk/main.c:#include "run_event_list_thread.h"
./src/gui-wizard-gtk/main.c:struct elp_thread_args *g_event_process;
./src/gui-wizard-gtk/main.c:    g_event_process = new_elp_thread_args();
./src/gui-wizard-gtk/main.c:    gdk_threads_init ();
./src/gui-wizard-gtk/main.c:    gdk_threads_enter ();
./src/gui-wizard-gtk/main.c:    if (elp_thread_init(g_event_process))
./src/gui-wizard-gtk/main.c:        perror_msg_and_die("initializatoin of event
process thread failed");
./src/gui-wizard-gtk/main.c:    gdk_threads_leave();
./src/gui-wizard-gtk/main.c:    free_elp_thread_args(g_event_process);
./src/gui-wizard-gtk/wizard.h:struct elp_thread_args;
./src/gui-wizard-gtk/wizard.h:extern struct elp_thread_args *g_event_process;
./src/gui-wizard-gtk/Makefile.am:# -lgthread-2.0
./src/include/run_event_list_thread.h: * struct elp_thread_args *thread_proc =
new_elp_thread_args();
./src/include/run_event_list_thread.h: * if (elp_thread_init(thread_proc))
./src/include/run_event_list_thread.h: * elp_thread_run(thread_proc, event_proc);
./src/include/run_event_list_thread.h: * elp_thread_loop_next_step(thread_proc);
./src/include/run_event_list_thread.h: *
free_event_list_process(elp_thread_get_process(thread_proc));
./src/include/run_event_list_thread.h: * free_elp_thread(thread_proc);
./src/include/run_event_list_thread.h: * Structure that holds state of thread process.
./src/include/run_event_list_thread.h:struct elp_thread_args;
./src/include/run_event_list_thread.h: * Callback used by thread process to send signals
about process state
./src/include/run_event_list_thread.h:typedef void(* elp_thread_args_callback)(struct
elp_thread_args *args);
./src/include/run_event_list_thread.h: * Creates a new thread process state
./src/include/run_event_list_thread.h:struct elp_thread_args *new_elp_thread_args();
./src/include/run_event_list_thread.h: * @param args Not NULL pointer to thread process
state
./src/include/run_event_list_thread.h:void elp_thread_args_set_on_start(struct
elp_thread_args *args,
./src/include/run_event_list_thread.h:                                 
elp_thread_args_callback cb);
./src/include/run_event_list_thread.h: * @param args Not NULL pointer to thread process
state
./src/include/run_event_list_thread.h:void elp_thread_args_set_on_step_done(struct
elp_thread_args *args,
./src/include/run_event_list_thread.h:                                     
elp_thread_args_callback cb);
./src/include/run_event_list_thread.h: * @param args Not NULL pointer to thread process
state
./src/include/run_event_list_thread.h:void elp_thread_args_set_on_finish(struct
elp_thread_args *args,
./src/include/run_event_list_thread.h:                                  
elp_thread_args_callback cb);
./src/include/run_event_list_thread.h: * @param args Not NULL pointer to thread process
state
./src/include/run_event_list_thread.h:struct event_list_process
*elp_thread_args_get_process(const struct elp_thread_args *args);
./src/include/run_event_list_thread.h: * Destroy thread process
./src/include/run_event_list_thread.h: * @param args A pointer to thread process
./src/include/run_event_list_thread.h:void free_elp_thread_args(struct elp_thread_args
*args);
./src/include/run_event_list_thread.h: * Creates a thread used by a process
./src/include/run_event_list_thread.h: * @param args Not NULL pointer to thread process
state
./src/include/run_event_list_thread.h:int elp_thread_init(struct elp_thread_args *args);
./src/include/run_event_list_thread.h: * Interrupts an event list process and kills a
process thread.
./src/include/run_event_list_thread.h: * A thread process cannot be used after this
function call.
./src/include/run_event_list_thread.h: * @param args Not NULL pointer to thread process
state
./src/include/run_event_list_thread.h:void elp_thread_kill(struct elp_thread_args *args);
./src/include/run_event_list_thread.h: * Interrupts an event list process and leaves a
process thread untouched.
./src/include/run_event_list_thread.h: * @param args Not NULL pointer to thread process
state
./src/include/run_event_list_thread.h:void elp_thread_interrupt(struct elp_thread_args
*args);
./src/include/run_event_list_thread.h: * @param args Not NULL pointer to thread process
state
./src/include/run_event_list_thread.h:void elp_thread_run(struct elp_thread_args *args,
struct event_list_process *process);
./src/include/run_event_list_thread.h: * @param args Not NULL pointer to thread process
state
./src/include/run_event_list_thread.h:int elp_thread_is_runnig(struct elp_thread_args
*args);
./src/include/run_event_list_thread.h: * Notify a thread process to perform next event
list process step.
./src/include/run_event_list_thread.h: * @param args Not NULL pointer to thread process
state
./src/include/run_event_list_thread.h:void elp_thread_loop_next_step(struct
elp_thread_args *args);
./src/include/run_event_list_thread.h: * @param args Not NULL pointer to thread process
state
./src/include/run_event_list_thread.h:void elp_thread_loop_kill_command(struct
elp_thread_args *args);
./src/include/Makefile.am:    run_event_list_thread.h
./src/lib/run_event_list.c:#include <pthread.h>
./src/lib/run_event_list.c:    pthread_mutex_t run_mut;
./src/lib/run_event_list.c:    pthread_mutex_init(&(process->run_mut), NULL);
./src/lib/run_event_list.c:    pthread_mutex_destroy(&(process->run_mut));
./src/lib/run_event_list.c:    pthread_mutex_lock(&(process->run_mut));
./src/lib/run_event_list.c:    pthread_mutex_unlock(&(process->run_mut));
./src/lib/run_event_list.c:    pthread_mutex_lock(&(process->run_mut));
./src/lib/run_event_list.c:    pthread_mutex_unlock(&(process->run_mut));
./src/lib/run_event_list.c:    pthread_mutex_lock(&(process->run_mut));
./src/lib/run_event_list.c:    pthread_mutex_unlock(&(process->run_mut));
./src/lib/run_event_list.c:    pthread_mutex_lock(&(process->run_mut));
./src/lib/run_event_list.c:    pthread_mutex_unlock(&(process->run_mut));
./src/lib/run_event_list.c:            /* have to create a copy because of threads */
./src/lib/run_event_list.c:            pthread_mutex_lock(&(process->run_mut));
./src/lib/run_event_list.c:            pthread_mutex_unlock(&(process->run_mut));
./src/lib/run_event_list.c:            pthread_mutex_lock(&(process->run_mut));
./src/lib/run_event_list.c:            pthread_mutex_unlock(&(process->run_mut));
./src/lib/run_event_list_thread.c:#include <pthread.h>
./src/lib/run_event_list_thread.c:#include "run_event_list_thread.h"
./src/lib/run_event_list_thread.c:struct elp_thread_args
./src/lib/run_event_list_thread.c:    pthread_t process_tid;
./src/lib/run_event_list_thread.c:    pthread_mutex_t sync_mut;
./src/lib/run_event_list_thread.c:    pthread_cond_t proc_cond;
./src/lib/run_event_list_thread.c:    pthread_cond_t step_cond;
./src/lib/run_event_list_thread.c:    elp_thread_args_callback start_cb;
./src/lib/run_event_list_thread.c:    elp_thread_args_callback step_done_cb;
./src/lib/run_event_list_thread.c:    elp_thread_args_callback finish_cb;
./src/lib/run_event_list_thread.c:struct elp_thread_args *new_elp_thread_args()
./src/lib/run_event_list_thread.c:    struct elp_thread_args *args =
xzalloc(sizeof(*args));
./src/lib/run_event_list_thread.c:    pthread_mutex_init(&(args->sync_mut), NULL);
./src/lib/run_event_list_thread.c:    pthread_cond_init(&(args->proc_cond), NULL);
./src/lib/run_event_list_thread.c:    pthread_cond_init(&(args->step_cond), NULL);
./src/lib/run_event_list_thread.c:void elp_thread_args_set_on_start(struct elp_thread_args
*args,
./src/lib/run_event_list_thread.c:                                 
elp_thread_args_callback cb)
./src/lib/run_event_list_thread.c:void elp_thread_args_set_on_step_done(struct
elp_thread_args *args,
./src/lib/run_event_list_thread.c:                                     
elp_thread_args_callback cb)
./src/lib/run_event_list_thread.c:void elp_thread_args_set_on_finish(struct
elp_thread_args *args,
./src/lib/run_event_list_thread.c:                                  
elp_thread_args_callback cb)
./src/lib/run_event_list_thread.c:static void elp_thread_args_set_process(struct
elp_thread_args *args,
./src/lib/run_event_list_thread.c:struct event_list_process
*elp_thread_args_get_process(const struct elp_thread_args *args)
./src/lib/run_event_list_thread.c:static void elp_thread_args_on_start(struct
elp_thread_args *args)
./src/lib/run_event_list_thread.c:static void elp_thread_args_on_step_done(struct
elp_thread_args *args)
./src/lib/run_event_list_thread.c:static void elp_thread_args_on_finish(struct
elp_thread_args *args)
./src/lib/run_event_list_thread.c:void elp_thread_interrupt_internal(struct
elp_thread_args *args)
./src/lib/run_event_list_thread.c:static void elp_thread_kill_internal(struct
elp_thread_args *args)
./src/lib/run_event_list_thread.c:    elp_thread_interrupt_internal(args);
./src/lib/run_event_list_thread.c:static int elp_thread_wait_on_process(struct
elp_thread_args *args)
./src/lib/run_event_list_thread.c:    pthread_mutex_lock(&(args->sync_mut));
./src/lib/run_event_list_thread.c:        const int error =
pthread_cond_wait(&(args->proc_cond), &(args->sync_mut));
./src/lib/run_event_list_thread.c:            elp_thread_kill_internal(args);
./src/lib/run_event_list_thread.c:    pthread_mutex_unlock(&(args->sync_mut));
./src/lib/run_event_list_thread.c:static int elp_thread_wait_on_step(struct
elp_thread_args *args)
./src/lib/run_event_list_thread.c:    pthread_mutex_lock(&(args->sync_mut));
./src/lib/run_event_list_thread.c:        const int error =
pthread_cond_wait(&(args->step_cond), &(args->sync_mut));
./src/lib/run_event_list_thread.c:            elp_thread_kill_internal(args);
./src/lib/run_event_list_thread.c:    pthread_mutex_unlock(&(args->sync_mut));
./src/lib/run_event_list_thread.c:void free_elp_thread_args(struct elp_thread_args *args)
./src/lib/run_event_list_thread.c:    pthread_cond_destroy(&(args->step_cond));
./src/lib/run_event_list_thread.c:    pthread_cond_destroy(&(args->proc_cond));
./src/lib/run_event_list_thread.c:    pthread_mutex_destroy(&(args->sync_mut));
./src/lib/run_event_list_thread.c:void elp_thread_run(struct elp_thread_args *args, struct
event_list_process *process)
./src/lib/run_event_list_thread.c:    pthread_mutex_lock(&(args->sync_mut));
./src/lib/run_event_list_thread.c:    if (elp_thread_is_runnig(args))
./src/lib/run_event_list_thread.c:        error_msg_and_die("event list process
thread is already runnig");
./src/lib/run_event_list_thread.c:    elp_thread_args_set_process(args, process);
./src/lib/run_event_list_thread.c:    pthread_cond_signal(&(args->proc_cond));
./src/lib/run_event_list_thread.c:    pthread_mutex_unlock(&(args->sync_mut));
./src/lib/run_event_list_thread.c:int elp_thread_is_runnig(struct elp_thread_args *args)
./src/lib/run_event_list_thread.c:void elp_thread_loop_next_step(struct elp_thread_args
*args)
./src/lib/run_event_list_thread.c:    pthread_mutex_lock(&(args->sync_mut));
./src/lib/run_event_list_thread.c:    pthread_cond_signal(&(args->step_cond));
./src/lib/run_event_list_thread.c:    pthread_mutex_unlock(&(args->sync_mut));
./src/lib/run_event_list_thread.c:static void *elp_thread(void *args)
./src/lib/run_event_list_thread.c:    struct elp_thread_args *p = (struct elp_thread_args
*)args;
./src/lib/run_event_list_thread.c:    while (elp_thread_wait_on_process(p))
./src/lib/run_event_list_thread.c:        elp_thread_args_on_start(p);
./src/lib/run_event_list_thread.c:        pthread_mutex_lock(&(p->sync_mut));
./src/lib/run_event_list_thread.c:           
pthread_mutex_unlock(&(p->sync_mut));
./src/lib/run_event_list_thread.c:            elp_thread_wait_on_step(p);
./src/lib/run_event_list_thread.c:            while (elp_thread_wait_on_step(p) &&
cont)
./src/lib/run_event_list_thread.c:                elp_thread_args_on_step_done(p);
./src/lib/run_event_list_thread.c:            pthread_mutex_lock(&(p->sync_mut));
./src/lib/run_event_list_thread.c:        pthread_mutex_unlock(&(p->sync_mut));
./src/lib/run_event_list_thread.c:        elp_thread_args_on_finish(p);
./src/lib/run_event_list_thread.c:int elp_thread_init(struct elp_thread_args *args)
./src/lib/run_event_list_thread.c:    return pthread_create(&(args->process_tid),
NULL, elp_thread, args);
./src/lib/run_event_list_thread.c:void elp_thread_loop_kill_command(struct elp_thread_args
*args)
./src/lib/run_event_list_thread.c:    pthread_mutex_lock(&(args->sync_mut));
./src/lib/run_event_list_thread.c:    pthread_mutex_unlock(&(args->sync_mut));
./src/lib/run_event_list_thread.c:void elp_thread_interrupt(struct elp_thread_args *args)
./src/lib/run_event_list_thread.c:    pthread_mutex_lock(&(args->sync_mut));
./src/lib/run_event_list_thread.c:    elp_thread_interrupt_internal(args);
./src/lib/run_event_list_thread.c:    pthread_cond_signal(&(args->step_cond));
./src/lib/run_event_list_thread.c:    pthread_mutex_unlock(&(args->sync_mut));
./src/lib/run_event_list_thread.c:void elp_thread_kill(struct elp_thread_args *args)
./src/lib/run_event_list_thread.c:    pthread_mutex_lock(&(args->sync_mut));
./src/lib/run_event_list_thread.c:    elp_thread_kill_internal(args);
./src/lib/run_event_list_thread.c:    pthread_cond_signal(&(args->proc_cond));
./src/lib/run_event_list_thread.c:    pthread_mutex_unlock(&(args->sync_mut));
./src/lib/json.c:#include <btparser/thread.h>
./src/lib/json.c:    struct btp_thread *core_bt = btp_load_core_backtrace(pd_item);
./src/lib/json.c:        ureport_add_int(item, "thread", 0);
./src/lib/json.c:    btp_thread_free(core_bt);
./src/lib/json.c:    * ureport_add_item_int(ureport, pd, "crash_thread", NULL);
./src/lib/json.c:    ureport_add_int(ureport, "crash_thread", 0);
./src/lib/Makefile.am:	run_event_list_thread.c
./src/plugins/rhbz.c:#include <btparser/thread.h>
./src/plugins/rhbz.c: *     - otherwise preview of crashed thread stack trace is created
./src/plugins/rhbz.c:        /* Get optimized thread stack trace for 10 top most frames
*/
./src/plugins/rhbz.c:        struct btp_thread *thread =
btp_backtrace_get_optimized_thread(backtrace, 10);
./src/plugins/rhbz.c:        if (!thread)
./src/plugins/rhbz.c:            log(_("Can't find crash thread"));
./src/plugins/rhbz.c:        btp_thread_append_to_str(thread, bt, true);
./src/plugins/rhbz.c:        btp_thread_free(thread);


I don't think this is an improvement.
Who will debug the next nightmage threading bug?

-- 
vda

[PATCH 4/7] track#554 : add API for runnig of lists of events

[Jakub Filak]

On Tuesday 26 of June 2012 17:09:48 you wrote:
>  On 06/26/2012 10:37 AM, Jakub Filak wrote:
>  > Signed-off-by: Jakub Filak<jfilak(a)redhat.com>
>  > ---
>  > 
>  >   libreport.spec.in            |    1 +
>  >   src/include/Makefile.am      |    3 +-
>  >   src/include/run_event_list.h |  209 ++++++++++++++
>  >   src/lib/Makefile.am          |    3 +-
>  >   src/lib/run_event_list.c     |  618
>  >   ++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 832
>  >   insertions(+), 2 deletions(-)
>  >   create mode 100644 src/include/run_event_list.h
>  >   create mode 100644 src/lib/run_event_list.c
>  > 
>  > diff --git a/libreport.spec.in b/libreport.spec.in
>  > index 3f730e3..ea51431 100644
>  > --- a/libreport.spec.in
>  > +++ b/libreport.spec.in
>  > 
>  > @@ -297,6 +297,7 @@ gtk-update-icon-cache 
%{_datadir}/icons/hicolor&>/dev/null || :
>  >   %{_includedir}/libreport/report.h
>  >   %{_includedir}/libreport/run_event.h
>  >   %{_includedir}/libreport/event_usability.h
>  > 
>  > +%{_includedir}/libreport/run_event_list.h
>  > 
>  >   # Private api headers:
>  >   %{_includedir}/libreport/internal_abrt_dbus.h
>  >   %{_includedir}/libreport/internal_libreport.h
>  > 
>  > diff --git a/src/include/Makefile.am b/src/include/Makefile.am
>  > index 7aa5f78..bca63dd 100644
>  > --- a/src/include/Makefile.am
>  > +++ b/src/include/Makefile.am
>  > @@ -10,4 +10,5 @@ libreport_include_HEADERS = \
>  > 
>  >       \
>  >       internal_libreport.h \
>  >       internal_abrt_dbus.h \
>  > 
>  > -    event_usability.h
>  > +    event_usability.h \
>  > +    run_event_list.h
>  > diff --git a/src/include/run_event_list.h b/src/include/run_event_list.h
>  > new file mode 100644
>  > index 0000000..f5fa11f
>  > --- /dev/null
>  > +++ b/src/include/run_event_list.h
>  > @@ -0,0 +1,209 @@
>  > +/*
>  > +    Copyright (C) 2012  ABRT team.
>  > +    Copyright (C) 2012  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.
>  > +*/
>  > +#ifndef LIBREPORT_RUN_EVENT_LIST_H_
>  > +#define LIBREPORT_RUN_EVENT_LIST_H_
>  > +
>  > +#include<glib.h>
>  > +#include "run_event.h"
>  > +#include "event_usability.h"
>  > +
>  > +/* Forward declartion */
>  > +struct event_list_process;
>  > +
>  > +/*
>  > + * Return value from event list process signal.
>  > + * Signal handler returns these values in order to adjust process
>  > + * flow according to current state.
>  > + */
>  > +enum elp_signal_ret
>  > +{
>  > +    ELPSR_CONTINUE,     ///<  A process should continue with next step.
>  > +    ELPSR_NEXT_EVENT,   ///<  A process should skip all remaining steps a
>  > continue with next event. +    ELPSR_FINISH,       ///<  A process should
>  > skip all remaining events and finis itself. +};
>  
>  What is elp[sr]? 
event list process signal return

>  
>  > +/*
>  > + * Event list process signal function type
>  
>  This does not make sense to me. 
pull approach, all functions have the same declaration and read required data 
from a passed process pointer

>  
>  > + *
>  > + * @param process A process that emits a signal.
>  > + * @return A value that adjusts process flow.
>  > + */
>  > +typedef enum elp_signal_ret (* elp_signal)(struct event_list_process
>  > *process); +
>  > +/*
>  > + * All signals used by event list process
>  > + */
>  > +struct elp_signals_impl
>  > +{
>  > +    /*
>  > +     * Next event was successfully selected and process is about to
>  > process it +     */
>  > +    elp_signal next_event_selected;
>  > +
>  > +    /*
>  > +     * Currently selected event requires review.
>  > +     */
>  > +    elp_signal review_data;
>  > +
>  > +    /*
>  > +     * Currently selected event is about to be run.
>  > +     */
>  > +    elp_signal run_event;
>  > +
>  > +    /*
>  > +     * Currently selected event has finished.
>  > +     */
>  > +    elp_signal event_done;
>  > +
>  > +    /*
>  > +     * No more events to be processed
>  > +     */
>  > +    elp_signal finished;
>  > +
>  > +    /*
>  > +     * Event has some problem with configuration
>  > +     */
>  > +    elp_signal configuration_issue;
>  > +};
>  
>  This looks like a TON of added complexity for no apparent reason. 
I can use only one signal functions with two arguments.
1. process
2. type of signal
But it forces me to define a new enum with type of signals.
And on the client side it requires more complex logic.

>  
>  For starters, what problem are you solving? 
(report-gtk|report-cli) -e report_uReport -e analyze_LocalGDB -e 
report_Bugzilla

I tried to unify the implementation.

Each event from list must be reviewed if it is required. After review the 
event must be run. And finally a result of run is sent to back to caller.

>  
>  > +/*
>  > + * Types of event run result
>  > + */
>  > +enum elp_event_run_status
>  > +{
>  > +    ELP_ERS_NONE,       ///<  No run was performed
>  > +    ELP_ERS_SUCCESSFUL, ///<  Event finished successfully
>  > +    ELP_ERS_FAILED,     ///<  Event failed
>  > +    ELP_ERS_NOT_FOUND,  ///<  No processing was found
>  > +};
>  
>  ELP ERS? 
:) event list process event run status

>  
>  > +/*
>  > + * Structure holds an configuration issue info
>  > + */
>  > +struct elp_configuration_issue
>  > +{
>  > +    const char *event_name;                 ///<  Event with problems
>  > +    enum event_usability_status usability;  ///<  Event usability
>  > +    const GList *issues;                    ///<  All known configuration
>  > issues for an event +};
>  > +
>  > +/*
>  > + * Initializes event list process signal functions.
>  > + *
>  > + * @param impl A not NULL pointer to signals
>  > + */
>  > +void event_list_process_impl_init(struct elp_signals_impl *impl);
>  
>  I am totally lost by now. What are we doing here? 
convenient way how to initialize a structure with signals
I can use memset() instead of this function

>  
>  > +/*
>  > + * Creates an initializes an event list process
>  > + *
>  > + * @param events A list of events to be processed, do not take an
>  > ownership + * @param signals A signal implementation, do not take an
>  > ownership + * @param run_impl A call backs for event run, do not take an
>  > ownership + * @param run_obs An observer for event run, do not take an
>  > ownership + * @param dump_dir_name A dump dir name, do not take an
>  > ownership + * @param signal_args A custom data available by
>  > elp_get_signal_args() + * @return An initialized event list process,
>  > never returns NULL
>  > + */
>  > +struct event_list_process *new_event_list_process(const GList *events,
>  > +                                                  const struct
>  > elp_signals_impl *impl, +                                                
>  >  const struct run_event_impl *run_impl, +                                
>  >                  const struct run_event_observer *run_obs, +             
>  >                                     const char *dump_dir_name, +         
>  >                                         void *signal_args); +
>  > +/*
>  > + * Frees all used memory by an event list process
>  > + *
>  > + * @param process A pointer to process
>  > + */
>  > +void free_event_list_process(struct event_list_process *process);
>  > +
>  > +/*
>  > + * Gets an currently selected event.
>  > + *
>  > + * @param process A not NULL pointer to process
>  > + * @return A pointer to event name if some event was selected, otherwise
>  > returns NULL + */
>  > +const char *elp_get_current_event(const struct event_list_process
>  > *process); +
>  > +/*
>  > + * Gets an currently selected event.
>  > + *
>  > + * @param process A not NULL pointer to process
>  > + * @return A data passed in new_event_list_process()
>  > + */
>  > +void *elp_get_signal_args(const struct event_list_process *process);
>  > +
>  > +/*
>  > + * Gets the last event run result.
>  > + *
>  > + * @param process A not NULL pointer to process
>  > + * @return the last event run result.
>  > + */
>  > +enum elp_event_run_status elp_get_last_event_status(const struct
>  > event_list_process *process); +
>  > +/*
>  > + * Gets the last configuraton issue. This function must be called
>  > + * only from handler of configuration_issue signal.
>  > + *
>  > + * @param process A not NULL pointer to process
>  > + * @return the last configuration issue.
>  > + */
>  > +const struct elp_configuration_issue
>  > *elp_get_last_configuration_issue(const struct event_list_process
>  > *process); +
>  > +/*
>  > + * Sets a post run callback for run_event_state.
>  > + *
>  > + * The method is provided only for backward compatibility
>  > + *
>  > + * @param process A not NULL pointer to process
>  > + * @param post_run_callback A pointer to function
>  > + * @param post_run_param A custom data passed to callback
>  > + */
>  > +void elp_set_post_run_callback(struct event_list_process *process,
>  > res_post_run_callback post_run_callback, void *post_run_param); +
>  > +/*
>  > + * Sets a logging callback for run_event_state.
>  > + *
>  > + * The method is provided only for backward compatibility
>  > + *
>  > + * @param process A not NULL pointer to process
>  > + * @param loggin_callback A pointer to function
>  > + * @param loggin_param A custom data passed to callback
>  > + */
>  > +void elp_set_logging_callback(struct event_list_process *process,
>  > res_logging_callback logging_callback, void *logging_param); +
>  > +/*
>  > + * Forces a process to perform next step.
>  > + *
>  > + * @param process A not NULL pointer to process
>  > + * @return 0 if last step was performed; otherwise returns non 0
>  > + */
>  > +int elp_next_step(struct event_list_process *process);
>  > +
>  > +/*
>  > + * Kills an event command process
>  > + *
>  > + * @param process A not NULL pointer to process
>  > + */
>  > +void elp_kill_run(struct event_list_process *process);
>  > +
>  > +#endif /* LIBREPORT_RUN_EVENT_LIST_H_ */
>  > +
>  > diff --git a/src/lib/Makefile.am b/src/lib/Makefile.am
>  > index cd1f164..fd406ce 100644
>  > --- a/src/lib/Makefile.am
>  > +++ b/src/lib/Makefile.am
>  > @@ -48,7 +48,8 @@ libreport_la_SOURCES = \
>  > 
>  >       user_settings.c \
>  >       client.c \
>  >       utf8.c \
>  > 
>  > -    event_usability.c
>  > +    event_usability.c \
>  > +	run_event_list.c
>  > 
>  >   libreport_la_CPPFLAGS = \
>  >   
>  >       -Wall -Wwrite-strings -Werror \
>  > 
>  > diff --git a/src/lib/run_event_list.c b/src/lib/run_event_list.c
>  > new file mode 100644
>  > index 0000000..559772d
>  > --- /dev/null
>  > +++ b/src/lib/run_event_list.c
>  > @@ -0,0 +1,618 @@
>  > +/*
>  > +    Copyright (C) 2012  ABRT Team
>  > +    Copyright (C) 2012  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<pthread.h>
>  > +#include<glob.h>
>  > +#include<regex.h>
>  > +#include "run_event.h"
>  > +#include "run_event_list.h"
>  > +#include "event_usability.h"
>  > +#include "internal_libreport.h"
>  > +
>  > +enum elp_process_states
>  > +{
>  > +    __MIN_PROC_STATE__ = 0,
>  
>  __names are reserved for compiler / libc. 
Thus I have to use better name.

>  
>  > +
>  > +    ELP_INIT = __MIN_PROC_STATE__,
>  > +    ELP_START,
>  > +    ELP_REVIEW_DATA,
>  > +    ELP_RUN_EVENT,
>  > +    ELP_END,
>  > +
>  > +    __MAX_PROC_STATE__ = ELP_END,
>  > +};
>  > +
>  > +struct event_list_process
>  > +{
>  > +    const struct elp_signals_impl *impl;
>  > +    const struct run_event_impl *run_impl;
>  > +    const struct run_event_observer *run_obs;
>  > +    const char *dump_dir_name;
>  > +    void *args;
>  > +
>  > +    enum elp_process_states current;
>  > +    const GList *events;
>  > +    GList *internal_events;
>  > +    GList *next;
>  > +    GList *processed;
>  > +
>  > +    struct run_event_state *run_state;
>  > +
>  > +    res_post_run_callback post_run_callback;
>  > +    void *post_run_param;
>  > +    res_logging_callback logging_callback;
>  > +    void *logging_param;
>  > +
>  > +    pthread_mutex_t run_mut;
>  > +    enum elp_event_run_status last_run;
>  > +
>  > +    struct elp_configuration_issue last_configuration_issue;
>  > +};
>  > +
>  > +void event_list_process_impl_init(struct elp_signals_impl *impl)
>  > +{
>  > +    memset(impl, 0, sizeof(*impl));
>  > +}
>  > +
>  > +struct event_list_process *new_event_list_process(const GList *events,
>  > +                                                  const struct
>  > elp_signals_impl *impl, +                                                
>  >  const struct run_event_impl *run_impl, +                                
>  >                  const struct run_event_observer *run_obs, +             
>  >                                     const char *dump_dir_name, +         
>  >                                         void *signal_args) +{
>  > +    assert(impl || !"NULL argument");
>  > +    assert(run_impl || !"NULL argument");
>  > +
>  > +    struct event_list_process *process = xmalloc(sizeof(*process));
>  > +
>  > +    process->impl = impl;
>  > +    process->run_impl = run_impl;
>  > +    process->run_obs = run_obs;
>  > +    process->dump_dir_name = dump_dir_name;
>  > +    process->args = signal_args;
>  > +    process->current = __MIN_PROC_STATE__;
>  > +    process->events = events;
>  > +    process->next = NULL;
>  > +    process->internal_events = NULL;
>  > +    process->processed = NULL;
>  > +    process->run_state = NULL;
>  > +
>  > +    pthread_mutex_init(&(process->run_mut), NULL);
>  > +
>  > +    process->last_run = ELP_ERS_NONE;
>  > +
>  > +    process->post_run_callback = NULL;
>  > +    process->post_run_param = NULL;
>  > +    process->logging_callback = NULL;
>  > +    process->logging_param = NULL;
>  > +
>  > +    return process;
>  > +}
>  > +
>  > +void free_event_list_process(struct event_list_process *process)
>  > +{
>  > +    assert(process || !"NULL argument");
>  > +
>  > +    g_list_free(process->internal_events);
>  > +
>  > +    pthread_mutex_destroy(&(process->run_mut));
>  > +
>  > +    free(process);
>  > +}
>  > +
>  > +const char* elp_get_current_event(const struct event_list_process
>  > *process) +{
>  > +    assert(process || !"NULL argument");
>  > +
>  > +    return process->processed ? process->processed->data : NULL;
>  > +}
>  > +
>  > +void *elp_get_signal_args(const struct event_list_process *process)
>  > +{
>  > +    assert(process || !"NULL argument");
>  > +
>  > +    return process->args;
>  > +}
>  > +
>  > +enum elp_event_run_status elp_get_last_event_status(const struct
>  > event_list_process *process) +{
>  > +    assert(process || !"NULL argument");
>  > +
>  > +    return process->last_run;
>  > +}
>  > +
>  > +void elp_kill_run(struct event_list_process *process)
>  > +{
>  > +    assert(process || !"NULL argument");
>  > +
>  > +    pthread_mutex_lock(&(process->run_mut));
>  > +
>  > +    if (process->run_state)
>  > +        run_event_state_kill_command(process->run_state);
>  > +
>  > +    pthread_mutex_unlock(&(process->run_mut));
>  > +}
>  > +
>  > +void elp_set_post_run_callback(struct event_list_process *process,
>  > +                               res_post_run_callback post_run_callback,
>  > +                               void *post_run_param)
>  > +{
>  > +    assert(process || !"NULL argument");
>  > +
>  > +    pthread_mutex_lock(&(process->run_mut));
>  > +
>  > +    process->post_run_callback = post_run_callback;
>  > +    process->post_run_param = post_run_param;
>  > +
>  > +    pthread_mutex_unlock(&(process->run_mut));
>  > +}
>  > +
>  > +void elp_set_logging_callback(struct event_list_process *process,
>  > +                              res_logging_callback logging_callback,
>  > +                              void *logging_param)
>  > +{
>  > +    assert(process || !"NULL argument");
>  > +
>  > +    pthread_mutex_lock(&(process->run_mut));
>  > +
>  > +    process->logging_callback = logging_callback;
>  > +    process->logging_param = logging_param;
>  > +
>  > +    pthread_mutex_unlock(&(process->run_mut));
>  > +}
>  > +
>  > +const struct elp_configuration_issue
>  > *elp_get_last_configuration_issue(const struct event_list_process
>  > *process) +{
>  > +    return&(process->last_configuration_issue);
>  > +}
>  > +
>  > +static const struct run_event_impl *elp_get_run_impl(struct
>  > event_list_process *process) +{
>  > +    assert(process || !"NULL argument");
>  > +
>  > +    return process->run_impl;
>  > +}
>  > +
>  > +static const struct run_event_observer *elp_get_run_obs(struct
>  > event_list_process *process) +{
>  > +    assert(process || !"NULL argument");
>  > +
>  > +    return process->run_obs;
>  > +}
>  > +
>  > +static problem_data_t *elp_create_problem_data(const struct
>  > event_list_process *process) +{
>  > +
>  > +    struct dump_dir *dd = dd_opendir(process->dump_dir_name, 0);
>  > +    if (!dd)
>  > +        return NULL;
>  > +
>  > +    problem_data_t *pd = create_problem_data_from_dump_dir(dd);
>  > +    dd_close(dd);
>  > +
>  > +    return pd;
>  > +}
>  > +
>  > +static bool elp_do_need_review(const struct event_list_process *process,
>  > const char *event_name) +{
>  > +    const event_config_t *const cfg = get_event_config(event_name);
>  > +    if (cfg&&  !cfg->ec_skip_review)
>  > +        return true;
>  > +
>  > +    problem_data_t *const pd = elp_create_problem_data(process);
>  > +    if (pd)
>  > +        return check_event_usability(cfg, pd, NULL, NULL, EUS_LOW) !=
>  > EUS_GOOD; +
>  > +    return true;
>  > +}
>  > +
>  > +static void elp_set_last_configuration_issues(struct event_list_process
>  > *process, +                                              const char
>  > *event_name, +                                              enum
>  > event_usability_status status, +                                         
>  >     const GList *issues) +{
>  > +    pthread_mutex_lock(&(process->run_mut));
>  > +
>  > +    process->last_configuration_issue.event_name = event_name;
>  > +    process->last_configuration_issue.usability = status;
>  > +    process->last_configuration_issue.issues = issues;
>  > +
>  > +    pthread_mutex_unlock(&(process->run_mut));
>  > +}
>  > +
>  > +static enum elp_signal_ret elp_event_configuration_issue(struct
>  > event_list_process *process, +                                           
>  >              const char *event_name, +                                   
>  >                      enum event_usability_status status, +               
>  >                                          const GList *issues) +{
>  > +    enum elp_signal_ret ret = ELPSR_FINISH;
>  > +
>  > +    if (process->impl->configuration_issue)
>  > +    {
>  > +        elp_set_last_configuration_issues(process, event_name, status,
>  > issues); +
>  > +        ret = process->impl->configuration_issue(process);
>  > +
>  > +        elp_set_last_configuration_issues(process, NULL, EUS_GOOD, NULL);
>  > +    }
>  > +
>  > +    return ret;
>  > +}
>  > +
>  > +typedef enum event_usability_status (*validator_fn)(const event_config_t
>  > *, const  problem_data_t *, +                                            
>  >        const GList *, GList **, enum event_usability_status); +
>  > +static enum elp_signal_ret elp_validate_event_config(struct
>  > event_list_process *process, +                                           
>  >          const event_config_t *cfg, +                                    
>  >                 const char *event_name, +                                
>  >                     const problem_data_t *pd, +                          
>  >                           const GList *not_loaded_items, +               
>  >                                      enum event_usability_status
>  > min_level, +                                                    
>  > validator_fn *validators) +{
>  > +    enum elp_signal_ret resp = ELPSR_CONTINUE;
>  > +
>  > +    if (!cfg)
>  > +        return resp;
>  > +
>  > +    enum event_usability_status status = EUS_GOOD;
>  > +    validator_fn *validator = validators;
>  > +    GList* issues = NULL;
>  > +    while(*validator)
>  > +    {
>  > +        status = worst_usability(status, (*validator)(cfg, pd,
>  > not_loaded_items,&issues, min_level)); +        ++validator;
>  > +    }
>  > +
>  > +    if (status == EUS_UNUSABLE)
>  > +    {
>  > +        resp = elp_event_configuration_issue(process, event_name, status,
>  > issues); +        g_list_free_full(issues, (GDestroyNotify)free);
>  > +
>  > +        if (resp == ELPSR_CONTINUE)
>  > +            error_msg_and_die("Cannot continue with unusable event
> '%s'",
>  > event_name); +    }
>  > +
>  > +    return resp;
>  > +}
>  > +
>  > +static enum elp_signal_ret elp_validate_event(struct event_list_process
>  > *process, +                                              const char
>  > *event_name, +                                              const
>  > problem_data_t *pd, +                                              const
>  > GList *not_loaded_items, +                                             
>  > enum event_usability_status min_level, +                                 
>  >             validator_fn *validators) +{
>  > +    return elp_validate_event_config(process,
>  > get_event_config(event_name), event_name, pd, +                          
>  >           not_loaded_items, min_level, validators); +}
>  > +
>  > +static const GList* elp_select_next_event(struct event_list_process
>  > *process, const GList **event_list, const GList *not_loaded_items, enum
>  > elp_signal_ret *ret) +{
>  > +    assert(process || !"NULL argument");
>  > +    assert(event_list || !"NULL argument");
>  > +
>  > +    static validator_fn validators[] = {
>  > +        check_event_usability,
>  > +        NULL,
>  > +    };
>  > +
>  > +    const GList *tmp;
>  > +    tmp = *event_list;
>  > +    *event_list = g_list_next(tmp);
>  > +
>  > +    problem_data_t *pd = elp_create_problem_data(process);
>  > +    if (!pd)
>  > +        return tmp;
>  > +
>  > +    while(tmp)
>  > +    {
>  > +        const enum elp_signal_ret resp = elp_validate_event(process,
>  > tmp->data, pd, +                                                         
>  >   not_loaded_items, EUS_UNUSABLE, validators); +
>  > +        if (ret)
>  > +            *ret = resp;
>  > +
>  > +        if (resp == ELPSR_CONTINUE)
>  > +            break;
>  > +        else if (resp == ELPSR_FINISH)
>  > +        {
>  > +            tmp = *event_list = NULL;
>  > +            break;
>  > +        }
>  > +        else if (resp != ELPSR_NEXT_EVENT)
>  > +        {
>  > +            assert(!"unexpected return value");
>  > +        }
>  > +
>  > +        tmp = *event_list;
>  > +        *event_list = g_list_next(tmp);
>  > +    }
>  > +
>  > +    free_problem_data(pd);
>  > +    return tmp;
>  > +}
>  > +
>  > +static GList* elp_revise_event_list(struct event_list_process *process,
>  > const GList *event_list) +{
>  > +    GList *revised_list = NULL;
>  > +    GList *created_items = NULL;
>  > +    enum elp_signal_ret ret;
>  > +
>  > +    const GList *event;
>  > +    while ((event = elp_select_next_event(process,&event_list,
>  > created_items,&ret))) +    {
>  > +        const event_config_t *const cfg = get_event_config(event->data);
>  > +        if (cfg&&  cfg->ec_creates_items)
>  > +        {
>  > +            /* have to create a copy because of threads */
>  > +            /* TODO : find a better place for following lines */
>  > +            char *item_list = xstrdup(cfg->ec_creates_items);
>  > +            char *bck = item_list;
>  > +            while (item_list[0])
>  > +            {
>  > +                char *end = strchr(item_list, ',');
>  > +                if (end) *end = '\0';
>  > +                created_items = g_list_prepend(created_items,
>  > xstrdup(item_list)); +                if (!end)
>  > +                    break;
>  > +                item_list = end + 1;
>  > +            }
>  > +            free(bck);
>  > +        }
>  > +
>  > +        revised_list = g_list_prepend(revised_list, event->data);
>  > +    }
>  > +
>  > +    g_list_free_full(created_items, (GDestroyNotify)free);
>  > +
>  > +    if (ret != ELPSR_FINISH)
>  > +        return g_list_reverse(revised_list);
>  > +
>  > +    g_list_free(revised_list);
>  > +    return NULL;
>  > +}
>  > +
>  > +static GList *elp_next_event(struct event_list_process *process)
>  > +{
>  > +    assert(process || !"NULL argument");
>  > +
>  > +    return (GList *)elp_select_next_event(process, (const GList
>  > **)&process->next, NULL, NULL); +}
>  > +
>  > +static bool event_list_process_call(struct event_list_process *process,
>  > +                                    elp_signal cb,
>  > +                                    enum elp_process_states ok_state,
>  > +                                    enum elp_signal_ret default_ret)
>  > +{
>  > +    assert(process || !"NULL argument");
>  > +    assert((ok_state>= __MIN_PROC_STATE__&&  ok_state<=
>  > __MAX_PROC_STATE__) || !"out of range argument"); +
>  > +    const enum elp_signal_ret ret = cb ? cb(process) : default_ret;
>  > +
>  > +    switch (ret)
>  > +    {
>  > +        case ELPSR_CONTINUE:
>  > +            process->current = ok_state;
>  > +            break;
>  > +        case ELPSR_NEXT_EVENT:
>  > +            process->current = ELP_START;
>  > +            break;
>  > +        case ELPSR_FINISH:
>  > +            process->current = ELP_END;
>  > +            break;
>  > +        default:
>  > +            assert(!"unexpected signal return value");
>  > +            error_msg_and_die("unexpected signal return value %d", ret);
>  > +            break;
>  > +    }
>  > +
>  > +    return ret == ELPSR_CONTINUE;
>  > +}
>  > +
>  > +struct process_run_event_watcher
>  > +{
>  > +    const struct run_event_observer *wrapped_obs;
>  > +    bool failed;
>  > +    bool stopper;
>  > +};
>  > +
>  > +static void process_command_started(pid_t pid, void *args)
>  > +{
>  > +    struct process_run_event_watcher *pre = (struct
>  > process_run_event_watcher *)args; +
>  > +    if (pre->wrapped_obs&&  pre->wrapped_obs->command_started)
>  > +        pre->wrapped_obs->command_started(pid,
> pre->wrapped_obs->args);
>  > +}
>  > +
>  > +static void process_command_msg_processed(const char *msg, const char
>  > *raw_input, const char *rsp, void *args) +{
>  > +    struct process_run_event_watcher *pre = (struct
>  > process_run_event_watcher *)args; +
>  > +    /* TODO : should I move it to client.h ? */
>  > +    if (!pre->stopper)
>  > +        pre->stopper = !strncmp(msg, "THANK_YOU",
> sizeof("THANK_YOU")
>  > -1);
>  > +
>  > +    if (pre->wrapped_obs&& 
> pre->wrapped_obs->command_msg_processed)
>  > +        pre->wrapped_obs->command_msg_processed(msg, raw_input, rsp,
>  > pre->wrapped_obs->args); +}
>  > +
>  > +static void process_command_finished(int retval, int status, const char
>  > *err_msg, void *args) +{
>  > +    struct process_run_event_watcher *pre = (struct
>  > process_run_event_watcher *)args; +
>  > +    pre->failed = retval != 0;
>  > +
>  > +    if (pre->wrapped_obs&&  pre->wrapped_obs->command_finished)
>  > +        pre->wrapped_obs->command_finished(retval, status, err_msg,
>  > pre->wrapped_obs->args); +}
>  > +
>  > +int elp_next_step(struct event_list_process *process)
>  > +{
>  > +    /* before process start, revise event list and remove not configured
>  > and */ +    /* unusable events */
>  > +    if (process->current == ELP_INIT)
>  > +    {
>  > +        process->current = ELP_START;
>  > +
>  > +        /* create internal event list from origin event list */
>  > +        /* it is a copy of original list without unusable events */
>  > +        process->internal_events = process->next =
>  > elp_revise_event_list(process, process->events); +    }
>  > +
>  > +    /* Process all event from list until reaches event that needs review,
>  > event run failure */ +    /* or the end of the event list */
>  > +    while (1)
>  > +    {
>  > +        if (process->current == ELP_START)
>  > +        {
>  > +            /* selects next event from internal list */
>  > +            process->processed = elp_next_event(process);
>  > +
>  > +            if (!process->processed)
>  > +            {   /* Event list is empty now */
>  > +                process->current = ELP_END;
>  > +            }
>  > +            else
>  > +            {
>  > +                /* If callback next_event_selected is not set the process
>  > expects that */ +                /* there is no problem to continue thus
>  > default response is CONTINUE */ +                /* It callback returns a
>  > positive response process state is set to START */ +                if
>  > (!event_list_process_call(process, process->impl->next_event_selected,
>  > ELP_START, ELPSR_CONTINUE)) +                    return true;
>  > +
>  > +                if (elp_do_need_review(process,
>  > elp_get_current_event(process))) +                    process->current =
>  > ELP_REVIEW_DATA;
>  > +                else
>  > +                    process->current = ELP_RUN_EVENT;
>  > +            }
>  > +
>  > +            /* return is not here because we want to continue with next
>  > state */ +            /* use case : next_step with start state causes
>  > beginning to review */ +            /*            or immediate run of
>  > event commands */
>  > +        }
>  > +
>  > +        if (process->current == ELP_REVIEW_DATA)
>  > +        {
>  > +            /* review_data signal has high priority thus if call back is
>  > not set, */ +            /* then we expect that data are not reviewed and
>  > event is skipped */ +
>  > +            /* return pauses the processing of events because process has
>  > to wait on next */ +            /* step signaling that review is
>  > finished, thus return if positive answer */ +            /* was returned
>  > from review_data callback */
>  > +
>  > +            /* if negative answer was returned we want to select next
>  > event immediately */ +            /* or finish the process */
>  > +            if(event_list_process_call(process,
>  > process->impl->review_data, ELP_RUN_EVENT, ELPSR_NEXT_EVENT)) +          
>  >      return true;
>  > +        }
>  > +
>  > +        if (process->current == ELP_RUN_EVENT)
>  > +        {
>  > +            /* If callback run_event is not set the process expects that
>  > */ +            /* there is no problem to continue thus default response
>  > is CONTINUE */ +
>  > +            /* if negative answer was returned we want to select next
>  > event immediately */ +            /* or finish the process */
>  > +            if (!event_list_process_call(process,
>  > process->impl->run_event, ELP_RUN_EVENT, ELPSR_CONTINUE)) +              
>  >  return true;
>  > +
>  > +            const char *event_name = elp_get_current_event(process);
>  > +
>  > +            struct process_run_event_watcher process_watcher = {
>  > +                .failed = false,
>  > +                .stopper = false,
>  > +            };
>  > +
>  > +            process_watcher.wrapped_obs = elp_get_run_obs(process);
>  > +
>  > +            struct run_event_observer process_obs = {
>  > +                .command_started = process_command_started,
>  > +                .command_msg_processed = process_command_msg_processed,
>  > +                .command_finished = process_command_finished,
>  > +            };
>  > +
>  > +            process_obs.args =&process_watcher;
>  > +
>  > +            const char *dump_dir_name = process->dump_dir_name;
>  > +
>  > +            pthread_mutex_lock(&(process->run_mut));
>  > +
>  > +            struct run_event_state *run_state = new_run_event_state();
>  > +            process->run_state = run_state;
>  > +            run_state->post_run_callback = process->post_run_callback;
>  > +            run_state->post_run_param = process->post_run_param;
>  > +            run_state->logging_callback = process->logging_callback;
>  > +            run_state->logging_param = process->logging_param;
>  > +
>  > +            pthread_mutex_unlock(&(process->run_mut));
>  > +
>  > +            prepare_commands(run_state, dump_dir_name, event_name);
>  > +            run_event_state_on_dir_name(run_state, dump_dir_name,
>  > event_name, +                                       
>  > elp_get_run_impl(process),&process_obs); +
>  > +            /* take care about stopper occurrence only if event was
>  > successful */ +            /* thus default value is not stopper
>  > occurrence */
>  > +            bool stopper = false;
>  > +
>  > +            process->last_run = ELP_ERS_FAILED;
>  > +            if (!process_watcher.failed)
>  > +            {
>  > +                if (run_state->children_count == 0)
>  > +                {
>  > +                    process->last_run = ELP_ERS_NOT_FOUND;
>  > +
>  > +                    /* run_event do not provide any callback for not
>  > event found notification */ +                    /* and no event is
>  > considered as fail thus setting failed var to TRUE */ +                  
>  >  process_watcher.failed = true;
>  > +                }
>  > +                else
>  > +                {
>  > +                    process->last_run = ELP_ERS_SUCCESSFUL;
>  > +                    stopper = process_watcher.stopper;
>  > +                }
>  > +            }
>  > +
>  > +            /* stopper means that event decided to stop all further
>  > processing the */ +            /* thus successful state is ELP_END and
>  > default response is ELPSR_FINISH */ +           
>  > event_list_process_call(process, process->impl->event_done, +            
>  >                        stopper ? ELP_END : ELP_START, +                  
>  >                  stopper ? ELPSR_FINISH : ELPSR_CONTINUE); +
>  > +            pthread_mutex_lock(&(process->run_mut));
>  > +            free_run_event_state(run_state);
>  > +            process->run_state = NULL;
>  > +            pthread_mutex_unlock(&(process->run_mut));
>  > +
>  > +            /* do not forward to next step if event failed */
>  > +            if (process_watcher.failed)
>  > +                return true;
>  > +        }
>  > +
>  > +        if (process->current == ELP_END)
>  > +        {
>  > +            /* Don't care about result, result can't change anything */
>  > +            event_list_process_call(process, process->impl->finished,
>  > ELP_END, ELPSR_FINISH); +            return false;
>  > +        }
>  > +    }
>  > +
>  > +    assert(!"cannot get here");
>  > +    return false;
>  > +}
>  
>  Before these patches:
>  
>  # grep -r thread .
>  ./src/gui-wizard-gtk/Makefile.am:# -lgthread-2.0
>  ./src/lib/json.c:#include <btparser/thread.h>
>  ./src/lib/json.c:    struct btp_thread *core_bt =
>  btp_load_core_backtrace(pd_item); ./src/lib/json.c:       
>  ureport_add_int(item, "thread", 0);
>  ./src/lib/json.c:    btp_thread_free(core_bt);
>  ./src/lib/json.c:    * ureport_add_item_int(ureport, pd, "crash_thread",
>  NULL); ./src/lib/json.c:    ureport_add_int(ureport, "crash_thread", 0);
>  ./src/plugins/rhbz.c:#include <btparser/thread.h>
>  ./src/plugins/rhbz.c: *     - otherwise preview of crashed thread stack
>  trace is created ./src/plugins/rhbz.c:        /* Get optimized thread stack
>  trace for 10 top most frames */ ./src/plugins/rhbz.c:        struct
>  btp_thread *thread = btp_backtrace_get_optimized_thread(backtrace, 10);
>  ./src/plugins/rhbz.c:        if (!thread)
>  ./src/plugins/rhbz.c:            log(_("Can't find crash thread"));
>  ./src/plugins/rhbz.c:        btp_thread_append_to_str(thread, bt, true);
>  ./src/plugins/rhbz.c:        btp_thread_free(thread);
>  
>  
>  After these patches:
>  
>  # grep -r thread .
>  ./libreport.spec.in:%{_includedir}/libreport/run_event_list_thread.h
>  ./src/gui-wizard-gtk/wizard.c:#include "run_event_list_thread.h"
>  ./src/gui-wizard-gtk/wizard.c:static pthread_t g_gui_thread_id;
>  ./src/gui-wizard-gtk/wizard.c:        gdk_threads_enter();
>  ./src/gui-wizard-gtk/wizard.c:        gdk_threads_leave();
>  ./src/gui-wizard-gtk/wizard.c:    show_error_as_msgbox_mts(msg,
>  !pthread_equal(g_gui_thread_id, pthread_self()));
>  ./src/gui-wizard-gtk/wizard.c:static void
>  process_step_done_callback_fn(struct elp_thread_args *args)
>  ./src/gui-wizard-gtk/wizard.c:static void process_start_callback_fn(struct
>  elp_thread_args *args) ./src/gui-wizard-gtk/wizard.c:       
>  gdk_threads_enter();
>  ./src/gui-wizard-gtk/wizard.c:        gdk_threads_leave();
>  ./src/gui-wizard-gtk/wizard.c:static void process_finish_callback_fn(struct
>  elp_thread_args  *args) ./src/gui-wizard-gtk/wizard.c:   
>  free_event_list_process(elp_thread_args_get_process(args));
>  ./src/gui-wizard-gtk/wizard.c:    gdk_threads_enter();
>  ./src/gui-wizard-gtk/wizard.c:    gdk_threads_leave();
>  ./src/gui-wizard-gtk/wizard.c:       
>  elp_thread_loop_kill_command(g_event_process);
>  ./src/gui-wizard-gtk/wizard.c:    if (g_reviewing_data ||
>  !elp_thread_is_runnig(g_event_process)) ./src/gui-wizard-gtk/wizard.c:     
>    elp_thread_loop_next_step(g_event_process);
>  ./src/gui-wizard-gtk/wizard.c:    gdk_threads_enter();
>  ./src/gui-wizard-gtk/wizard.c:    gdk_threads_leave();
>  ./src/gui-wizard-gtk/wizard.c:    gdk_threads_enter();
>  ./src/gui-wizard-gtk/wizard.c:    gdk_threads_leave();
>  ./src/gui-wizard-gtk/wizard.c:    gdk_threads_enter();
>  ./src/gui-wizard-gtk/wizard.c:    gdk_threads_leave();
>  ./src/gui-wizard-gtk/wizard.c:    gdk_threads_enter();
>  ./src/gui-wizard-gtk/wizard.c:    gdk_threads_leave();
>  ./src/gui-wizard-gtk/wizard.c:    gdk_threads_enter();
>  ./src/gui-wizard-gtk/wizard.c:    gdk_threads_leave();
>  ./src/gui-wizard-gtk/wizard.c:    gdk_threads_enter();
>  ./src/gui-wizard-gtk/wizard.c:    gdk_threads_leave();
>  ./src/gui-wizard-gtk/wizard.c:    gdk_threads_enter();
>  ./src/gui-wizard-gtk/wizard.c:    gdk_threads_leave();
>  ./src/gui-wizard-gtk/wizard.c:    gdk_threads_enter();
>  ./src/gui-wizard-gtk/wizard.c:    gdk_threads_leave();
>  ./src/gui-wizard-gtk/wizard.c:    gdk_threads_enter();
>  ./src/gui-wizard-gtk/wizard.c:    gdk_threads_leave();
>  ./src/gui-wizard-gtk/wizard.c:    gdk_threads_enter();
>  ./src/gui-wizard-gtk/wizard.c:    gdk_threads_leave();
>  ./src/gui-wizard-gtk/wizard.c:    gdk_threads_enter();
>  ./src/gui-wizard-gtk/wizard.c:    gdk_threads_leave();
>  ./src/gui-wizard-gtk/wizard.c:    gdk_threads_enter();
>  ./src/gui-wizard-gtk/wizard.c:    gdk_threads_leave();
>  ./src/gui-wizard-gtk/wizard.c:        gdk_threads_enter();
>  ./src/gui-wizard-gtk/wizard.c:        gdk_threads_leave();
>  ./src/gui-wizard-gtk/wizard.c:    elp_thread_run(g_event_process, proc);
>  ./src/gui-wizard-gtk/wizard.c:       
>  elp_thread_loop_next_step(g_event_process); ./src/gui-wizard-gtk/wizard.c: 
>    gdk_threads_enter();
>  ./src/gui-wizard-gtk/wizard.c:    gdk_threads_leave();
>  ./src/gui-wizard-gtk/wizard.c:   
>  elp_thread_loop_next_step(g_event_process); ./src/gui-wizard-gtk/wizard.c: 
>    elp_thread_args_set_on_step_done(g_event_process,
>  process_step_done_callback_fn); ./src/gui-wizard-gtk/wizard.c:   
>  elp_thread_args_set_on_start(g_event_process, process_start_callback_fn);
>  ./src/gui-wizard-gtk/wizard.c:   
>  elp_thread_args_set_on_finish(g_event_process, process_finish_callback_fn);
>  ./src/gui-wizard-gtk/wizard.c:    g_gui_thread_id = pthread_self();
>  ./src/gui-wizard-gtk/wizard.c:       
>  g_source_attach((GSource*)gtk_assistant_source,
>  g_main_context_get_thread_default()); ./src/gui-wizard-gtk/main.c:#include
>  "run_event_list_thread.h"
>  ./src/gui-wizard-gtk/main.c:struct elp_thread_args *g_event_process;
>  ./src/gui-wizard-gtk/main.c:    g_event_process = new_elp_thread_args();
>  ./src/gui-wizard-gtk/main.c:    gdk_threads_init ();
>  ./src/gui-wizard-gtk/main.c:    gdk_threads_enter ();
>  ./src/gui-wizard-gtk/main.c:    if (elp_thread_init(g_event_process))
>  ./src/gui-wizard-gtk/main.c:        perror_msg_and_die("initializatoin of
>  event process thread failed"); ./src/gui-wizard-gtk/main.c:   
>  gdk_threads_leave();
>  ./src/gui-wizard-gtk/main.c:    free_elp_thread_args(g_event_process);
>  ./src/gui-wizard-gtk/wizard.h:struct elp_thread_args;
>  ./src/gui-wizard-gtk/wizard.h:extern struct elp_thread_args
>  *g_event_process; ./src/gui-wizard-gtk/Makefile.am:# -lgthread-2.0
>  ./src/include/run_event_list_thread.h: * struct elp_thread_args *thread_proc
>  = new_elp_thread_args(); ./src/include/run_event_list_thread.h: * if
>  (elp_thread_init(thread_proc)) ./src/include/run_event_list_thread.h: *
>  elp_thread_run(thread_proc, event_proc);
>  ./src/include/run_event_list_thread.h: *
>  elp_thread_loop_next_step(thread_proc);
>  ./src/include/run_event_list_thread.h: *
>  free_event_list_process(elp_thread_get_process(thread_proc));
>  ./src/include/run_event_list_thread.h: * free_elp_thread(thread_proc);
>  ./src/include/run_event_list_thread.h: * Structure that holds state of
>  thread process. ./src/include/run_event_list_thread.h:struct
>  elp_thread_args;
>  ./src/include/run_event_list_thread.h: * Callback used by thread process to
>  send signals about process state
>  ./src/include/run_event_list_thread.h:typedef void(*
>  elp_thread_args_callback)(struct elp_thread_args *args);
>  ./src/include/run_event_list_thread.h: * Creates a new thread process state
>  ./src/include/run_event_list_thread.h:struct elp_thread_args
>  *new_elp_thread_args(); ./src/include/run_event_list_thread.h: * @param
>  args Not NULL pointer to thread process state
>  ./src/include/run_event_list_thread.h:void
>  elp_thread_args_set_on_start(struct elp_thread_args *args,
>  ./src/include/run_event_list_thread.h:                                 
>  elp_thread_args_callback cb); ./src/include/run_event_list_thread.h: *
>  @param args Not NULL pointer to thread process state
>  ./src/include/run_event_list_thread.h:void
>  elp_thread_args_set_on_step_done(struct elp_thread_args *args,
>  ./src/include/run_event_list_thread.h:                                     
>  elp_thread_args_callback cb); ./src/include/run_event_list_thread.h: *
>  @param args Not NULL pointer to thread process state
>  ./src/include/run_event_list_thread.h:void
>  elp_thread_args_set_on_finish(struct elp_thread_args *args,
>  ./src/include/run_event_list_thread.h:                                  
>  elp_thread_args_callback cb); ./src/include/run_event_list_thread.h: *
>  @param args Not NULL pointer to thread process state
>  ./src/include/run_event_list_thread.h:struct event_list_process
>  *elp_thread_args_get_process(const struct elp_thread_args *args);
>  ./src/include/run_event_list_thread.h: * Destroy thread process
>  ./src/include/run_event_list_thread.h: * @param args A pointer to thread
>  process ./src/include/run_event_list_thread.h:void
>  free_elp_thread_args(struct elp_thread_args *args);
>  ./src/include/run_event_list_thread.h: * Creates a thread used by a process
>  ./src/include/run_event_list_thread.h: * @param args Not NULL pointer to
>  thread process state ./src/include/run_event_list_thread.h:int
>  elp_thread_init(struct elp_thread_args *args);
>  ./src/include/run_event_list_thread.h: * Interrupts an event list process
>  and kills a process thread. ./src/include/run_event_list_thread.h: * A
>  thread process cannot be used after this function call.
>  ./src/include/run_event_list_thread.h: * @param args Not NULL pointer to
>  thread process state ./src/include/run_event_list_thread.h:void
>  elp_thread_kill(struct elp_thread_args *args);
>  ./src/include/run_event_list_thread.h: * Interrupts an event list process
>  and leaves a process thread untouched.
>  ./src/include/run_event_list_thread.h: * @param args Not NULL pointer to
>  thread process state ./src/include/run_event_list_thread.h:void
>  elp_thread_interrupt(struct elp_thread_args *args);
>  ./src/include/run_event_list_thread.h: * @param args Not NULL pointer to
>  thread process state ./src/include/run_event_list_thread.h:void
>  elp_thread_run(struct elp_thread_args *args, struct event_list_process
>  *process); ./src/include/run_event_list_thread.h: * @param args Not NULL
>  pointer to thread process state ./src/include/run_event_list_thread.h:int
>  elp_thread_is_runnig(struct elp_thread_args *args);
>  ./src/include/run_event_list_thread.h: * Notify a thread process to perform
>  next event list process step. ./src/include/run_event_list_thread.h: *
>  @param args Not NULL pointer to thread process state
>  ./src/include/run_event_list_thread.h:void elp_thread_loop_next_step(struct
>  elp_thread_args *args); ./src/include/run_event_list_thread.h: * @param
>  args Not NULL pointer to thread process state
>  ./src/include/run_event_list_thread.h:void
>  elp_thread_loop_kill_command(struct elp_thread_args *args);
>  ./src/include/Makefile.am:    run_event_list_thread.h
>  ./src/lib/run_event_list.c:#include <pthread.h>
>  ./src/lib/run_event_list.c:    pthread_mutex_t run_mut;
>  ./src/lib/run_event_list.c:    pthread_mutex_init(&(process->run_mut),
>  NULL); ./src/lib/run_event_list.c:   
>  pthread_mutex_destroy(&(process->run_mut)); ./src/lib/run_event_list.c:   
>  pthread_mutex_lock(&(process->run_mut)); ./src/lib/run_event_list.c:   
>  pthread_mutex_unlock(&(process->run_mut)); ./src/lib/run_event_list.c:   
>  pthread_mutex_lock(&(process->run_mut)); ./src/lib/run_event_list.c:   
>  pthread_mutex_unlock(&(process->run_mut)); ./src/lib/run_event_list.c:   
>  pthread_mutex_lock(&(process->run_mut)); ./src/lib/run_event_list.c:   
>  pthread_mutex_unlock(&(process->run_mut)); ./src/lib/run_event_list.c:   
>  pthread_mutex_lock(&(process->run_mut)); ./src/lib/run_event_list.c:   
>  pthread_mutex_unlock(&(process->run_mut)); ./src/lib/run_event_list.c:     
>        /* have to create a copy because of threads */
>  ./src/lib/run_event_list.c:           
>  pthread_mutex_lock(&(process->run_mut)); ./src/lib/run_event_list.c:       
>      pthread_mutex_unlock(&(process->run_mut)); ./src/lib/run_event_list.c: 
>            pthread_mutex_lock(&(process->run_mut));
>  ./src/lib/run_event_list.c:           
>  pthread_mutex_unlock(&(process->run_mut));
>  ./src/lib/run_event_list_thread.c:#include <pthread.h>
>  ./src/lib/run_event_list_thread.c:#include "run_event_list_thread.h"
>  ./src/lib/run_event_list_thread.c:struct elp_thread_args
>  ./src/lib/run_event_list_thread.c:    pthread_t process_tid;
>  ./src/lib/run_event_list_thread.c:    pthread_mutex_t sync_mut;
>  ./src/lib/run_event_list_thread.c:    pthread_cond_t proc_cond;
>  ./src/lib/run_event_list_thread.c:    pthread_cond_t step_cond;
>  ./src/lib/run_event_list_thread.c:    elp_thread_args_callback start_cb;
>  ./src/lib/run_event_list_thread.c:    elp_thread_args_callback step_done_cb;
>  ./src/lib/run_event_list_thread.c:    elp_thread_args_callback finish_cb;
>  ./src/lib/run_event_list_thread.c:struct elp_thread_args
>  *new_elp_thread_args() ./src/lib/run_event_list_thread.c:    struct
>  elp_thread_args *args = xzalloc(sizeof(*args));
>  ./src/lib/run_event_list_thread.c:    pthread_mutex_init(&(args->sync_mut),
>  NULL); ./src/lib/run_event_list_thread.c:   
>  pthread_cond_init(&(args->proc_cond), NULL);
>  ./src/lib/run_event_list_thread.c:    pthread_cond_init(&(args->step_cond),
>  NULL); ./src/lib/run_event_list_thread.c:void
>  elp_thread_args_set_on_start(struct elp_thread_args *args,
>  ./src/lib/run_event_list_thread.c:                                 
>  elp_thread_args_callback cb) ./src/lib/run_event_list_thread.c:void
>  elp_thread_args_set_on_step_done(struct elp_thread_args *args,
>  ./src/lib/run_event_list_thread.c:                                     
>  elp_thread_args_callback cb) ./src/lib/run_event_list_thread.c:void
>  elp_thread_args_set_on_finish(struct elp_thread_args *args,
>  ./src/lib/run_event_list_thread.c:                                  
>  elp_thread_args_callback cb) ./src/lib/run_event_list_thread.c:static void
>  elp_thread_args_set_process(struct elp_thread_args *args,
>  ./src/lib/run_event_list_thread.c:struct event_list_process
>  *elp_thread_args_get_process(const struct elp_thread_args *args)
>  ./src/lib/run_event_list_thread.c:static void
>  elp_thread_args_on_start(struct elp_thread_args *args)
>  ./src/lib/run_event_list_thread.c:static void
>  elp_thread_args_on_step_done(struct elp_thread_args *args)
>  ./src/lib/run_event_list_thread.c:static void
>  elp_thread_args_on_finish(struct elp_thread_args *args)
>  ./src/lib/run_event_list_thread.c:void elp_thread_interrupt_internal(struct
>  elp_thread_args *args) ./src/lib/run_event_list_thread.c:static void
>  elp_thread_kill_internal(struct elp_thread_args *args)
>  ./src/lib/run_event_list_thread.c:    elp_thread_interrupt_internal(args);
>  ./src/lib/run_event_list_thread.c:static int
>  elp_thread_wait_on_process(struct elp_thread_args *args)
>  ./src/lib/run_event_list_thread.c:   
>  pthread_mutex_lock(&(args->sync_mut)); ./src/lib/run_event_list_thread.c:  
>       const int error = pthread_cond_wait(&(args->proc_cond),
>  &(args->sync_mut)); ./src/lib/run_event_list_thread.c:           
>  elp_thread_kill_internal(args); ./src/lib/run_event_list_thread.c:   
>  pthread_mutex_unlock(&(args->sync_mut));
>  ./src/lib/run_event_list_thread.c:static int elp_thread_wait_on_step(struct
>  elp_thread_args *args) ./src/lib/run_event_list_thread.c:   
>  pthread_mutex_lock(&(args->sync_mut)); ./src/lib/run_event_list_thread.c:  
>       const int error = pthread_cond_wait(&(args->step_cond),
>  &(args->sync_mut)); ./src/lib/run_event_list_thread.c:           
>  elp_thread_kill_internal(args); ./src/lib/run_event_list_thread.c:   
>  pthread_mutex_unlock(&(args->sync_mut));
>  ./src/lib/run_event_list_thread.c:void free_elp_thread_args(struct
>  elp_thread_args *args) ./src/lib/run_event_list_thread.c:   
>  pthread_cond_destroy(&(args->step_cond));
>  ./src/lib/run_event_list_thread.c:   
>  pthread_cond_destroy(&(args->proc_cond));
>  ./src/lib/run_event_list_thread.c:   
>  pthread_mutex_destroy(&(args->sync_mut));
>  ./src/lib/run_event_list_thread.c:void elp_thread_run(struct
>  elp_thread_args *args, struct event_list_process *process)
>  ./src/lib/run_event_list_thread.c:   
>  pthread_mutex_lock(&(args->sync_mut)); ./src/lib/run_event_list_thread.c:  
>   if (elp_thread_is_runnig(args)) ./src/lib/run_event_list_thread.c:       
>  error_msg_and_die("event list process thread is already runnig");
>  ./src/lib/run_event_list_thread.c:    elp_thread_args_set_process(args,
>  process); ./src/lib/run_event_list_thread.c:   
>  pthread_cond_signal(&(args->proc_cond)); ./src/lib/run_event_list_thread.c:
>     pthread_mutex_unlock(&(args->sync_mut));
>  ./src/lib/run_event_list_thread.c:int elp_thread_is_runnig(struct
>  elp_thread_args *args) ./src/lib/run_event_list_thread.c:void
>  elp_thread_loop_next_step(struct elp_thread_args *args)
>  ./src/lib/run_event_list_thread.c:   
>  pthread_mutex_lock(&(args->sync_mut)); ./src/lib/run_event_list_thread.c:  
>   pthread_cond_signal(&(args->step_cond));
>  ./src/lib/run_event_list_thread.c:   
>  pthread_mutex_unlock(&(args->sync_mut));
>  ./src/lib/run_event_list_thread.c:static void *elp_thread(void *args)
>  ./src/lib/run_event_list_thread.c:    struct elp_thread_args *p = (struct
>  elp_thread_args *)args; ./src/lib/run_event_list_thread.c:    while
>  (elp_thread_wait_on_process(p)) ./src/lib/run_event_list_thread.c:       
>  elp_thread_args_on_start(p); ./src/lib/run_event_list_thread.c:       
>  pthread_mutex_lock(&(p->sync_mut)); ./src/lib/run_event_list_thread.c:     
>        pthread_mutex_unlock(&(p->sync_mut));
>  ./src/lib/run_event_list_thread.c:            elp_thread_wait_on_step(p);
>  ./src/lib/run_event_list_thread.c:            while
>  (elp_thread_wait_on_step(p) && cont) ./src/lib/run_event_list_thread.c:    
>             elp_thread_args_on_step_done(p);
>  ./src/lib/run_event_list_thread.c:           
>  pthread_mutex_lock(&(p->sync_mut)); ./src/lib/run_event_list_thread.c:     
>    pthread_mutex_unlock(&(p->sync_mut)); ./src/lib/run_event_list_thread.c: 
>        elp_thread_args_on_finish(p); ./src/lib/run_event_list_thread.c:int
>  elp_thread_init(struct elp_thread_args *args)
>  ./src/lib/run_event_list_thread.c:    return
>  pthread_create(&(args->process_tid), NULL, elp_thread, args);
>  ./src/lib/run_event_list_thread.c:void elp_thread_loop_kill_command(struct
>  elp_thread_args *args) ./src/lib/run_event_list_thread.c:   
>  pthread_mutex_lock(&(args->sync_mut)); ./src/lib/run_event_list_thread.c:  
>   pthread_mutex_unlock(&(args->sync_mut));
>  ./src/lib/run_event_list_thread.c:void elp_thread_interrupt(struct
>  elp_thread_args *args) ./src/lib/run_event_list_thread.c:   
>  pthread_mutex_lock(&(args->sync_mut)); ./src/lib/run_event_list_thread.c:  
>   elp_thread_interrupt_internal(args); ./src/lib/run_event_list_thread.c:   
>  pthread_cond_signal(&(args->step_cond)); ./src/lib/run_event_list_thread.c:
>     pthread_mutex_unlock(&(args->sync_mut));
>  ./src/lib/run_event_list_thread.c:void elp_thread_kill(struct
>  elp_thread_args *args) ./src/lib/run_event_list_thread.c:   
>  pthread_mutex_lock(&(args->sync_mut)); ./src/lib/run_event_list_thread.c:  
>   elp_thread_kill_internal(args); ./src/lib/run_event_list_thread.c:   
>  pthread_cond_signal(&(args->proc_cond)); ./src/lib/run_event_list_thread.c:
>     pthread_mutex_unlock(&(args->sync_mut)); ./src/lib/json.c:#include
>  <btparser/thread.h>
>  ./src/lib/json.c:    struct btp_thread *core_bt =
>  btp_load_core_backtrace(pd_item); ./src/lib/json.c:       
>  ureport_add_int(item, "thread", 0);
>  ./src/lib/json.c:    btp_thread_free(core_bt);
>  ./src/lib/json.c:    * ureport_add_item_int(ureport, pd, "crash_thread",
>  NULL); ./src/lib/json.c:    ureport_add_int(ureport, "crash_thread", 0);
>  ./src/lib/Makefile.am:	run_event_list_thread.c
>  ./src/plugins/rhbz.c:#include <btparser/thread.h>
>  ./src/plugins/rhbz.c: *     - otherwise preview of crashed thread stack
>  trace is created ./src/plugins/rhbz.c:        /* Get optimized thread stack
>  trace for 10 top most frames */ ./src/plugins/rhbz.c:        struct
>  btp_thread *thread = btp_backtrace_get_optimized_thread(backtrace, 10);
>  ./src/plugins/rhbz.c:        if (!thread)
>  ./src/plugins/rhbz.c:            log(_("Can't find crash thread"));
>  ./src/plugins/rhbz.c:        btp_thread_append_to_str(thread, bt, true);
>  ./src/plugins/rhbz.c:        btp_thread_free(thread);
>  
>  
>  I don't think this is an improvement.
>  Who will debug the next nightmage threading bug? 
I use only two threads :( All nightmare stuff is hidden in 
run_event_list_thread.

> From my point of view, this approach is better than running event
> processes  
from GUI
* it allows me to use callbacks in run_event_on_dir().
* it is not necessary to implement run_event_on_dir in GUI again
* implementation of run event list can be shared between reporters
* reporters are much more simple

[PATCH 0/5] Merge implementations of 'run event'

[Jakub Filak]

I'm still working on the API for running of chain of events because we have to
implement this functionality in report-cli. I proposed an implementation
employing threads few weeks ago and the implementation have been reject. (I
have to admit that the proposed implementation was a little bit complicated.)
Now, I am trying to achieve my goals in much simpler way.

This patch set doesn't introduces the chain API yet, it only merges duplicate
implementations of running of event commands. We have one implementation for
the command line reporter and another one for the GUI report. There are only
few new lines but lot of changes. The main improvement is handling of
nonblocking reads form child's stdout and better maintainability.

I want to know your opinion about this patch set before I continue.

Jakub Filak (5):
  trac#622 : event command message prefix lengths computed at
    initialization
  trac#622 : split run_event_on_dir_name() in to two functions
  trac#622 : use callbacks in run_event_command_on_dir_name()
  trac#622 : expose run_event_command_on_dir() and allow user to set
    O_NONBLOCK read to child's stdout
  trac#622 : report-gtk uses run_event_command_on_dir_name()

 src/gui-wizard-gtk/wizard.c |  311 +++++++++++++++++--------------------------
 src/include/run_event.h     |  106 +++++++++++++++
 src/lib/run_event.c         |  227 ++++++++++++++++++++-----------
 3 files changed, 378 insertions(+), 266 deletions(-)

-- 
1.7.10.4

[PATCH 1/5] trac#622 : event command message prefix lengths computed at initialization

[Jakub Filak]

Signed-off-by: Jakub Filak <jfilak(a)redhat.com&gt;
---
 src/lib/run_event.c |   10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/lib/run_event.c b/src/lib/run_event.c
index 151b8be..2f9ec92 100644
--- a/src/lib/run_event.c
+++ b/src/lib/run_event.c
@@ -439,6 +439,11 @@ int run_event_on_dir_name(struct run_event_state *state,
                 const char *dump_dir_name,
                 const char *event
 ) {
+    static const size_t alert_prefix_len = sizeof(REPORT_PREFIX_ALERT) - 1;
+    static const size_t ask_prefix_len = sizeof(REPORT_PREFIX_ASK) - 1;
+    static const size_t ask_yes_no_prefix_len = sizeof(REPORT_PREFIX_ASK_YES_NO) - 1;
+    static const size_t ask_password_prefix_len = sizeof(REPORT_PREFIX_ASK_PASSWORD) -
1;
+
     prepare_commands(state, dump_dir_name, event);
 
     /* Execute every command in shell */
@@ -453,11 +458,6 @@ int run_event_on_dir_name(struct run_event_state *state,
         char *buf;
         char *msg;
 
-        int alert_prefix_len = strlen(REPORT_PREFIX_ALERT);
-        int ask_prefix_len = strlen(REPORT_PREFIX_ASK);
-        int ask_yes_no_prefix_len = strlen(REPORT_PREFIX_ASK_YES_NO);
-        int ask_password_prefix_len = strlen(REPORT_PREFIX_ASK_PASSWORD);
-
         while ((buf = xmalloc_fgetline(fp)) != NULL)
         {
             msg = buf;
-- 
1.7.10.4

[PATCH 1/5] trac#622 : event command message prefix lengths computed at initialization

[Nikola Pajkovsky]

Jakub Filak <jfilak(a)redhat.com&gt; writes:

>  Signed-off-by: Jakub Filak <jfilak(a)redhat.com&gt;
>  ---
>   src/lib/run_event.c |   10 +++++-----
>   1 file changed, 5 insertions(+), 5 deletions(-)
>
>  diff --git a/src/lib/run_event.c b/src/lib/run_event.c
>  index 151b8be..2f9ec92 100644
>  --- a/src/lib/run_event.c
>  +++ b/src/lib/run_event.c
>  @@ -439,6 +439,11 @@ int run_event_on_dir_name(struct run_event_state *state,
>                   const char *dump_dir_name,
>                   const char *event
>   ) {
>  +    static const size_t alert_prefix_len = sizeof(REPORT_PREFIX_ALERT) - 1;
>  +    static const size_t ask_prefix_len = sizeof(REPORT_PREFIX_ASK) - 1;
>  +    static const size_t ask_yes_no_prefix_len = sizeof(REPORT_PREFIX_ASK_YES_NO) - 1;
>  +    static const size_t ask_password_prefix_len = sizeof(REPORT_PREFIX_ASK_PASSWORD) -
> 1;
>  +
>       prepare_commands(state, dump_dir_name, event);
>   
>       /* Execute every command in shell */
>  @@ -453,11 +458,6 @@ int run_event_on_dir_name(struct run_event_state *state,
>           char *buf;
>           char *msg;
>   
>  -        int alert_prefix_len = strlen(REPORT_PREFIX_ALERT);
>  -        int ask_prefix_len = strlen(REPORT_PREFIX_ASK);
>  -        int ask_yes_no_prefix_len = strlen(REPORT_PREFIX_ASK_YES_NO);
>  -        int ask_password_prefix_len = strlen(REPORT_PREFIX_ASK_PASSWORD);
>  -
>           while ((buf = xmalloc_fgetline(fp)) != NULL)
>           {
>               msg = buf; 
I still don't get it, why are you/we using strncmp(var, "foo",
sizeof("foo") - 1) for prefix looking. there is way faster function
called _prefixcmp()_

-- 
Nikola

[PATCH 1/5] trac#622 : event command message prefix lengths computed at initialization

[Jakub Filak]

On Wednesday 18 of July 2012 13:42:15 Nikola Pajkovsky wrote:
>  Jakub Filak <jfilak(a)redhat.com&gt; writes:
>  > Signed-off-by: Jakub Filak <jfilak(a)redhat.com&gt;
>  > ---
>  > 
>  >  src/lib/run_event.c |   10 +++++-----
>  >  1 file changed, 5 insertions(+), 5 deletions(-)
>  > 
>  > diff --git a/src/lib/run_event.c b/src/lib/run_event.c
>  > index 151b8be..2f9ec92 100644
>  > --- a/src/lib/run_event.c
>  > +++ b/src/lib/run_event.c
>  > @@ -439,6 +439,11 @@ int run_event_on_dir_name(struct run_event_state
>  > *state,> 
>  >                  const char *dump_dir_name,
>  >                  const char *event
>  >  
>  >  ) {
>  > 
>  > +    static const size_t alert_prefix_len = sizeof(REPORT_PREFIX_ALERT) -
>  > 1; +    static const size_t ask_prefix_len = sizeof(REPORT_PREFIX_ASK) -
>  > 1; +    static const size_t ask_yes_no_prefix_len =
>  > sizeof(REPORT_PREFIX_ASK_YES_NO) - 1; +    static const size_t
>  > ask_password_prefix_len = sizeof(REPORT_PREFIX_ASK_PASSWORD) - 1; +
>  > 
>  >      prepare_commands(state, dump_dir_name, event);
>  >      
>  >      /* Execute every command in shell */
>  > 
>  > @@ -453,11 +458,6 @@ int run_event_on_dir_name(struct run_event_state
>  > *state,> 
>  >          char *buf;
>  >          char *msg;
>  > 
>  > -        int alert_prefix_len = strlen(REPORT_PREFIX_ALERT);
>  > -        int ask_prefix_len = strlen(REPORT_PREFIX_ASK);
>  > -        int ask_yes_no_prefix_len = strlen(REPORT_PREFIX_ASK_YES_NO);
>  > -        int ask_password_prefix_len = strlen(REPORT_PREFIX_ASK_PASSWORD);
>  > -
>  > 
>  >          while ((buf = xmalloc_fgetline(fp)) != NULL)
>  >          {
>  >          
>  >              msg = buf;
>  
>  I still don't get it, why are you/we using strncmp(var, "foo",
>  sizeof("foo") - 1) for prefix looking. there is way faster function
>  called _prefixcmp()_ 
You are right, the prefixcmp() fn is good. I always try to minimalize number 
of changed lines in working code and I didn't know that prefixcmp() exists ;)

I'll change it. But this change will break all of the remaining patches. 
Therefore I will not change it immediately but I'd rather wait for review 
comments of all patches.

Nikola, are you going to review the remaining patches?


Regards
Jakub

[PATCH 1/5] trac#622 : event command message prefix lengths computed at initialization

[Denys Vlasenko]

On 07/18/2012 01:01 PM, Jakub Filak wrote:
>  Signed-off-by: Jakub Filak <jfilak(a)redhat.com&gt;
>  ---
>   src/lib/run_event.c |   10 +++++-----
>   1 file changed, 5 insertions(+), 5 deletions(-)
>  
>  diff --git a/src/lib/run_event.c b/src/lib/run_event.c
>  index 151b8be..2f9ec92 100644
>  --- a/src/lib/run_event.c
>  +++ b/src/lib/run_event.c
>  @@ -439,6 +439,11 @@ int run_event_on_dir_name(struct run_event_state *state,
>                   const char *dump_dir_name,
>                   const char *event
>   ) {
>  +    static const size_t alert_prefix_len = sizeof(REPORT_PREFIX_ALERT) - 1;
>  +    static const size_t ask_prefix_len = sizeof(REPORT_PREFIX_ASK) - 1;
>  +    static const size_t ask_yes_no_prefix_len = sizeof(REPORT_PREFIX_ASK_YES_NO) - 1;
>  +    static const size_t ask_password_prefix_len = sizeof(REPORT_PREFIX_ASK_PASSWORD) -
> 1;
>  +
>       prepare_commands(state, dump_dir_name, event);
>   
>       /* Execute every command in shell */
>  @@ -453,11 +458,6 @@ int run_event_on_dir_name(struct run_event_state *state,
>           char *buf;
>           char *msg;
>   
>  -        int alert_prefix_len = strlen(REPORT_PREFIX_ALERT);
>  -        int ask_prefix_len = strlen(REPORT_PREFIX_ASK);
>  -        int ask_yes_no_prefix_len = strlen(REPORT_PREFIX_ASK_YES_NO);
>  -        int ask_password_prefix_len = strlen(REPORT_PREFIX_ASK_PASSWORD);
>  -
>           while ((buf = xmalloc_fgetline(fp)) != NULL)
>           {
>               msg = buf; 
This patch is ok (not very useful, though: compiler detects it by itself)

[PATCH 2/5] trac#622 : split run_event_on_dir_name() in to two functions

[Jakub Filak]

* introduced run_event_command_on_dir_name() which runs a command,
  handles a communication with the command and so on (the code of this
  function was originally placed in the run_event_on_dir_name())
* run_event_on_dir_name() uses the new run_event_command_on_dir_name()

Signed-off-by: Jakub Filak <jfilak(a)redhat.com&gt;
---
 src/lib/run_event.c |  179 ++++++++++++++++++++++++++-------------------------
 1 file changed, 91 insertions(+), 88 deletions(-)

diff --git a/src/lib/run_event.c b/src/lib/run_event.c
index 2f9ec92..105cef5 100644
--- a/src/lib/run_event.c
+++ b/src/lib/run_event.c
@@ -432,6 +432,96 @@ int spawn_next_command(struct run_event_state *state,
     return 0;
 }
 
+static int run_event_command_on_dir_name(struct run_event_state *state, const char
*dump_dir_name)
+{
+    static const size_t alert_prefix_len = sizeof(REPORT_PREFIX_ALERT) - 1;
+    static const size_t ask_prefix_len = sizeof(REPORT_PREFIX_ASK) - 1;
+    static const size_t ask_yes_no_prefix_len = sizeof(REPORT_PREFIX_ASK_YES_NO) - 1;
+    static const size_t ask_password_prefix_len = sizeof(REPORT_PREFIX_ASK_PASSWORD) -
1;
+
+    /* Consume log from stdout */
+    FILE *fp = fdopen(state->command_out_fd, "r");
+    if (!fp)
+        die_out_of_memory();
+
+    char *buf;
+    char *msg;
+
+    while ((buf = xmalloc_fgetline(fp)) != NULL)
+    {
+        msg = buf;
+
+        /* just cut off prefix, no waiting */
+        if (strncmp(REPORT_PREFIX_ALERT, msg, alert_prefix_len) == 0)
+        {
+            msg += alert_prefix_len;
+            printf("%s\n", msg);
+            fflush(stdout);
+        }
+        /* wait for y/N response on the same line */
+        else if (strncmp(REPORT_PREFIX_ASK_YES_NO, msg, ask_yes_no_prefix_len) == 0)
+        {
+            msg += ask_yes_no_prefix_len;
+            printf("%s [%s/%s] ", msg, _("y"), _("N"));
+            fflush(stdout);
+            char buf[16];
+            if (!fgets(buf, sizeof(buf), stdin))
+                buf[0] = '\0';
+
+            if (write(state->command_in_fd, buf, strlen(buf)) < 0)
+                perror_msg_and_die("write");
+        }
+        /* wait for the string on the same line */
+        else if (strncmp(REPORT_PREFIX_ASK, msg, ask_prefix_len) == 0)
+        {
+            msg += ask_prefix_len;
+            printf("%s ", msg);
+            fflush(stdout);
+            char buf[256];
+            if (!fgets(buf, sizeof(buf), stdin))
+                buf[0] = '\0';
+
+            if (write(state->command_in_fd, buf, strlen(buf)) < 0)
+                perror_msg_and_die("write");
+        }
+        /* set echo off and wait for password on the same line */
+        else if (strncmp(REPORT_PREFIX_ASK_PASSWORD, msg, ask_password_prefix_len) == 0)
+        {
+            msg += ask_password_prefix_len;
+            printf("%s ", msg);
+            fflush(stdout);
+            char buf[256];
+            bool changed = set_echo(false);
+            if (!fgets(buf, sizeof(buf), stdin))
+                buf[0] = '\0';
+            if (changed)
+                set_echo(true);
+
+            if (write(state->command_in_fd, buf, strlen(buf)) < 0)
+                perror_msg_and_die("write");
+        }
+        /* no special prefix -> forward to log if applicable
+         * note that callback may take ownership of buf by returning NULL */
+        else if (state->logging_callback)
+            buf = state->logging_callback(buf, state->logging_param);
+
+        free(buf);
+    }
+    fclose(fp); /* Got EOF, close. This also closes state->command_out_fd */
+
+    /* Wait for child to actually exit, collect status */
+    int status;
+    safe_waitpid(state->command_pid, &status, 0);
+
+    int retval = WEXITSTATUS(status);
+    if (WIFSIGNALED(status))
+        retval = WTERMSIG(status) + 128;
+
+    if (retval == 0 && state->post_run_callback)
+        retval = state->post_run_callback(dump_dir_name, state->post_run_param);
+
+    return retval;
+}
 
 /* Synchronous command execution:
  */
@@ -439,11 +529,6 @@ int run_event_on_dir_name(struct run_event_state *state,
                 const char *dump_dir_name,
                 const char *event
 ) {
-    static const size_t alert_prefix_len = sizeof(REPORT_PREFIX_ALERT) - 1;
-    static const size_t ask_prefix_len = sizeof(REPORT_PREFIX_ASK) - 1;
-    static const size_t ask_yes_no_prefix_len = sizeof(REPORT_PREFIX_ASK_YES_NO) - 1;
-    static const size_t ask_password_prefix_len = sizeof(REPORT_PREFIX_ASK_PASSWORD) -
1;
-
     prepare_commands(state, dump_dir_name, event);
 
     /* Execute every command in shell */
@@ -451,91 +536,9 @@ int run_event_on_dir_name(struct run_event_state *state,
     int retval = 0;
     while (spawn_next_command(state, dump_dir_name, event) >= 0)
     {
-        /* Consume log from stdout */
-        FILE *fp = fdopen(state->command_out_fd, "r");
-        if (!fp)
-            die_out_of_memory();
-        char *buf;
-        char *msg;
-
-        while ((buf = xmalloc_fgetline(fp)) != NULL)
-        {
-            msg = buf;
-
-            /* just cut off prefix, no waiting */
-            if (strncmp(REPORT_PREFIX_ALERT, msg, alert_prefix_len) == 0)
-            {
-                msg += alert_prefix_len;
-                printf("%s\n", msg);
-                fflush(stdout);
-            }
-            /* wait for y/N response on the same line */
-            else if (strncmp(REPORT_PREFIX_ASK_YES_NO, msg, ask_yes_no_prefix_len) == 0)
-            {
-                msg += ask_yes_no_prefix_len;
-                printf("%s [%s/%s] ", msg, _("y"),
_("N"));
-                fflush(stdout);
-                char buf[16];
-                if (!fgets(buf, sizeof(buf), stdin))
-                    buf[0] = '\0';
-
-                if (write(state->command_in_fd, buf, strlen(buf)) < 0)
-                    perror_msg_and_die("write");
-            }
-            /* wait for the string on the same line */
-            else if (strncmp(REPORT_PREFIX_ASK, msg, ask_prefix_len) == 0)
-            {
-                msg += ask_prefix_len;
-                printf("%s ", msg);
-                fflush(stdout);
-                char buf[256];
-                if (!fgets(buf, sizeof(buf), stdin))
-                    buf[0] = '\0';
-
-                if (write(state->command_in_fd, buf, strlen(buf)) < 0)
-                    perror_msg_and_die("write");
-            }
-            /* set echo off and wait for password on the same line */
-            else if (strncmp(REPORT_PREFIX_ASK_PASSWORD, msg, ask_password_prefix_len) ==
0)
-            {
-                msg += ask_password_prefix_len;
-                printf("%s ", msg);
-                fflush(stdout);
-                char buf[256];
-                bool changed = set_echo(false);
-                if (!fgets(buf, sizeof(buf), stdin))
-                    buf[0] = '\0';
-                if (changed)
-                    set_echo(true);
-
-                if (write(state->command_in_fd, buf, strlen(buf)) < 0)
-                    perror_msg_and_die("write");
-            }
-            /* no special prefix -> forward to log if applicable
-             * note that callback may take ownership of buf by returning NULL */
-            else if (state->logging_callback)
-                buf = state->logging_callback(buf, state->logging_param);
-
-            free(buf);
-        }
-        fclose(fp); /* Got EOF, close. This also closes state->command_out_fd */
-
-        /* Wait for child to actually exit, collect status */
-        int status;
-        safe_waitpid(state->command_pid, &status, 0);
-
-        retval = WEXITSTATUS(status);
-        if (WIFSIGNALED(status))
-            retval = WTERMSIG(status) + 128;
+        retval = run_event_command_on_dir_name(state, dump_dir_name);
         if (retval != 0)
             break;
-
-        if (state->post_run_callback)
-        {
-            retval = state->post_run_callback(dump_dir_name,
state->post_run_param);
-            if (retval != 0)
-                break;
-        }
     }
 
     free_commands(state);
-- 
1.7.10.4

[PATCH 2/5] trac#622 : split run_event_on_dir_name() in to two functions

[Denys Vlasenko]

On 07/18/2012 01:01 PM, Jakub Filak wrote:
>  * introduced run_event_command_on_dir_name() which runs a command,
>    handles a communication with the command and so on (the code of this
>    function was originally placed in the run_event_on_dir_name())
>  * run_event_on_dir_name() uses the new run_event_command_on_dir_name()
>  
>  Signed-off-by: Jakub Filak <jfilak(a)redhat.com&gt;
>  ---
>   src/lib/run_event.c |  179 ++++++++++++++++++++++++++-------------------------
>   1 file changed, 91 insertions(+), 88 deletions(-)
>  
>  diff --git a/src/lib/run_event.c b/src/lib/run_event.c
>  index 2f9ec92..105cef5 100644
>  --- a/src/lib/run_event.c
>  +++ b/src/lib/run_event.c
>  @@ -432,6 +432,96 @@ int spawn_next_command(struct run_event_state *state,
>       return 0;
>   }
>   
>  +static int run_event_command_on_dir_name(struct run_event_state *state, const char
> *dump_dir_name) 
I think the name can be better. This function doesn't run (as in "start")
anything, it just eats output until EOF, then collects exit status.

The rest looks ok to me.

[PATCH 3/5] trac#622 : use callbacks in run_event_command_on_dir_name()

[Jakub Filak]

* the implementations of event command request handlers were moved in to
  separate functions
* the request handlers are called through run_event_state callbacks

Signed-off-by: Jakub Filak <jfilak(a)redhat.com&gt;
---
 src/include/run_event.h |   88 +++++++++++++++++++++++++++++++++++++++++++
 src/lib/run_event.c     |   96 ++++++++++++++++++++++++++++++++---------------
 2 files changed, 154 insertions(+), 30 deletions(-)

diff --git a/src/include/run_event.h b/src/include/run_event.h
index 43730ce..4577444 100644
--- a/src/include/run_event.h
+++ b/src/include/run_event.h
@@ -40,6 +40,57 @@ struct run_event_state {
     char* (*logging_callback)(char *log_line, void *param);
     void *logging_param;
 
+    /*
+     * An optional argument for the following callbacks
+     */
+    void *interaction_param;
+
+    /*
+     * Called when child command produced an alert.
+     *
+     * The default value is run_event_stdio_alert()
+     *
+     * @param msg An alert message produced byt child command
+     * @param args An interaction param
+     */
+    void (*alert_callback)(const char *msg, void *interaction_param);
+
+    /*
+     * Called when child command ask for some input. A callee
+     * should return a text whithout any new line character.
+     *
+     * The default value is run_event_stdio_ask()
+     *
+     * @param msg An ask message produced by child command
+     * @param args An interaction param
+     * @return Must allways return string without new lines, an empty string
+     *         if response was not get.
+     */
+    char *(*ask_callback)(const char *msg, void *interaction_param);
+
+    /*
+     * Called when child command wants to know 'yes/no' decision.
+     *
+     * The default value is run_event_stdio_ask_yes_no()
+     *
+     * @param msg An ask message produced by child command
+     * @param args An implementor args
+     * @return Return 0 if an answer is NO, otherwise return nonzero value.
+     */
+    int (*ask_yes_no_callback)(const char *msg, void *interaction_param);
+
+    /*
+     * Called when child wants to know a password.
+     *
+     * The default value is run_event_stdio_ask_password()
+     *
+     * @param msg An ask message produced by child command
+     * @param args An interaction param
+     * @return Must allways return string without new lines, an empty string
+     *         if password was not get.
+     */
+    char *(*ask_password_callback)(const char *msg, void *interaction_param);
+
     /* Internal data for async command execution */
     GList *rule_list;
     pid_t command_pid;
@@ -76,6 +127,43 @@ int run_event_on_problem_data(struct run_event_state *state,
problem_data_t *dat
  */
 char *list_possible_events(struct dump_dir *dd, const char *dump_dir_name, const char
*pfx);
 
+/* Command line run event callback implemenetation */
+
+/*
+ * Prints the msg param on stdout
+ *
+ * @param msg a printed message
+ * @param param UNUSED
+ */
+void run_event_stdio_alert(const char *msg, void *param);
+
+/*
+ * Prints the msg param on stdout and reads a response from stdin
+ *
+ * @param msg a printed message
+ * @param param UNUSED
+ * @return a malloced string with response, an empty string on error or no response
+ */
+char *run_event_stdio_ask(const char *msg, void *param);
+
+/*
+ * Prints the msg param on stdout and reads a response from stdin
+ *
+ * @param msg a printed message
+ * @param param UNUSED
+ * @return 0 if user's answer is 'no', otherwise non 0 value
+ */
+int run_event_stdio_ask_yes_no(const char *msg, void *param);
+
+/*
+ * Prints the msg param on stdout and reads a response from stdin
+ *
+ * @param msg a printed message
+ * @param param UNUSED
+ * @return a malloced string with response, an empty string on error or no response
+ */
+char *run_event_stdio_ask_password(const char *msg, void *param);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/lib/run_event.c b/src/lib/run_event.c
index 105cef5..ab6d79c 100644
--- a/src/lib/run_event.c
+++ b/src/lib/run_event.c
@@ -23,7 +23,14 @@
 
 struct run_event_state *new_run_event_state()
 {
-    return xzalloc(sizeof(struct run_event_state));
+    struct run_event_state *state = xzalloc(sizeof(struct run_event_state));
+
+    state->alert_callback = run_event_stdio_alert;
+    state->ask_callback = run_event_stdio_ask;
+    state->ask_yes_no_callback = run_event_stdio_ask_yes_no;
+    state->ask_password_callback = run_event_stdio_ask_password;
+
+    return state;
 }
 
 void free_run_event_state(struct run_event_state *state)
@@ -451,60 +458,48 @@ static int run_event_command_on_dir_name(struct run_event_state
*state, const ch
     {
         msg = buf;
 
+        char *response = NULL;
         /* just cut off prefix, no waiting */
         if (strncmp(REPORT_PREFIX_ALERT, msg, alert_prefix_len) == 0)
         {
             msg += alert_prefix_len;
-            printf("%s\n", msg);
-            fflush(stdout);
+            state->alert_callback(msg, state->interaction_param);
         }
         /* wait for y/N response on the same line */
         else if (strncmp(REPORT_PREFIX_ASK_YES_NO, msg, ask_yes_no_prefix_len) == 0)
         {
             msg += ask_yes_no_prefix_len;
-            printf("%s [%s/%s] ", msg, _("y"), _("N"));
-            fflush(stdout);
-            char buf[16];
-            if (!fgets(buf, sizeof(buf), stdin))
-                buf[0] = '\0';
-
-            if (write(state->command_in_fd, buf, strlen(buf)) < 0)
-                perror_msg_and_die("write");
+            const bool ans = state->ask_yes_no_callback(msg,
state->interaction_param);
+            response = xstrdup(ans ? "yes" : "no");
         }
         /* wait for the string on the same line */
         else if (strncmp(REPORT_PREFIX_ASK, msg, ask_prefix_len) == 0)
         {
             msg += ask_prefix_len;
-            printf("%s ", msg);
-            fflush(stdout);
-            char buf[256];
-            if (!fgets(buf, sizeof(buf), stdin))
-                buf[0] = '\0';
-
-            if (write(state->command_in_fd, buf, strlen(buf)) < 0)
-                perror_msg_and_die("write");
+            response = state->ask_callback(msg, state->interaction_param);
         }
         /* set echo off and wait for password on the same line */
         else if (strncmp(REPORT_PREFIX_ASK_PASSWORD, msg, ask_password_prefix_len) == 0)
         {
             msg += ask_password_prefix_len;
-            printf("%s ", msg);
-            fflush(stdout);
-            char buf[256];
-            bool changed = set_echo(false);
-            if (!fgets(buf, sizeof(buf), stdin))
-                buf[0] = '\0';
-            if (changed)
-                set_echo(true);
-
-            if (write(state->command_in_fd, buf, strlen(buf)) < 0)
-                perror_msg_and_die("write");
+            response = state->ask_password_callback(msg,
state->interaction_param);
         }
         /* no special prefix -> forward to log if applicable
          * note that callback may take ownership of buf by returning NULL */
         else if (state->logging_callback)
             buf = state->logging_callback(buf, state->logging_param);
 
+        if (response)
+        {
+            size_t len = strlen(response);
+            response[len++] = '\n';
+
+            if (full_write(state->command_in_fd, response, len) != len)
+                perror_msg_and_die("Can't write %lu bytes to child's
stdin", len);
+
+            free(response);
+        }
+
         free(buf);
     }
     fclose(fp); /* Got EOF, close. This also closes state->command_out_fd */
@@ -612,3 +607,44 @@ char *list_possible_events(struct dump_dir *dd, const char
*dump_dir_name, const
 
     return strbuf_free_nobuf(result);
 }
+
+void run_event_stdio_alert(const char *msg, void *param)
+{
+    printf("%s\n", msg);
+    fflush(stdout);
+}
+
+char *run_event_stdio_ask(const char *msg, void *param)
+{
+    printf("%s ", msg);
+    fflush(stdout);
+    char buf[256];
+    if (!safe_read(STDIN_FILENO, buf, sizeof(buf)))
+        buf[0] = '\0';
+    else
+        strtrimch(buf, '\n');
+
+    return xstrdup(buf);
+}
+
+int run_event_stdio_ask_yes_no(const char *msg, void *param)
+{
+    printf("%s [%s/%s] ", msg, _("y"), _("N"));
+    fflush(stdout);
+    char buf[16];
+    if (!safe_read(STDIN_FILENO, buf, sizeof(buf)))
+        return false;
+
+    return buf[0] == 'y' && (buf[1] == '\n' || buf[1] ==
'\0');
+}
+
+char *run_event_stdio_ask_password(const char *msg, void *param)
+{
+    const bool changed = set_echo(false);
+    char *const password = run_event_stdio_ask(msg, param);
+
+    if (changed)
+        set_echo(true);
+
+    return password;
+}
-- 
1.7.10.4

[PATCH 3/5] trac#622 : use callbacks in run_event_command_on_dir_name()

[Denys Vlasenko]

On 07/18/2012 01:01 PM, Jakub Filak wrote:
>  +        if (response)
>  +        {
>  +            size_t len = strlen(response);
>  +            response[len++] = '\n';
>  +
>  +            if (full_write(state->command_in_fd, response, len) != len)
>  +                perror_msg_and_die("Can't write %lu bytes to child's
> stdin", len); 
%lu means "unsigned long". I would add a cast: (unsigned long)len.

>  +
>  +            free(response);
>  +        }
>  +
>           free(buf);
>       }
>       fclose(fp); /* Got EOF, close. This also closes state->command_out_fd */
>  @@ -612,3 +607,44 @@ char *list_possible_events(struct dump_dir *dd, const char
> *dump_dir_name, const
>   
>       return strbuf_free_nobuf(result);
>   }
>  +
>  +void run_event_stdio_alert(const char *msg, void *param)
>  +{
>  +    printf("%s\n", msg);
>  +    fflush(stdout);
>  +}
>  +
>  +char *run_event_stdio_ask(const char *msg, void *param)
>  +{
>  +    printf("%s ", msg);
>  +    fflush(stdout);
>  +    char buf[256];
>  +    if (!safe_read(STDIN_FILENO, buf, sizeof(buf))) 
If you name them ..._stdio_..., I would use stdio functions consistently
in all callbacks. Here, I'd use fgets, not safe_read.

-- 
vda

[PATCH 3/5] trac#622 : use callbacks in run_event_command_on_dir_name()

[Jakub Filak]

On Wednesday 18 of July 2012 15:55:30 Denys Vlasenko wrote:
>  On 07/18/2012 01:01 PM, Jakub Filak wrote:
>  > +        if (response)
>  > +        {
>  > +            size_t len = strlen(response);
>  > +            response[len++] = '\n';
>  > +
>  > +            if (full_write(state->command_in_fd, response, len) != len)
>  > +                perror_msg_and_die("Can't write %lu bytes to child's
>  > stdin", len);
>  %lu means "unsigned long". I would add a cast: (unsigned long)len.
>  
>  > +
>  > +            free(response);
>  > +        }
>  > +
>  > 
>  >          free(buf);
>  >      
>  >      }
>  >      fclose(fp); /* Got EOF, close. This also closes state->command_out_fd
>  >      */
>  > 
>  > @@ -612,3 +607,44 @@ char *list_possible_events(struct dump_dir *dd, const
>  > char *dump_dir_name, const> 
>  >      return strbuf_free_nobuf(result);
>  >  
>  >  }
>  > 
>  > +
>  > +void run_event_stdio_alert(const char *msg, void *param)
>  > +{
>  > +    printf("%s\n", msg);
>  > +    fflush(stdout);
>  > +}
>  > +
>  > +char *run_event_stdio_ask(const char *msg, void *param)
>  > +{
>  > +    printf("%s ", msg);
>  > +    fflush(stdout);
>  > +    char buf[256];
>  > +    if (!safe_read(STDIN_FILENO, buf, sizeof(buf)))
>  
>  If you name them ..._stdio_..., I would use stdio functions consistently
>  in all callbacks. Here, I'd use fgets, not safe_read. 
Should I take care of EINTR? (I always use CTRL+Z everywhere.)

[PATCH 3/5] trac#622 : use callbacks in run_event_command_on_dir_name()

[Jakub Filak]

On Wednesday 18 of July 2012 16:33:32 Jakub Filak wrote:
>  On Wednesday 18 of July 2012 15:55:30 Denys Vlasenko wrote:
>  > On 07/18/2012 01:01 PM, Jakub Filak wrote:
>  > > +        if (response)
>  > > +        {
>  > > +            size_t len = strlen(response);
>  > > +            response[len++] = '\n';
>  > > +
>  > > +            if (full_write(state->command_in_fd, response, len) != len)
>  > > +                perror_msg_and_die("Can't write %lu bytes to
> child's
>  > > stdin", len);
>  > 
>  > %lu means "unsigned long". I would add a cast: (unsigned long)len.
>  > 
>  > > +
>  > > +            free(response);
>  > > +        }
>  > > +
>  > > 
>  > >          free(buf);
>  > >      
>  > >      }
>  > >      fclose(fp); /* Got EOF, close. This also closes
>  > >      state->command_out_fd
>  > >      */
>  > > 
>  > > @@ -612,3 +607,44 @@ char *list_possible_events(struct dump_dir *dd,
>  > > const
>  > > char *dump_dir_name, const>
>  > > 
>  > >      return strbuf_free_nobuf(result);
>  > >  
>  > >  }
>  > > 
>  > > +
>  > > +void run_event_stdio_alert(const char *msg, void *param)
>  > > +{
>  > > +    printf("%s\n", msg);
>  > > +    fflush(stdout);
>  > > +}
>  > > +
>  > > +char *run_event_stdio_ask(const char *msg, void *param)
>  > > +{
>  > > +    printf("%s ", msg);
>  > > +    fflush(stdout);
>  > > +    char buf[256];
>  > > +    if (!safe_read(STDIN_FILENO, buf, sizeof(buf)))
>  > 
>  > If you name them ..._stdio_..., I would use stdio functions consistently
>  > in all callbacks. Here, I'd use fgets, not safe_read.
>  
>  Should I take care of EINTR? (I always use CTRL+Z everywhere.) 
The answer is 'no' :)

[PATCH 3/5] trac#622 : use callbacks in run_event_command_on_dir_name()

[Nikola Pajkovsky]

Denys Vlasenko <dvlasenk(a)redhat.com&gt; writes:

>  On 07/18/2012 01:01 PM, Jakub Filak wrote:
> > +        if (response)
> > +        {
> > +            size_t len = strlen(response);
> > +            response[len++] = '\n';
> > +
> > +            if (full_write(state->command_in_fd, response, len) != len)
> > +                perror_msg_and_die("Can't write %lu bytes to child's
> stdin", len);
>
>  %lu means "unsigned long". I would add a cast: (unsigned long)len. 
or without casting, you can use %zu, which is intend for size_t type

> > +
> > +            free(response);
> > +        }
> > +
> >          free(buf);
> >      }
> >      fclose(fp); /* Got EOF, close. This also closes state->command_out_fd */
> > @@ -612,3 +607,44 @@ char *list_possible_events(struct dump_dir *dd, const char
> *dump_dir_name, const
> >  
> >      return strbuf_free_nobuf(result);
> >  }
> > +
> > +void run_event_stdio_alert(const char *msg, void *param)
> > +{
> > +    printf("%s\n", msg);
> > +    fflush(stdout);
> > +}
> > +
> > +char *run_event_stdio_ask(const char *msg, void *param)
> > +{
> > +    printf("%s ", msg);
> > +    fflush(stdout);
> > +    char buf[256];
> > +    if (!safe_read(STDIN_FILENO, buf, sizeof(buf)))
>
>  If you name them ..._stdio_..., I would use stdio functions consistently
>  in all callbacks. Here, I'd use fgets, not safe_read. 
-- 
Nikola

[PATCH 3/5] trac#622 : use callbacks in run_event_command_on_dir_name()

[Jakub Filak]

On Wednesday 18 of July 2012 16:35:06 Nikola Pajkovsky wrote:
>  Denys Vlasenko <dvlasenk(a)redhat.com&gt; writes:
>  > On 07/18/2012 01:01 PM, Jakub Filak wrote:
>  >> +        if (response)
>  >> +        {
>  >> +            size_t len = strlen(response);
>  >> +            response[len++] = '\n';
>  >> +
>  >> +            if (full_write(state->command_in_fd, response, len) != len)
>  >> +                perror_msg_and_die("Can't write %lu bytes to
> child's
>  >> stdin", len);> 
>  > %lu means "unsigned long". I would add a cast: (unsigned long)len.
>  
>  or without casting, you can use %zu, which is intend for size_t type 
nice, thanks

>  
>  >> +
>  >> +            free(response);
>  >> +        }
>  >> +
>  >> 
>  >>          free(buf);
>  >>      
>  >>      }
>  >>      fclose(fp); /* Got EOF, close. This also closes
>  >>      state->command_out_fd */
>  >> 
>  >> @@ -612,3 +607,44 @@ char *list_possible_events(struct dump_dir *dd,
>  >> const char *dump_dir_name, const>> 
>  >>      return strbuf_free_nobuf(result);
>  >>  
>  >>  }
>  >> 
>  >> +
>  >> +void run_event_stdio_alert(const char *msg, void *param)
>  >> +{
>  >> +    printf("%s\n", msg);
>  >> +    fflush(stdout);
>  >> +}
>  >> +
>  >> +char *run_event_stdio_ask(const char *msg, void *param)
>  >> +{
>  >> +    printf("%s ", msg);
>  >> +    fflush(stdout);
>  >> +    char buf[256];
>  >> +    if (!safe_read(STDIN_FILENO, buf, sizeof(buf)))
>  > 
>  > If you name them ..._stdio_..., I would use stdio functions consistently
>  > in all callbacks. Here, I'd use fgets, not safe_read.

[PATCH 4/5] trac#622 : adds support for nonblocking reads from child's stdout

[Jakub Filak]

* expose run_event_command_on_dir_name()
* add buffering of incomplete lines

Signed-off-by: Jakub Filak <jfilak(a)redhat.com&gt;
---
 src/include/run_event.h |   13 +++++
 src/lib/run_event.c     |  124 ++++++++++++++++++++++++++++-------------------
 2 files changed, 88 insertions(+), 49 deletions(-)

diff --git a/src/include/run_event.h b/src/include/run_event.h
index 4577444..40caaa4 100644
--- a/src/include/run_event.h
+++ b/src/include/run_event.h
@@ -96,6 +96,7 @@ struct run_event_state {
     pid_t command_pid;
     int command_out_fd;
     int command_in_fd;
+    struct strbuf *command_output;
 };
 struct run_event_state *new_run_event_state(void);
 void free_run_event_state(struct run_event_state *state);
@@ -113,6 +114,18 @@ void free_commands(struct run_event_state *state);
 
 /* Synchronous command execution */
 
+/* The function believes that a state param value is fully initialized and
+ * action is started.
+ *
+ * Returns exit code of action, or nonzero return value of post_run_callback
+ * If action is successful, returns 0.
+ *
+ * If return value is lower than 0 and you set O_NONBLOCK to command's out fd
+ * examine errno to detect EAGAIN case. Incomplete child lines are buffered
+ * in the state param.
+ */
+int run_event_command_on_dir_name(struct run_event_state *state, const char
*dump_dir_name);
+
 /* Returns exit code of first failed action, or first nonzero return value
  * of post_run_callback. If all actions are successful, returns 0.
  */
diff --git a/src/lib/run_event.c b/src/lib/run_event.c
index ab6d79c..78b3b4a 100644
--- a/src/lib/run_event.c
+++ b/src/lib/run_event.c
@@ -30,6 +30,8 @@ struct run_event_state *new_run_event_state()
     state->ask_yes_no_callback = run_event_stdio_ask_yes_no;
     state->ask_password_callback = run_event_stdio_ask_password;
 
+    state->command_output = strbuf_new();
+
     return state;
 }
 
@@ -37,6 +39,7 @@ void free_run_event_state(struct run_event_state *state)
 {
     if (state)
     {
+        strbuf_free(state->command_output);
         free_commands(state);
         free(state);
     }
@@ -373,6 +376,7 @@ int prepare_commands(struct run_event_state *state,
     free_commands(state);
 
     state->children_count = 0;
+    strbuf_clear(state->command_output);
 
     GList *rule_list = load_rule_list(NULL, CONF_DIR"/report_event.conf",
/*recursion_depth:*/ 0);
     state->rule_list = rule_list;
@@ -439,70 +443,92 @@ int spawn_next_command(struct run_event_state *state,
     return 0;
 }
 
-static int run_event_command_on_dir_name(struct run_event_state *state, const char
*dump_dir_name)
+int run_event_command_on_dir_name(struct run_event_state *state, const char
*dump_dir_name)
 {
     static const size_t alert_prefix_len = sizeof(REPORT_PREFIX_ALERT) - 1;
     static const size_t ask_prefix_len = sizeof(REPORT_PREFIX_ASK) - 1;
     static const size_t ask_yes_no_prefix_len = sizeof(REPORT_PREFIX_ASK_YES_NO) - 1;
     static const size_t ask_password_prefix_len = sizeof(REPORT_PREFIX_ASK_PASSWORD) -
1;
 
-    /* Consume log from stdout */
-    FILE *fp = fdopen(state->command_out_fd, "r");
-    if (!fp)
-        die_out_of_memory();
-
-    char *buf;
-    char *msg;
-
-    while ((buf = xmalloc_fgetline(fp)) != NULL)
+    int r = 0;
+    char buf[256];
+    errno = 0;
+    struct strbuf *cmd_output = state->command_output;
+    while ((r = safe_read(state->command_out_fd, buf, sizeof(buf) - 1)) > 0)
     {
-        msg = buf;
+        char *newline;
+        char *raw;
+        buf[r] = '\0';
+        raw = buf;
 
-        char *response = NULL;
-        /* just cut off prefix, no waiting */
-        if (strncmp(REPORT_PREFIX_ALERT, msg, alert_prefix_len) == 0)
-        {
-            msg += alert_prefix_len;
-            state->alert_callback(msg, state->interaction_param);
-        }
-        /* wait for y/N response on the same line */
-        else if (strncmp(REPORT_PREFIX_ASK_YES_NO, msg, ask_yes_no_prefix_len) == 0)
-        {
-            msg += ask_yes_no_prefix_len;
-            const bool ans = state->ask_yes_no_callback(msg,
state->interaction_param);
-            response = xstrdup(ans ? "yes" : "no");
-        }
-        /* wait for the string on the same line */
-        else if (strncmp(REPORT_PREFIX_ASK, msg, ask_prefix_len) == 0)
+        while ((newline = strchr(raw, '\n')) != NULL)
         {
-            msg += ask_prefix_len;
-            response = state->ask_callback(msg, state->interaction_param);
-        }
-        /* set echo off and wait for password on the same line */
-        else if (strncmp(REPORT_PREFIX_ASK_PASSWORD, msg, ask_password_prefix_len) == 0)
-        {
-            msg += ask_password_prefix_len;
-            response = state->ask_password_callback(msg,
state->interaction_param);
-        }
-        /* no special prefix -> forward to log if applicable
-         * note that callback may take ownership of buf by returning NULL */
-        else if (state->logging_callback)
-            buf = state->logging_callback(buf, state->logging_param);
+            *newline = '\0';
+            strbuf_append_str(cmd_output, raw);
+            char *msg = cmd_output->buf;
+            size_t skip_chars = 0;
 
-        if (response)
-        {
-            size_t len = strlen(response);
-            response[len++] = '\n';
+            char *response = NULL;
 
-            if (full_write(state->command_in_fd, response, len) != len)
-                perror_msg_and_die("Can't write %lu bytes to child's
stdin", len);
+            /* just cut off prefix, no waiting */
+            if (strncmp(REPORT_PREFIX_ALERT, msg, alert_prefix_len) == 0)
+            {
+                skip_chars = alert_prefix_len;
+                state->alert_callback(msg + skip_chars, state->interaction_param);
+            }
+            /* wait for y/N response on the same line */
+            else if (strncmp(REPORT_PREFIX_ASK_YES_NO, msg, ask_yes_no_prefix_len) == 0)
+            {
+                skip_chars = ask_yes_no_prefix_len;
+                const bool ans = state->ask_yes_no_callback(msg + skip_chars,
state->interaction_param);
+                response = xstrdup(ans ? "yes" : "no");
+            }
+            /* wait for the string on the same line */
+            else if (strncmp(REPORT_PREFIX_ASK, msg, ask_prefix_len) == 0)
+            {
+                skip_chars = ask_prefix_len;
+                response = state->ask_callback(msg + skip_chars,
state->interaction_param);
+            }
+            /* set echo off and wait for password on the same line */
+            else if (strncmp(REPORT_PREFIX_ASK_PASSWORD, msg, ask_password_prefix_len) ==
0)
+            {
+                skip_chars = ask_password_prefix_len;
+                response = state->ask_password_callback(msg + skip_chars,
state->interaction_param);
+            }
+            /* no special prefix -> forward to log if applicable
+             * note that callback may take ownership of buf by returning NULL */
+            else if (state->logging_callback)
+            {
+                char *logged = state->logging_callback(xstrdup(msg),
state->logging_param);
+                free(logged);
+            }
+
+            if (response)
+            {
+                size_t len = strlen(response);
+                response[len++] = '\n';
 
-            free(response);
+                if (full_write(state->command_in_fd, response, len) != len)
+                    perror_msg_and_die("Can't write %lu bytes to child's
stdin", len);
+
+                free(response);
+            }
+
+            strbuf_clear(cmd_output);
+
+            /* jump to next line */
+            raw = newline + 1;
         }
 
-        free(buf);
+        /* beginning of next line. the line continues by next read() */
+        strbuf_append_str(cmd_output, raw);
     }
-    fclose(fp); /* Got EOF, close. This also closes state->command_out_fd */
+
+    /* Hope that child's stdout fd was set to O_NONBLOCK */
+    if (r == -1 && errno == EAGAIN)
+        return -1;
+
+    strbuf_clear(cmd_output);
 
     /* Wait for child to actually exit, collect status */
     int status;
-- 
1.7.10.4

[PATCH 4/5] trac#622 : adds support for nonblocking reads from child's stdout

[Denys Vlasenko]

On 07/18/2012 01:01 PM, Jakub Filak wrote:
>  * expose run_event_command_on_dir_name()
>  * add buffering of incomplete lines 

Looks good to me.

-- 
vda

[PATCH 5/5] trac#622 : report-gtk uses run_event_command_on_dir_name()

[Jakub Filak]

* report-gtk had own implementation of communication with event command
* this patch removes code duplication
* this patch should improve maintainability and simplify implementation

Signed-off-by: Jakub Filak <jfilak(a)redhat.com&gt;
---
 src/gui-wizard-gtk/wizard.c |  311 +++++++++++++++++--------------------------
 src/include/run_event.h     |   10 ++
 src/lib/run_event.c         |   16 ++-
 3 files changed, 142 insertions(+), 195 deletions(-)

diff --git a/src/gui-wizard-gtk/wizard.c b/src/gui-wizard-gtk/wizard.c
index 0e76c78..bf010a2 100644
--- a/src/gui-wizard-gtk/wizard.c
+++ b/src/gui-wizard-gtk/wizard.c
@@ -1282,218 +1282,139 @@ static void on_btn_cancel_event(GtkButton *button)
         kill(- g_event_child_pid, SIGTERM);
 }
 
-static gboolean consume_cmd_output(GIOChannel *source, GIOCondition condition, gpointer
data)
+static void update_command_run_log(const char* message, struct analyze_event_data *evd)
 {
-    struct analyze_event_data *evd = data;
+    gtk_label_set_text(g_lbl_event_log, message);
+
+    char *log_msg = xasprintf("%s\n", message);
+    append_to_textview(evd->tv_log, log_msg);
+    save_to_event_log(evd, log_msg);
+    free(log_msg);
+}
+
+static void run_event_gtk_error(const char *error_line, void *param)
+{
+    update_command_run_log(error_line, (struct analyze_event_data *)param);
+}
+
+static char *run_event_gtk_logging(char *log_line, void *param)
+{
+    update_command_run_log(log_line, (struct analyze_event_data *)param);
+    return log_line;
+}
+
+static void log_request_response_communication(const char *request, const char *response,
struct analyze_event_data *evd)
+{
+    char *message = xasprintf(response ? "%s '%s'" : "%s",
request, response);
+    update_command_run_log(message, evd);
+    free(message);
+}
+
+static void run_event_gtk_alert(const char *msg, void *args)
+{
+    GtkWidget *dialog = gtk_message_dialog_new(GTK_WINDOW(g_wnd_assistant),
+            GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
+            GTK_MESSAGE_WARNING,
+            GTK_BUTTONS_CLOSE,
+            "%s", msg);
+    char *tagged_msg = tag_url(msg, "\n");
+    gtk_message_dialog_set_markup(GTK_MESSAGE_DIALOG(dialog), tagged_msg);
+    free(tagged_msg);
+
+    gtk_dialog_run(GTK_DIALOG(dialog));
+    gtk_widget_destroy(dialog);
+
+    log_request_response_communication(msg, NULL, (struct analyze_event_data *)args);
+}
+
+static char *ask_helper(const char *msg, void *args, bool password)
+{
+    GtkWidget *dialog = gtk_message_dialog_new(GTK_WINDOW(g_wnd_assistant),
+            GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
+            GTK_MESSAGE_QUESTION,
+            GTK_BUTTONS_OK_CANCEL,
+            "%s", msg);
+    char *tagged_msg = tag_url(msg, "\n");
+    gtk_message_dialog_set_markup(GTK_MESSAGE_DIALOG(dialog), tagged_msg);
+    free(tagged_msg);
+
+    GtkWidget *vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
+    GtkWidget *textbox = gtk_entry_new();
+    /* gtk_entry_set_editable(GTK_ENTRY(textbox), TRUE);
+     * is not available in gtk3, so please use the highlevel
+     * g_object_set
+     */
+    g_object_set(G_OBJECT(textbox), "editable", TRUE, NULL);
 
-    /* Read and insert the output into the log pane */
-    char buf[257]; /* usually we get one line, no need to have big buf */
-    int r;
-    int alert_prefix_len = strlen(REPORT_PREFIX_ALERT);
-    int ask_prefix_len = strlen(REPORT_PREFIX_ASK);
-    int ask_yes_no_prefix_len = strlen(REPORT_PREFIX_ASK_YES_NO);
-    int ask_password_prefix_len = strlen(REPORT_PREFIX_ASK_PASSWORD);
+    if (password)
+        gtk_entry_set_visibility(GTK_ENTRY(textbox), FALSE);
 
-    if (!cmd_output)
-        cmd_output = strbuf_new();
+    gtk_box_pack_start(GTK_BOX(vbox), textbox, TRUE, TRUE, 0);
+    gtk_widget_show(textbox);
 
-    /* read buffered and split lines */
-    while ((r = read(evd->fd, buf, sizeof(buf) - 1)) > 0)
+    char *response = NULL;
+    if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK)
     {
-        char *newline;
-        char *raw;
-        buf[r] = '\0';
-        raw = buf;
+        const char *text = gtk_entry_get_text(GTK_ENTRY(textbox));
+        response = xstrdup(text);
+    }
 
-        /* split lines in the current buffer */
-        while ((newline = strchr(raw, '\n')) != NULL)
-        {
-            *newline = '\0';
-            strbuf_append_str(cmd_output, raw);
-            char *msg = cmd_output->buf;
-
-            /* In the code below:
-             * response is always malloced,
-             * log_response is always set to response
-             * or to constant string.
-             */
-            char *response = NULL;
-            const char *log_response = response;
-            unsigned skip_chars = 0;
+    gtk_widget_destroy(textbox);
+    gtk_widget_destroy(dialog);
 
-            char * tagged_msg = NULL;
+    const char *log_response = "";
+    if (response)
+        log_response = password ? "********" : response;
 
-            /* alert dialog */
-            if (strncmp(REPORT_PREFIX_ALERT, msg, alert_prefix_len) == 0)
-            {
-                skip_chars = alert_prefix_len;
-
-                GtkWidget *dialog = gtk_message_dialog_new(GTK_WINDOW(g_wnd_assistant),
-                    GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
-                    GTK_MESSAGE_WARNING,
-                    GTK_BUTTONS_CLOSE,
-                    "%s", msg + skip_chars);
-                tagged_msg = tag_url(msg + skip_chars, "\n");
-                gtk_message_dialog_set_markup(GTK_MESSAGE_DIALOG(dialog), tagged_msg);
-
-                gtk_dialog_run(GTK_DIALOG(dialog));
-                gtk_widget_destroy(dialog);
-            }
-            /* ask dialog with textbox */
-            else if (strncmp(REPORT_PREFIX_ASK, msg, ask_prefix_len) == 0)
-            {
-                skip_chars = ask_prefix_len;
-
-                GtkWidget *dialog = gtk_message_dialog_new(GTK_WINDOW(g_wnd_assistant),
-                    GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
-                    GTK_MESSAGE_QUESTION,
-                    GTK_BUTTONS_OK_CANCEL,
-                    "%s", msg + skip_chars);
-                tagged_msg = tag_url(msg + skip_chars, "\n");
-                gtk_message_dialog_set_markup(GTK_MESSAGE_DIALOG(dialog), tagged_msg);
-
-                GtkWidget *vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
-                GtkWidget *textbox = gtk_entry_new();
-                /* gtk_entry_set_editable(GTK_ENTRY(textbox), TRUE);
-                 * is not available in gtk3, so please use the highlevel
-                 * g_object_set
-                 */
-                g_object_set(G_OBJECT(textbox), "editable", TRUE, NULL);
-                gtk_box_pack_start(GTK_BOX(vbox), textbox, TRUE, TRUE, 0);
-                gtk_widget_show(textbox);
-                if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK)
-                {
-                    const char *text = gtk_entry_get_text(GTK_ENTRY(textbox));
-                    response = xstrdup(text);
-                    log_response = response;
-                }
-                else
-                {
-                    response = xstrdup("");
-                    log_response = "";
-                }
-                gtk_widget_destroy(textbox);
-                gtk_widget_destroy(dialog);
-            }
-            /* ask dialog with passwordbox */
-            else if (strncmp(REPORT_PREFIX_ASK_PASSWORD, msg, ask_password_prefix_len) ==
0)
-            {
-                skip_chars = ask_password_prefix_len;
-
-                GtkWidget *dialog = gtk_message_dialog_new(GTK_WINDOW(g_wnd_assistant),
-                    GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
-                    GTK_MESSAGE_QUESTION,
-                    GTK_BUTTONS_OK_CANCEL,
-                    "%s", msg + skip_chars);
-                tagged_msg = tag_url(msg + skip_chars, "\n");
-                gtk_message_dialog_set_markup(GTK_MESSAGE_DIALOG(dialog), tagged_msg);
-
-                GtkWidget *vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
-                GtkWidget *textbox = gtk_entry_new();
-                /* gtk_entry_set_editable(GTK_ENTRY(textbox), TRUE);
-                 * is not available in gtk3, so please use the highlevel
-                 * g_object_set
-                 */
-                g_object_set(G_OBJECT(textbox), "editable", TRUE, NULL);
-                gtk_entry_set_visibility(GTK_ENTRY(textbox), FALSE);
-                gtk_box_pack_start(GTK_BOX(vbox), textbox, TRUE, TRUE, 0);
-                gtk_widget_show(textbox);
-                if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK)
-                {
-                    const char *text = gtk_entry_get_text(GTK_ENTRY(textbox));
-                    response = xstrdup(text);
-                    log_response = "******"; /* don't log passwords! */
-                }
-                else
-                {
-                    response = xstrdup("");
-                    log_response = "";
-                }
-                gtk_widget_destroy(textbox);
-                gtk_widget_destroy(dialog);
-            }
-            /* yes/no dialog */
-            else if (strncmp(REPORT_PREFIX_ASK_YES_NO, msg, ask_yes_no_prefix_len) == 0)
-            {
-                skip_chars = ask_yes_no_prefix_len;
+    log_request_response_communication(msg, log_response, (struct analyze_event_data
*)args);
+    return response;
+}
 
-                GtkWidget *dialog = gtk_message_dialog_new(GTK_WINDOW(g_wnd_assistant),
-                    GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
-                    GTK_MESSAGE_QUESTION,
-                    GTK_BUTTONS_YES_NO,
-                    "%s", msg + skip_chars);
-                tagged_msg = tag_url(msg + skip_chars, "\n");
-                gtk_message_dialog_set_markup(GTK_MESSAGE_DIALOG(dialog), tagged_msg);
+static char *run_event_gtk_ask(const char *msg, void *args)
+{
+    return ask_helper(msg, args, false);
+}
 
-                if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_YES)
-                {
-                    response = xstrdup(_("y"));
-                    log_response = "YES";
-                }
-                else
-                {
-                    response = xstrdup("");
-                    log_response = "NO";
-                }
-                gtk_widget_destroy(dialog);
-            }
-            /* else: no special prefix, just forward to log */
+static int run_event_gtk_ask_yes_no(const char *msg, void *args)
+{
+    GtkWidget *dialog = gtk_message_dialog_new(GTK_WINDOW(g_wnd_assistant),
+            GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
+            GTK_MESSAGE_QUESTION,
+            GTK_BUTTONS_YES_NO,
+            "%s", msg);
+    char *tagged_msg = tag_url(msg, "\n");
+    gtk_message_dialog_set_markup(GTK_MESSAGE_DIALOG(dialog), tagged_msg);
+    free(tagged_msg);
 
-            if (response)
-            {
-                unsigned len = strlen(response);
-                response[len++] = '\n';
-                if (full_write(evd->run_state->command_in_fd, response, len) !=
len)
-                {
-                    VERB1 perror_msg("Can't write %u bytes to child's
stdin", len);
-                    free(response);
-                    response = xstrdup("<WRITE ERROR>");
-                    log_response = response;
-                }
-                strbuf_append_char(cmd_output, ' ');
-                strbuf_append_str(cmd_output, log_response);
-                free(response);
-            }
+    const int ret = gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_YES;
 
-            msg = cmd_output->buf;
-            msg += skip_chars;
-            gtk_label_set_text(g_lbl_event_log, msg);
+    gtk_widget_destroy(dialog);
 
-            strbuf_append_char(cmd_output, '\n');
-            msg = cmd_output->buf;
-            msg += skip_chars;
-            append_to_textview(evd->tv_log, msg);
-            save_to_event_log(evd, msg);
+    log_request_response_communication(msg, ret ? "YES" : "NO",
(struct analyze_event_data *)args);
+    return ret;
+}
 
-            strbuf_clear(cmd_output);
+static char *run_event_gtk_ask_password(const char *msg, void *args)
+{
+    return ask_helper(msg, args, true);
+}
 
-            /* jump to next line */
-            raw = newline + 1;
-            free(tagged_msg);
-        }
+static gboolean consume_cmd_output(GIOChannel *source, GIOCondition condition, gpointer
data)
+{
+    struct analyze_event_data *evd = data;
+    struct run_event_state *run_state = evd->run_state;
 
-        /* beginning of next line. the line continues by next read() */
-        strbuf_append_str(cmd_output, raw);
-    }
+    const int retval = run_event_command_on_dir_name(run_state, g_dump_dir_name);
 
-    if (r < 0 && errno == EAGAIN)
+    if (retval < 0 && errno == EAGAIN)
         /* We got all buffered data, but fd is still open. Done for now */
         return TRUE; /* "please don't remove this event (yet)" */
 
     /* EOF/error */
 
-    strbuf_clear(cmd_output);
-
     unexport_event_config(evd->env_list);
     evd->env_list = NULL;
 
-    /* Wait for child to actually exit, collect status */
-    int status;
-    safe_waitpid(evd->run_state->command_pid, &status, 0);
-    int retval = WEXITSTATUS(status);
-    if (WIFSIGNALED(status))
-        retval = WTERMSIG(status) + 128;
-
     /* Make sure "Cancel" button won't send anything (process is gone) */
     g_event_child_pid = -1;
     evd->run_state->command_pid = -1; /* just for consistency */
@@ -1501,14 +1422,15 @@ static gboolean consume_cmd_output(GIOChannel *source,
GIOCondition condition, g
     /* Write a final message to the log */
     if (evd->event_log->len != 0 &&
evd->event_log->buf[evd->event_log->len - 1] != '\n')
         save_to_event_log(evd, "\n");
+
     /* If program failed, or if it finished successfully without saying anything... */
     if (retval != 0 || evd->event_log_state == LOGSTATE_FIRSTLINE)
     {
         if (retval != 0) /* If program failed, emit error line */
             evd->event_log_state = LOGSTATE_ERRLINE;
         char *msg;
-        if (WIFSIGNALED(status))
-            msg = xasprintf("(killed by signal %u)\n", WTERMSIG(status));
+        if (WIFSIGNALED(run_state->process_status))
+            msg = xasprintf("(killed by signal %u)\n",
WTERMSIG(run_state->process_status));
         else
             msg = xasprintf("(exited with %u)\n", retval);
         append_to_textview(evd->tv_log, msg);
@@ -1603,6 +1525,12 @@ static void start_event_run(const char *event_name,
      * (synchronous run would freeze GUI until completion)
      */
     struct run_event_state *state = new_run_event_state();
+    state->logging_callback = run_event_gtk_logging;
+    state->error_callback = run_event_gtk_error;
+    state->alert_callback = run_event_gtk_alert;
+    state->ask_callback = run_event_gtk_ask;
+    state->ask_yes_no_callback = run_event_gtk_ask_yes_no;
+    state->ask_password_callback = run_event_gtk_ask_password;
 
     if (prepare_commands(state, g_dump_dir_name, event_name) == 0)
     {
@@ -1650,6 +1578,11 @@ static void start_event_run(const char *event_name,
     evd->success_msg = success_msg;
     evd->event_log = strbuf_new();
     evd->fd = state->command_out_fd;
+
+    state->logging_param = evd;
+    state->error_param = evd;
+    state->interaction_param = evd;
+
     ndelay_on(evd->fd);
     evd->channel = g_io_channel_unix_new(evd->fd);
     /*evd->event_source_id = */ g_io_add_watch(evd->channel,
diff --git a/src/include/run_event.h b/src/include/run_event.h
index 40caaa4..09000e3 100644
--- a/src/include/run_event.h
+++ b/src/include/run_event.h
@@ -41,6 +41,15 @@ struct run_event_state {
     void *logging_param;
 
     /*
+     * Called if any error occures during communication with child's command.
+     *
+     * @param error_line An error message
+     * @param param a custom param
+     */
+    void (*error_callback)(const char *error_line, void *param);
+    void *error_param;
+
+    /*
      * An optional argument for the following callbacks
      */
     void *interaction_param;
@@ -96,6 +105,7 @@ struct run_event_state {
     pid_t command_pid;
     int command_out_fd;
     int command_in_fd;
+    int process_status;
     struct strbuf *command_output;
 };
 struct run_event_state *new_run_event_state(void);
diff --git a/src/lib/run_event.c b/src/lib/run_event.c
index 78b3b4a..62d1d14 100644
--- a/src/lib/run_event.c
+++ b/src/lib/run_event.c
@@ -509,7 +509,12 @@ int run_event_command_on_dir_name(struct run_event_state *state,
const char *dum
                 response[len++] = '\n';
 
                 if (full_write(state->command_in_fd, response, len) != len)
-                    perror_msg_and_die("Can't write %lu bytes to child's
stdin", len);
+                {
+                    if (state->error_callback)
+                        state->error_callback("<WRITE ERROR>",
state->error_param);
+                    else
+                        perror_msg_and_die("Can't write %lu bytes to child's
stdin", len);
+                }
 
                 free(response);
             }
@@ -531,12 +536,11 @@ int run_event_command_on_dir_name(struct run_event_state *state,
const char *dum
     strbuf_clear(cmd_output);
 
     /* Wait for child to actually exit, collect status */
-    int status;
-    safe_waitpid(state->command_pid, &status, 0);
+    safe_waitpid(state->command_pid, &(state->process_status), 0);
 
-    int retval = WEXITSTATUS(status);
-    if (WIFSIGNALED(status))
-        retval = WTERMSIG(status) + 128;
+    int retval = WEXITSTATUS(state->process_status);
+    if (WIFSIGNALED(state->process_status))
+        retval = WTERMSIG(state->process_status) + 128;
 
     if (retval == 0 && state->post_run_callback)
         retval = state->post_run_callback(dump_dir_name, state->post_run_param);
-- 
1.7.10.4

[PATCH 5/5] trac#622 : report-gtk uses run_event_command_on_dir_name()

[Denys Vlasenko]

On 07/18/2012 01:01 PM, Jakub Filak wrote:
>  * report-gtk had own implementation of communication with event
> command
>  * this patch removes code duplication
>  * this patch should improve maintainability and simplify implementation 
Looks good to me.

[PATCH 5/7] track#554 : use run event list API in report-cli

[Jakub Filak]

Signed-off-by: Jakub Filak <jfilak(a)redhat.com&gt;
---
 src/cli/cli.c |  160 +++++++++++++++++++++++++--------------------------------
 1 file changed, 70 insertions(+), 90 deletions(-)

diff --git a/src/cli/cli.c b/src/cli/cli.c
index 244dce0..eca8bda 100644
--- a/src/cli/cli.c
+++ b/src/cli/cli.c
@@ -22,8 +22,48 @@
 #include <syslog.h>
 #include "internal_libreport.h"
 #include "cli-report.h"
+#include "run_event_list.h"
 
-static char *do_log(char *log_line, void *param)
+static enum elp_signal_ret cli_event_done(struct event_list_process *process)
+{
+    const char *const event_name = elp_get_current_event(process);
+    const enum elp_event_run_status status = elp_get_last_event_status(process);
+
+    switch(status)
+    {
+        case ELP_ERS_SUCCESSFUL:
+            VERB1 log("Successfull event '%s'", event_name);
+            return ELPSR_CONTINUE;
+
+        case ELP_ERS_FAILED:
+            error_msg("Event '%s' failed", event_name);
+            return ELPSR_FINISH;
+
+        case ELP_ERS_NOT_FOUND:
+            error_msg("No actions are found for event '%s'",
event_name);
+            return ELPSR_FINISH;
+
+        case ELP_ERS_NONE:
+            /* fall throug */
+        default:
+            error_msg_and_die("unexpected event return status '%d'",
status);
+            break;
+    }
+
+    return ELPSR_FINISH;
+}
+
+enum elp_signal_ret cli_configuration_issue(const struct event_list_process *process)
+{
+    const struct elp_configuration_issue *last =
elp_get_last_configuration_issue(process);
+    log("Found configuration flaws for event '%s'",
last->event_name);
+    for(const GList *i = last->issues; i; i = g_list_next(i))
+        log("* %s", (char *)i->data);
+
+    return last->usability == EUS_UNUSABLE ? ELPSR_NEXT_EVENT : ELPSR_CONTINUE;
+}
+
+static char* cli_logging_callback(char *log_line, void *param)
 {
     log("%s", log_line);
     return log_line;
@@ -48,7 +88,7 @@ int main(int argc, char** argv)
 #endif
 
     GList *D_list = NULL;
-    const char *event_name = NULL;
+    GList *events_list = NULL;
     const char *pfx = "";
 
     /* Can't keep these strings/structs static: _() doesn't support that */
@@ -62,31 +102,23 @@ int main(int argc, char** argv)
     enum {
         OPT_list_events  = 1 << 0,
         OPT_run_event    = 1 << 1,
-        OPT_analyze      = 1 << 2,
-        OPT_collect      = 1 << 3,
-        OPT_report       = 1 << 4,
-        OPT_version      = 1 << 5,
-        OPT_delete       = 1 << 6,
-        OPTMASK_op       =
OPT_list_events|OPT_run_event|OPT_analyze|OPT_collect|OPT_report|OPT_version,
-        OPTMASK_need_arg = OPT_run_event|OPT_analyze|OPT_collect|OPT_report,
-        OPT_y            = 1 << 7,
-        OPT_o            = 1 << 8,
-        OPT_v            = 1 << 9,
-        OPT_s            = 1 << 10,
-        OPT_p            = 1 << 11,
+        OPT_version      = 1 << 2,
+        OPT_delete       = 1 << 3,
+        OPTMASK_op       = OPT_list_events|OPT_run_event|OPT_version,
+        OPTMASK_need_arg = OPT_run_event,
+        OPT_y            = 1 << 4,
+        OPT_v            = 1 << 5,
+        OPT_s            = 1 << 6,
+        OPT_p            = 1 << 7,
     };
     /* Keep enum above and order of options below in sync! */
     struct options program_options[] = {
         /*      short_name long_name  value    parameter_name  help */
         OPT_OPTSTRING('L', NULL     , &pfx, "PREFIX",         
_("List possible events [which start with PREFIX]")),
-        OPT_STRING(   'e', NULL     , &event_name, "EVENT",   
_("Run EVENT on DUMP_DIR")),
-        OPT_BOOL(     'a', "analyze", NULL,                   
_("Run analyze event(s) on DUMP_DIR")),
-        OPT_BOOL(     'c', "collect", NULL,                   
_("Run collect event(s) on DUMP_DIR")),
-        OPT_BOOL(     'r', "report" , NULL,                   
_("Analyze, collect and report problem data in DUMP_DIR")),
+        OPT_LIST(     'e', "event"  , &events_list,
"EVENT",   _("Run only this event")),
         OPT_BOOL(     'V', "version", NULL,                   
_("Display version and exit")),
-        OPT_BOOL(     'd', "delete" , NULL,                   
_("Remove DUMP_DIR after reporting")),
+        OPT_BOOL(     'd', "delete" , NULL,                   
_("Remove DUMP_DIR")),
         OPT_BOOL(     'y', "always" , NULL,                   
_("Noninteractive: don't ask questions, assume 'yes'")),
-        OPT_BOOL(     'o', "report-only" , NULL,              
_("With -r: do not run analyzers, run only reporters")),
         OPT__VERBOSE(&g_verbose),
         OPT_BOOL(     's', NULL     , NULL,                    _("Log to
syslog")),
         OPT_BOOL(     'p', NULL     , NULL,                    _("Add
program names to log")),
@@ -124,8 +156,6 @@ int main(int argc, char** argv)
     }
 
     char *dump_dir_name = argv[0];
-    bool always = (opts & OPT_y);
-    bool report_only = (opts & OPT_o);
 
     if (!D_list)
     {
@@ -154,76 +184,26 @@ int main(int argc, char** argv)
         }
         case OPT_run_event: /* -e EVENT: run event */
         {
-            struct run_event_state *run_state = new_run_event_state();
-            run_state->logging_callback = do_log;
-            int r = run_event_on_dir_name(run_state, dump_dir_name, event_name);
-            if (r == 0 && run_state->children_count == 0)
-                error_msg_and_die("No actions are found for event
'%s'", event_name);
-            free_run_event_state(run_state);
-            break;
-        }
-        case OPT_analyze:
-        {
-            /* Load problem_data from dump dir */
-            struct dump_dir *dd = dd_opendir(dump_dir_name, DD_OPEN_READONLY);
-            if (!dd)
-                return 1;
-            char *analyze_events_as_lines = list_possible_events(dd, NULL,
"analyze");
-            dd_close(dd);
-
-            if (analyze_events_as_lines && *analyze_events_as_lines)
-            {
-                GList *list_analyze_events = str_to_glist(analyze_events_as_lines,
'\n');
-                char *event = select_event_option(list_analyze_events);
-                list_free_with_free(list_analyze_events);
-                exitcode = run_analyze_event(dump_dir_name, event);
-                free(event);
-            }
-            free(analyze_events_as_lines);
-            break;
-        }
-        case OPT_collect:
-        {
-            exitcode = collect(dump_dir_name, always);
+            struct elp_signals_impl impl;
+            event_list_process_impl_init(&impl);
+            impl.event_done=cli_event_done;
 
-            /* Be consistent and return 1 when opening dd failed */
-            if (exitcode == -1)
-                return 1;
+            struct run_event_impl *run_impl = new_text_run_event_impl();
 
-            break;
-        }
-        case OPT_report:
-        {
-            struct dump_dir *dd = dd_opendir(dump_dir_name, DD_OPEN_READONLY);
-            if (!dd)
-                return 1;
-            int readonly = !dd->locked;
-            dd_close(dd);
-            if (readonly)
-            {
-                log("'%s' is not writable", dump_dir_name);
-                /* D_list can't be NULL here */
-                struct dump_dir *dd_copy = steal_directory((char *)D_list->data,
dump_dir_name);
-                if (dd_copy)
-                {
-                    delete_dump_dir_possibly_using_abrtd(dump_dir_name);
-                    dump_dir_name = xstrdup(dd_copy->dd_dirname);
-                    dd_close(dd_copy);
-                }
-            }
-
-            exitcode = report(dump_dir_name,
-                    (always ? CLI_REPORT_BATCH : 0) |
-                    (report_only ? CLI_REPORT_ONLY : 0));
-            if (exitcode == -1)
-                error_msg_and_die("Crash '%s' not found",
dump_dir_name);
-
-            if (opts & OPT_delete)
-            {
-                int r = delete_dump_dir_possibly_using_abrtd(dump_dir_name);
-                if (exitcode == 0)
-                    exitcode = r;
-            }
+            struct event_list_process *process = new_event_list_process(events_list,
+                                                                        &impl,
+                                                                        run_impl,
+                                                                        NULL,
+                                                                        dump_dir_name,
+                                                                        NULL);
+
+            elp_set_logging_callback(process, cli_logging_callback, NULL);
+
+            while(elp_next_step(process))
+                ;
+
+            free_event_list_process(process);
+            free_text_run_event_impl(run_impl);
 
             break;
         }
-- 
1.7.10.2

[PATCH 6/7] track#554 : run event list in thread API

[Jakub Filak]

Signed-off-by: Jakub Filak <jfilak(a)redhat.com&gt;
---
 libreport.spec.in                   |    1 +
 src/include/Makefile.am             |    3 +-
 src/include/run_event_list_thread.h |  174 +++++++++++++++++++++
 src/lib/Makefile.am                 |    3 +-
 src/lib/run_event_list_thread.c     |  284 +++++++++++++++++++++++++++++++++++
 5 files changed, 463 insertions(+), 2 deletions(-)
 create mode 100644 src/include/run_event_list_thread.h
 create mode 100644 src/lib/run_event_list_thread.c

diff --git a/libreport.spec.in b/libreport.spec.in
index ea51431..6f628cd 100644
--- a/libreport.spec.in
+++ b/libreport.spec.in
@@ -298,6 +298,7 @@ gtk-update-icon-cache %{_datadir}/icons/hicolor &>/dev/null ||
:
 %{_includedir}/libreport/run_event.h
 %{_includedir}/libreport/event_usability.h
 %{_includedir}/libreport/run_event_list.h
+%{_includedir}/libreport/run_event_list_thread.h
 # Private api headers:
 %{_includedir}/libreport/internal_abrt_dbus.h
 %{_includedir}/libreport/internal_libreport.h
diff --git a/src/include/Makefile.am b/src/include/Makefile.am
index bca63dd..4244b6e 100644
--- a/src/include/Makefile.am
+++ b/src/include/Makefile.am
@@ -11,4 +11,5 @@ libreport_include_HEADERS = \
     internal_libreport.h \
     internal_abrt_dbus.h \
     event_usability.h \
-    run_event_list.h
+    run_event_list.h \
+    run_event_list_thread.h
diff --git a/src/include/run_event_list_thread.h b/src/include/run_event_list_thread.h
new file mode 100644
index 0000000..b253a2e
--- /dev/null
+++ b/src/include/run_event_list_thread.h
@@ -0,0 +1,174 @@
+/*
+    Copyright (C) 2012  ABRT team.
+    Copyright (C) 2012  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.
+*/
+#ifndef LIBREPORT_RUN_EVENT_LIST_THREAD_H_
+#define LIBREPORT_RUN_EVENT_LIST_THREAD_H_
+
+/*
+ * This functions allow asynchronous run of event list process.
+ *
+ * Example of usage:
+ *
+ * struct elp_thread_args *thread_proc = new_elp_thread_args();
+ *
+ * if (elp_thread_init(thread_proc))
+ *   exit(1);
+ *
+ * struct even_list_process *event_proc = new_event_list_process(...);
+ *
+ * elp_thread_run(thread_proc, event_proc);
+ *
+ * in some event loop call:
+ * elp_thread_loop_next_step(thread_proc);
+ *
+ * after finish call:
+ * free_event_list_process(elp_thread_get_process(thread_proc));
+ * free_elp_thread(thread_proc);
+ */
+
+/*
+ * Forward declaration
+ */
+struct event_list_process;
+
+/*
+ * Structure that holds state of thread process.
+ */
+struct elp_thread_args;
+
+/*
+ * Callback used by thread process to send signals about process state
+ *
+ * @param args a caller
+ */
+typedef void(* elp_thread_args_callback)(struct elp_thread_args *args);
+
+/*
+ * Creates a new thread process state
+ *
+ * @return never returns NULL
+ */
+struct elp_thread_args *new_elp_thread_args();
+
+/*
+ * Sets "on start" signal callback. The process calls this signla before
+ * the first step of event list process is performed.
+ *
+ * Replaces the currently configured callback.
+ *
+ * @param args Not NULL pointer to thread process state
+ * @param cb Callback signal
+ */
+void elp_thread_args_set_on_start(struct elp_thread_args *args,
+                                  elp_thread_args_callback cb);
+
+/*
+ * Sets "on step done" signal callback. The process calls this signal
+ * after each event list process step.
+ *
+ * Replaces the currently configured callback.
+ *
+ * @param args Not NULL pointer to thread process state
+ * @param cb Callback signal
+ */
+void elp_thread_args_set_on_step_done(struct elp_thread_args *args,
+                                      elp_thread_args_callback cb);
+
+/*
+ * Sets "on finish" signal callback. The process calls this signal after
+ * last event list process step.
+ *
+ * Replaces the currently configured callback.
+ *
+ * @param args Not NULL pointer to thread process state
+ * @param cb Callback signal
+ */
+void elp_thread_args_set_on_finish(struct elp_thread_args *args,
+                                   elp_thread_args_callback cb);
+
+/*
+ * Gets an event list process.
+ *
+ * @param args Not NULL pointer to thread process state
+ * @return An event list process
+ */
+struct event_list_process *elp_thread_args_get_process(const struct elp_thread_args
*args);
+
+/*
+ * Destroy thread process
+ *
+ * @param args A pointer to thread process
+ * @return An event list process
+ */
+void free_elp_thread_args(struct elp_thread_args *args);
+
+/*
+ * Creates a thread used by a process
+ *
+ * @param args Not NULL pointer to thread process state
+ * @return On success returns non 0, on error, it returns an error number
+ */
+int elp_thread_init(struct elp_thread_args *args);
+
+/*
+ * Interrupts an event list process and kills a process thread.
+ * A thread process cannot be used after this function call.
+ *
+ * @param args Not NULL pointer to thread process state
+ */
+void elp_thread_kill(struct elp_thread_args *args);
+
+/*
+ * Interrupts an event list process and leaves a process thread untouched.
+ * The process can be rerun after this method finishes.
+ *
+ * @param args Not NULL pointer to thread process state
+ */
+void elp_thread_interrupt(struct elp_thread_args *args);
+
+/*
+ * Sets an event list process and stars waiting on next step.
+ *
+ * @param args Not NULL pointer to thread process state
+ * @param process An event list process. Do not take ownership of it's memory.
Replaces a currently configured process.
+ */
+void elp_thread_run(struct elp_thread_args *args, struct event_list_process *process);
+
+/*
+ * Gets an state of the inner event list process.
+ *
+ * @param args Not NULL pointer to thread process state
+ * @return non 0 if event process list is under processing; otherwise return 0
+ */
+int elp_thread_is_runnig(struct elp_thread_args *args);
+
+/*
+ * Notify a thread process to perform next event list process step.
+ *
+ * @param args Not NULL pointer to thread process state
+ */
+void elp_thread_loop_next_step(struct elp_thread_args *args);
+
+/*
+ * Kills a currently running event command process
+ *
+ * @param args Not NULL pointer to thread process state
+ */
+void elp_thread_loop_kill_command(struct elp_thread_args *args);
+
+#endif /* LIBREPORT_RUN_EVENT_LIST_THREAD_H_ */
diff --git a/src/lib/Makefile.am b/src/lib/Makefile.am
index fd406ce..d7eab1a 100644
--- a/src/lib/Makefile.am
+++ b/src/lib/Makefile.am
@@ -49,7 +49,8 @@ libreport_la_SOURCES = \
     client.c \
     utf8.c \
     event_usability.c \
-	run_event_list.c
+	run_event_list.c \
+	run_event_list_thread.c
 
 libreport_la_CPPFLAGS = \
     -Wall -Wwrite-strings -Werror \
diff --git a/src/lib/run_event_list_thread.c b/src/lib/run_event_list_thread.c
new file mode 100644
index 0000000..2c230a5
--- /dev/null
+++ b/src/lib/run_event_list_thread.c
@@ -0,0 +1,284 @@
+/*
+    Copyright (C) 2012  ABRT team.
+    Copyright (C) 2012  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 <pthread.h>
+#include "run_event_list.h"
+#include "run_event_list_thread.h"
+#include "internal_libreport.h"
+
+struct elp_thread_args
+{
+    pthread_t process_tid;
+
+    int proc_ready;
+    int step_ready;
+    struct event_list_process *process;
+
+    int killed;
+    int interrupted;
+    int runnig;
+
+    pthread_mutex_t sync_mut;
+
+    pthread_cond_t proc_cond;
+    pthread_cond_t step_cond;
+
+    elp_thread_args_callback start_cb;
+    elp_thread_args_callback step_done_cb;
+    elp_thread_args_callback finish_cb;
+};
+
+struct elp_thread_args *new_elp_thread_args()
+{
+    struct elp_thread_args *args = xzalloc(sizeof(*args));
+
+    pthread_mutex_init(&(args->sync_mut), NULL);
+
+    pthread_cond_init(&(args->proc_cond), NULL);
+    pthread_cond_init(&(args->step_cond), NULL);
+
+    return args;
+}
+
+void elp_thread_args_set_on_start(struct elp_thread_args *args,
+                                  elp_thread_args_callback cb)
+{
+    args->start_cb = cb;
+}
+
+void elp_thread_args_set_on_step_done(struct elp_thread_args *args,
+                                      elp_thread_args_callback cb)
+{
+    args->step_done_cb = cb;
+}
+
+void elp_thread_args_set_on_finish(struct elp_thread_args *args,
+                                   elp_thread_args_callback cb)
+{
+    args->finish_cb = cb;
+}
+
+static void elp_thread_args_set_process(struct elp_thread_args *args,
+                                 struct event_list_process *process)
+{
+    args->process = process;
+}
+
+struct event_list_process *elp_thread_args_get_process(const struct elp_thread_args
*args)
+{
+    return args->process;
+}
+
+static void elp_thread_args_on_start(struct elp_thread_args *args)
+{
+    if (args->start_cb)
+        args->start_cb(args);
+}
+
+static void elp_thread_args_on_step_done(struct elp_thread_args *args)
+{
+    if (args->step_done_cb)
+        args->step_done_cb(args);
+}
+
+static void elp_thread_args_on_finish(struct elp_thread_args *args)
+{
+    if (args->finish_cb)
+        args->finish_cb(args);
+}
+
+void elp_thread_interrupt_internal(struct elp_thread_args *args)
+{
+    args->step_ready = 0;
+    args->interrupted = 1;
+    /* not unset runnig because of waiting on last step */
+}
+
+static void elp_thread_kill_internal(struct elp_thread_args *args)
+{
+    args->proc_ready = 0;
+    args->killed = 1;
+    args->runnig = 0;
+
+    elp_thread_interrupt_internal(args);
+}
+
+static int elp_thread_wait_on_process(struct elp_thread_args *args)
+{
+    pthread_mutex_lock(&(args->sync_mut));
+
+    while (!args->killed && !args->proc_ready)
+    {
+        const int error = pthread_cond_wait(&(args->proc_cond),
&(args->sync_mut));
+        if (error)
+        {
+            perror_msg("waiting o next process failed with %d", error);
+            elp_thread_kill_internal(args);
+        }
+    }
+
+    --(args->proc_ready);
+
+    const int killed = args->killed;
+
+    pthread_mutex_unlock(&(args->sync_mut));
+
+    return !killed;
+}
+
+static int elp_thread_wait_on_step(struct elp_thread_args *args)
+{
+    pthread_mutex_lock(&(args->sync_mut));
+
+    while(!args->interrupted && !args->killed &&
!args->step_ready)
+    {
+        const int error = pthread_cond_wait(&(args->step_cond),
&(args->sync_mut));
+        if (error)
+        {
+            perror_msg("waiting o next process failed with %d", error);
+            elp_thread_kill_internal(args);
+        }
+    }
+
+    --(args->step_ready);
+
+    const int interrupted = args->interrupted || args->killed;
+
+    pthread_mutex_unlock(&(args->sync_mut));
+
+    return !interrupted;
+}
+
+void free_elp_thread_args(struct elp_thread_args *args)
+{
+    if (!args)
+        return;
+
+    pthread_cond_destroy(&(args->step_cond));
+    pthread_cond_destroy(&(args->proc_cond));
+
+    pthread_mutex_destroy(&(args->sync_mut));
+
+    free(args);
+}
+
+void elp_thread_run(struct elp_thread_args *args, struct event_list_process *process)
+{
+    pthread_mutex_lock(&(args->sync_mut));
+
+    if (elp_thread_is_runnig(args))
+        error_msg_and_die("event list process thread is already runnig");
+
+    args->runnig = 1;
+    args->killed = 0;
+    args->interrupted = 0;
+    args->proc_ready = 1;
+
+    elp_thread_args_set_process(args, process);
+
+    pthread_cond_signal(&(args->proc_cond));
+    pthread_mutex_unlock(&(args->sync_mut));
+}
+
+int elp_thread_is_runnig(struct elp_thread_args *args)
+{
+    return args->runnig;
+}
+
+void elp_thread_loop_next_step(struct elp_thread_args *args)
+{
+    pthread_mutex_lock(&(args->sync_mut));
+
+    ++(args->step_ready);
+
+    pthread_cond_signal(&(args->step_cond));
+    pthread_mutex_unlock(&(args->sync_mut));
+}
+
+static void *elp_thread(void *args)
+{
+    struct elp_thread_args *p = (struct elp_thread_args *)args;
+
+    while (elp_thread_wait_on_process(p))
+    {
+        elp_thread_args_on_start(p);
+
+        pthread_mutex_lock(&(p->sync_mut));
+
+        if (!p->killed)
+        {
+            pthread_mutex_unlock(&(p->sync_mut));
+
+            /* Perform first step outside the loop because we */
+            /* want to finish immediately if process is empty */
+            elp_thread_wait_on_step(p);
+            bool cont = elp_next_step(p->process);
+
+            while (elp_thread_wait_on_step(p) && cont)
+            {
+                cont = elp_next_step(p->process);
+                elp_thread_args_on_step_done(p);
+            }
+
+            pthread_mutex_lock(&(p->sync_mut));
+        }
+
+        p->runnig = 0;
+
+        pthread_mutex_unlock(&(p->sync_mut));
+
+        elp_thread_args_on_finish(p);
+    }
+
+    return NULL;
+}
+
+int elp_thread_init(struct elp_thread_args *args)
+{
+    return pthread_create(&(args->process_tid), NULL, elp_thread, args);
+}
+
+void elp_thread_loop_kill_command(struct elp_thread_args *args)
+{
+    pthread_mutex_lock(&(args->sync_mut));
+
+    if (args->process)
+        elp_kill_run(args->process);
+
+    pthread_mutex_unlock(&(args->sync_mut));
+}
+
+void elp_thread_interrupt(struct elp_thread_args *args)
+{
+    pthread_mutex_lock(&(args->sync_mut));
+
+    elp_thread_interrupt_internal(args);
+
+    pthread_cond_signal(&(args->step_cond));
+    pthread_mutex_unlock(&(args->sync_mut));
+}
+
+void elp_thread_kill(struct elp_thread_args *args)
+{
+    pthread_mutex_lock(&(args->sync_mut));
+
+    elp_thread_kill_internal(args);
+
+    pthread_cond_signal(&(args->proc_cond));
+    pthread_mutex_unlock(&(args->sync_mut));
+}
-- 
1.7.10.2

[PATCH 7/7] track#554 : reworked report-gtk with usage of run event list in thread

[Jakub Filak]

Signed-off-by: Jakub Filak <jfilak(a)redhat.com&gt;
---
 src/gui-wizard-gtk/main.c       |   24 +-
 src/gui-wizard-gtk/wizard.c     | 1544 +++++++++++++++++----------------------
 src/gui-wizard-gtk/wizard.glade |   10 +-
 src/gui-wizard-gtk/wizard.h     |    2 +
 4 files changed, 703 insertions(+), 877 deletions(-)

diff --git a/src/gui-wizard-gtk/main.c b/src/gui-wizard-gtk/main.c
index 05d01e9..84b210e 100644
--- a/src/gui-wizard-gtk/main.c
+++ b/src/gui-wizard-gtk/main.c
@@ -22,12 +22,12 @@
 #if HAVE_LOCALE_H
 # include <locale.h>
 #endif
+#include "run_event_list_thread.h"
 
 char *g_glade_file = NULL;
 char *g_dump_dir_name = NULL;
 char *g_events = NULL;
 GList *g_auto_event_list = NULL;
-int g_report_only = false;
 problem_data_t *g_cd;
 
 
@@ -77,9 +77,14 @@ void reload_problem_data_from_dump_dir(void)
 
 }
 
+struct elp_thread_args *g_event_process;
+
 int main(int argc, char **argv)
 {
     const char *prgname = "abrt";
+
+    g_event_process = new_elp_thread_args();
+
     abrt_init(argv);
 
     /* I18n */
@@ -113,9 +118,8 @@ int main(int argc, char **argv)
         OPT_v = 1 << 0,
         OPT_g = 1 << 1,
         OPT_p = 1 << 2,
-        OPT_o = 1 << 3, // report only
-        OPT_d = 1 << 4,
-        OPT_e = 1 << 5,
+        OPT_d = 1 << 3,
+        OPT_e = 1 << 4,
     };
     /* Keep enum above and order of options below in sync! */
     struct options program_options[] = {
@@ -123,7 +127,6 @@ int main(int argc, char **argv)
         OPT_STRING('g', NULL, &g_glade_file, "FILE",         
_("Alternate GUI file")),
         OPT_BOOL(  'p', NULL, NULL,                           _("Add program
names to log")),
         /* for use from 3rd party apps to show just a reporter selector */
-        OPT_BOOL(  'o', "report-only", &g_report_only,       
_("Skip analyze steps, go through report steps only")),
         OPT_BOOL(  'd', "delete", NULL,                      
_("Remove DIR after reporting")),
         OPT_LIST(  'e', "event", &g_auto_event_list,
"EVENT", _("Run only this event")),
         OPT_END()
@@ -145,15 +148,24 @@ int main(int argc, char **argv)
 
     reload_problem_data_from_dump_dir();
 
+    gdk_threads_init ();
+    gdk_threads_enter ();
+
+    if (elp_thread_init(g_event_process))
+        perror_msg_and_die("initializatoin of event process thread failed");
+
     create_assistant();
 
     g_custom_logger = &show_error_as_msgbox;
 
     update_gui_state_from_problem_data();
-
     /* Enter main loop */
     gtk_main();
 
+    gdk_threads_leave();
+
+    free_elp_thread_args(g_event_process);
+
     if (opts & OPT_d)
         delete_dump_dir_possibly_using_abrtd(g_dump_dir_name);
 
diff --git a/src/gui-wizard-gtk/wizard.c b/src/gui-wizard-gtk/wizard.c
index 30c25ee..8ad8285 100644
--- a/src/gui-wizard-gtk/wizard.c
+++ b/src/gui-wizard-gtk/wizard.c
@@ -20,6 +20,9 @@
 #include <gdk/gdkkeysyms.h>
 #include "client.h"
 #include "internal_libreport_gtk.h"
+#include "run_event.h"
+#include "run_event_list.h"
+#include "run_event_list_thread.h"
 #include "wizard.h"
 
 #define DEFAULT_WIDTH   800
@@ -30,7 +33,6 @@
 # define GDK_KEY_Delete GDK_Delete
 # define GDK_KEY_KP_Delete GDK_KP_Delete
 #endif
-
 typedef struct event_gui_data_t
 {
     char *event_name;
@@ -38,12 +40,55 @@ typedef struct event_gui_data_t
 } event_gui_data_t;
 
 
-static char *g_event_selected;
-static unsigned g_black_event_count = 0;
+static enum elp_signal_ret gtk_next_event_selected(struct event_list_process *process);
+static enum elp_signal_ret gtk_review_data(struct event_list_process *process);
+static enum elp_signal_ret gtk_run_event(struct event_list_process *process);
+static enum elp_signal_ret gtk_event_done(struct event_list_process *process);
+static enum elp_signal_ret gtk_finished(struct event_list_process *process);
+static enum elp_signal_ret gtk_configuration_issue(struct event_list_process *process);
+
+static void gtk_alert(const char *msg, void *args);
+static char *gtk_ask(const char *msg, void *args);
+static int gtk_ask_yes_no(const char *msg, void *args);
+static int gtk_ask_password(const char *msg, char **password, void *args);
+static void gtk_command_started(pid_t pid, void *args);
+static void gtk_command_msg_processed(const char *msg, const char *raw_input, const char
*rsp, void *args);
+static void gtk_command_finished(int retval, int status, const char *err_msg, void
*args);
+
+static struct elp_signals_impl g_process_impl = {
+    .next_event_selected=gtk_next_event_selected,
+    .review_data=gtk_review_data,
+    .run_event=gtk_run_event,
+    .event_done=gtk_event_done,
+    .finished=gtk_finished,
+    .configuration_issue=gtk_configuration_issue,
+};
+
+static struct run_event_impl *g_run_impl;
+
+static struct run_event_impl g_gtk_run_impl = {
+    .alert=gtk_alert,
+    .ask=gtk_ask,
+    .ask_yes_no=gtk_ask_yes_no,
+    .ask_password=gtk_ask_password,
+    .args=NULL,
+};
+
+static struct run_event_observer *g_run_obs;
+
+static struct run_event_observer g_gtk_run_obs = {
+    .command_started=gtk_command_started,
+    .command_msg_processed=gtk_command_msg_processed,
+    .command_finished=gtk_command_finished,
+    .args=NULL,
+};
+
+static pthread_t g_gui_thread_id;
 
-static pid_t g_event_child_pid = 0;
+static char *g_event_selected;
 
 static bool g_expert_mode;
+static bool g_reviewing_data;
 
 static GtkNotebook *g_assistant;
 static GtkWindow *g_wnd_assistant;
@@ -60,10 +105,6 @@ static GtkLabel *g_lbl_event_log;
 static GtkTextView *g_tv_event_log;
 
 /* List of event_gui_data's */
-
-/* List of event_gui_data's */
-static GList *g_list_selected_reporters;
-
 static GtkContainer *g_container_details1;
 static GtkContainer *g_container_details2;
 
@@ -157,13 +198,13 @@ enum {
  * instead of strcmp.
  */
 static const gchar PAGE_SUMMARY[]        = "page_0";
-static const gchar PAGE_EVENT_SELECTOR[] = "page_2_report";
+static const gchar PAGE_EVENT_SELECTOR[] = "page_2";
 static const gchar PAGE_EDIT_COMMENT[]   = "page_1";
 static const gchar PAGE_EDIT_ELEMENTS[]  = "page_3";
-static const gchar PAGE_REVIEW_DATA[]    = "page_4_report";
-static const gchar PAGE_EVENT_PROGRESS[] = "page_5_report";
-static const gchar PAGE_EVENT_DONE[]     = "page_6_report";
-static const gchar PAGE_NOT_SHOWN[]      = "page_7_report";
+static const gchar PAGE_REVIEW_DATA[]    = "page_4";
+static const gchar PAGE_EVENT_PROGRESS[] = "page_5";
+static const gchar PAGE_EVENT_DONE[]     = "page_6";
+static const gchar PAGE_NOT_SHOWN[]      = "page_7";
 
 static const gchar *const page_names[] =
 {
@@ -188,9 +229,31 @@ typedef struct
 
 static page_obj_t pages[NUM_PAGES];
 
-static struct strbuf *cmd_output = NULL;
+//static struct strbuf *cmd_output = NULL;
+
+static gint select_next_page_no(gint current_page_no);
+static void on_comment_changed(GtkTextBuffer *buffer, gpointer user_data);
 
 /* Utility functions */
+static char *format_glist_of_strings(const GList *list, const char *item_format, const
char *delimiter)
+{
+    struct strbuf *buf = strbuf_new();
+
+    const GList *i = list;
+    if (i)
+    {
+        strbuf_append_strf(buf, item_format, i->data);
+        i = g_list_next(i);
+    }
+
+    for(; i; i = g_list_next(i))
+    {
+        strbuf_append_str(buf, delimiter);
+        strbuf_append_strf(buf, item_format, i->data);
+    }
+
+    return strbuf_free_nobuf(buf);
+}
 
 static void wrap_fixer(GtkWidget *widget, gpointer data_unused)
 {
@@ -254,17 +317,27 @@ static void on_configure_event_cb(GtkWidget *button, gpointer
user_data)
     }
 }
 
-static void show_event_opt_error_dialog(const char *event_name)
+static void show_event_list_opt_error_dialog(const GList *events)
 {
-    event_config_t *ec = get_event_config(event_name);
+    struct strbuf *buf = strbuf_new();
+    for(const GList *e = events; e; e = g_list_next(e))
+    {
+        event_config_t *ec = get_event_config(e->data);
+
+        if (e != events)
+            strbuf_append_strf(buf,",%s", ec ? ec->screen_name :
e->data);
+        else
+            strbuf_append_strf(buf,"%s", ec ? ec->screen_name :
e->data);
+    }
+
+    char *names = strbuf_free_nobuf(buf);
+
     char *message = xasprintf(_("Wrong settings detected for %s, "
                               "reporting will probably fail if you continue "
-                              "with the current configuration."),
-                               ec->screen_name);
+                              "with the current configuration."), names);
     char *markup_message = xasprintf(_("Wrong settings detected for
<b>%s</b>, "
                               "reporting will probably fail if you continue "
-                              "with the current configuration."),
-                               ec->screen_name);
+                              "with the current configuration."), names);
     GtkWidget *wrong_settings = g_top_most_window =
gtk_message_dialog_new(GTK_WINDOW(g_wnd_assistant),
         GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
         GTK_MESSAGE_WARNING,
@@ -276,22 +349,36 @@ static void show_event_opt_error_dialog(const char *event_name)
                                     markup_message);
     free(message);
     free(markup_message);
+    free(names);
 
     GtkWidget *act_area = gtk_dialog_get_content_area(GTK_DIALOG(wrong_settings));
-    char * conf_btn_lbl = xasprintf(_("Con_figure %s"), ec->screen_name);
-    GtkWidget *configure_event_btn = gtk_button_new_with_mnemonic(conf_btn_lbl);
-    g_signal_connect(configure_event_btn, "clicked",
G_CALLBACK(on_configure_event_cb), (gpointer)event_name);
-    free(conf_btn_lbl);
-
-    gtk_box_pack_start(GTK_BOX(act_area), configure_event_btn, false, false, 0);
-    gtk_widget_show(configure_event_btn);
 
+    for(const GList *e = events; e; e = g_list_next(e))
+    {
+        event_config_t *ec = get_event_config(e->data);
+        char * conf_btn_lbl = xasprintf(_("Configure %s"),
ec->screen_name);
+        GtkWidget *configure_event_btn = gtk_button_new_with_mnemonic(conf_btn_lbl);
+        g_signal_connect(configure_event_btn, "clicked",
G_CALLBACK(on_configure_event_cb), (gpointer)e->data);
+        free(conf_btn_lbl);
+        gtk_box_pack_start(GTK_BOX(act_area), configure_event_btn, false, false, 0);
+        gtk_widget_show(configure_event_btn);
+    }
 
     gtk_dialog_run(GTK_DIALOG(wrong_settings));
     if (g_top_most_window)
         gtk_widget_destroy(wrong_settings);
 }
 
+static void show_event_opt_error_dialog(const char *event_name)
+{
+    GList *e = NULL;
+    log("%s", event_name);
+    e = g_list_append(e, (gpointer)event_name);
+    show_event_list_opt_error_dialog(e);
+    g_list_free(e);
+    return;
+}
+
 static void update_window_title(void)
 {
     /* prgname can be null according to gtk documentation */
@@ -365,6 +452,7 @@ struct dump_dir *steal_if_needed(struct dump_dir *dd)
      */
     char *old_name = g_dump_dir_name;
     g_dump_dir_name = xstrdup(dd->dd_dirname);
+    VERB1 log("New dump dir path '%s'", g_dump_dir_name);
     dd_close(dd);
 
     update_window_title();
@@ -378,8 +466,11 @@ struct dump_dir *steal_if_needed(struct dump_dir *dd)
     return dd;
 }
 
-void show_error_as_msgbox(const char *msg)
+void show_error_as_msgbox_mts(const char *msg, bool need_lock)
 {
+    if (need_lock)
+        gdk_threads_enter();
+
     GtkWidget *dialog = gtk_message_dialog_new(GTK_WINDOW(g_wnd_assistant),
                 GTK_DIALOG_DESTROY_WITH_PARENT,
                 GTK_MESSAGE_WARNING,
@@ -388,6 +479,14 @@ void show_error_as_msgbox(const char *msg)
     );
     gtk_dialog_run(GTK_DIALOG(dialog));
     gtk_widget_destroy(dialog);
+
+    if (need_lock)
+        gdk_threads_leave();
+}
+
+void show_error_as_msgbox(const char *msg)
+{
+    show_error_as_msgbox_mts(msg, !pthread_equal(g_gui_thread_id, pthread_self()));
 }
 
 static void load_text_to_text_view(GtkTextView *tv, const char *name)
@@ -715,38 +814,6 @@ static void event_rb_was_toggled(GtkButton *button, gpointer
user_data)
  * Set "toggled" callback on each button to given GCallback if it's not
NULL.
  * Return active button (or NULL if none created).
  */
-/* helper */
-static char *missing_items_in_comma_list(const char *input_item_list)
-{
-    if (!input_item_list)
-        return NULL;
-
-    char *item_list = xstrdup(input_item_list);
-    char *result = item_list;
-    char *dst = item_list;
-
-    while (item_list[0])
-    {
-        char *end = strchr(item_list, ',');
-        if (end) *end = '\0';
-        if (!get_problem_data_item_or_NULL(g_cd, item_list))
-        {
-            if (dst != result)
-                *dst++ = ',';
-            dst = stpcpy(dst, item_list);
-        }
-        if (!end)
-            break;
-        *end = ',';
-        item_list = end + 1;
-    }
-    if (result == dst)
-    {
-        free(result);
-        result = NULL;
-    }
-    return result;
-}
 static event_gui_data_t *add_event_buttons(GtkBox *box,
                 GList **p_event_list,
                 char *event_name,
@@ -758,8 +825,6 @@ static event_gui_data_t *add_event_buttons(GtkBox *box,
     g_list_free(*p_event_list);
     *p_event_list = NULL;
 
-    g_black_event_count = 0;
-
     if (!event_name || !event_name[0])
     {
         GtkWidget *lbl = gtk_label_new(_("No reporting targets are defined for this
problem. Check configuration in /etc/libreport/*"));
@@ -795,31 +860,19 @@ static event_gui_data_t *add_event_buttons(GtkBox *box,
                 event_screen_name = cfg->screen_name;
             event_description = cfg->description;
 
-            char *missing = missing_items_in_comma_list(cfg->ec_requires_items);
-            if (missing)
-            {
-                red_choice = true;
-                event_description = tmp_description = xasprintf(_("(requires:
%s)"), missing);
-                free(missing);
-            }
-            else
-            if (cfg->ec_creates_items)
+            GList *issues = NULL;
+            enum event_usability_status status = check_event_usability(cfg, g_cd, NULL,
&issues, EUS_LOW);
+
+            red_choice = status == EUS_UNUSABLE;
+            green_choice = status == EUS_LOW;
+
+            if (issues)
             {
-                if (get_problem_data_item_or_NULL(g_cd, cfg->ec_creates_items))
-                {
-                    char *missing =
missing_items_in_comma_list(cfg->ec_creates_items);
-                    if (missing)
-                        free(missing);
-                    else
-                    {
-                        green_choice = true;
-                        event_description = tmp_description = xasprintf(_("(not
needed, data already exist: %s)"), cfg->ec_creates_items);
-                    }
-                }
+                event_description = tmp_description = format_glist_of_strings(issues,
"(%s)", ",");
+                tmp_description[strlen(tmp_description)-1] = '\0';
+                g_list_free_full(issues, (GDestroyNotify)free);
             }
         }
-        if (!green_choice && !red_choice)
-            g_black_event_count++;
 
         //VERB2 log("adding button '%s' to box %p", event_name, box);
         char *event_label = xasprintf("%s%s%s",
@@ -991,9 +1044,9 @@ static void append_item_to_ls_details(gpointer name, gpointer value,
gpointer da
 }
 
 /* Based on selected reporter, update item checkboxes */
-static void update_ls_details_checkboxes(void)
+static void update_ls_details_checkboxes(const char *event_name)
 {
-    event_config_t *cfg = get_event_config(g_event_selected);
+    event_config_t *cfg = get_event_config(event_name);
     //log("%s: event:'%s', cfg:'%p'", __func__,
g_event_selected, cfg);
     GHashTableIter iter;
     char *name;
@@ -1117,32 +1170,6 @@ void update_gui_state_from_problem_data(void)
     gtk_widget_show_all(GTK_WIDGET(g_wnd_assistant));
 }
 
-
-/* start_event_run */
-
-struct analyze_event_data
-{
-    struct run_event_state *run_state;
-    const char *event_name;
-    GList *env_list;
-    GtkWidget *page_widget;
-    GtkLabel *status_label;
-    GtkTextView *tv_log;
-    const char *success_msg;
-    const char *error_msg;
-    GIOChannel *channel;
-    struct strbuf *event_log;
-    int event_log_state;
-    int fd;
-    /*guint event_source_id;*/
-};
-enum {
-    LOGSTATE_FIRSTLINE = 0,
-    LOGSTATE_BEGLINE,
-    LOGSTATE_ERRLINE,
-    LOGSTATE_MIDLINE,
-};
-
 static void set_excluded_envvar(void)
 {
     struct strbuf *item_list = strbuf_new();
@@ -1179,491 +1206,6 @@ static void set_excluded_envvar(void)
         unsetenv("EXCLUDE_FROM_REPORT");
 }
 
-static int spawn_next_command_in_evd(struct analyze_event_data *evd)
-{
-    evd->env_list = export_event_config(evd->event_name);
-    int r = spawn_next_command(evd->run_state, g_dump_dir_name, evd->event_name);
-    if (r >= 0)
-    {
-        g_event_child_pid = evd->run_state->command_pid;
-    }
-    else
-    {
-        unexport_event_config(evd->env_list);
-        evd->env_list = NULL;
-    }
-    return r;
-}
-
-static void save_to_event_log(struct analyze_event_data *evd, const char *str)
-{
-    static const char delim[] = {
-        [LOGSTATE_FIRSTLINE] = '>',
-        [LOGSTATE_BEGLINE] = ' ',
-        [LOGSTATE_ERRLINE] = '*',
-    };
-
-    while (str[0])
-    {
-        char *end = strchrnul(str, '\n');
-        char end_char = *end;
-        if (end_char == '\n')
-            end++;
-        switch (evd->event_log_state)
-        {
-            case LOGSTATE_FIRSTLINE:
-            case LOGSTATE_BEGLINE:
-            case LOGSTATE_ERRLINE:
-                /* skip empty lines */
-                if (str[0] == '\n')
-                    goto next;
-                strbuf_append_strf(evd->event_log, "%s%c %.*s",
-                        iso_date_string(NULL),
-                        delim[evd->event_log_state],
-                        (int)(end - str), str
-                );
-                break;
-            case LOGSTATE_MIDLINE:
-                strbuf_append_strf(evd->event_log, "%.*s", (int)(end - str),
str);
-                break;
-        }
-        evd->event_log_state = LOGSTATE_MIDLINE;
-        if (end_char != '\n')
-            break;
-        evd->event_log_state = LOGSTATE_BEGLINE;
- next:
-        str = end;
-    }
-}
-
-static void update_event_log_on_disk(const char *str)
-{
-    /* Load existing log */
-    struct dump_dir *dd = dd_opendir(g_dump_dir_name, 0);
-    if (!dd)
-        return;
-    char *event_log = dd_load_text_ext(dd, FILENAME_EVENT_LOG, DD_FAIL_QUIETLY_ENOENT);
-
-    /* Append new log part to existing log */
-    unsigned len = strlen(event_log);
-    if (len != 0 && event_log[len - 1] != '\n')
-        event_log = append_to_malloced_string(event_log, "\n");
-    event_log = append_to_malloced_string(event_log, str);
-
-    /* Trim log according to size watermarks */
-    len = strlen(event_log);
-    char *new_log = event_log;
-    if (len > EVENT_LOG_HIGH_WATERMARK)
-    {
-        new_log += len - EVENT_LOG_LOW_WATERMARK;
-        new_log = strchrnul(new_log, '\n');
-        if (new_log[0])
-            new_log++;
-    }
-
-    /* Save */
-    dd_save_text(dd, FILENAME_EVENT_LOG, new_log);
-    free(event_log);
-    dd_close(dd);
-}
-
-static void on_btn_cancel_event(GtkButton *button)
-{
-    if (g_event_child_pid > 0)
-        kill(- g_event_child_pid, SIGTERM);
-}
-
-static gboolean consume_cmd_output(GIOChannel *source, GIOCondition condition, gpointer
data)
-{
-    struct analyze_event_data *evd = data;
-
-    /* Read and insert the output into the log pane */
-    char buf[257]; /* usually we get one line, no need to have big buf */
-    int r;
-    int alert_prefix_len = strlen(REPORT_PREFIX_ALERT);
-    int ask_prefix_len = strlen(REPORT_PREFIX_ASK);
-    int ask_yes_no_prefix_len = strlen(REPORT_PREFIX_ASK_YES_NO);
-    int ask_password_prefix_len = strlen(REPORT_PREFIX_ASK_PASSWORD);
-
-    if (!cmd_output)
-        cmd_output = strbuf_new();
-
-    /* read buffered and split lines */
-    while ((r = read(evd->fd, buf, sizeof(buf) - 1)) > 0)
-    {
-        char *newline;
-        char *raw;
-        buf[r] = '\0';
-        raw = buf;
-
-        /* split lines in the current buffer */
-        while ((newline = strchr(raw, '\n')) != NULL)
-        {
-            *newline = '\0';
-            strbuf_append_str(cmd_output, raw);
-            char *msg = cmd_output->buf;
-
-            /* In the code below:
-             * response is always malloced,
-             * log_response is always set to response
-             * or to constant string.
-             */
-            char *response = NULL;
-            const char *log_response = response;
-            unsigned skip_chars = 0;
-
-            char * tagged_msg = NULL;
-
-            /* alert dialog */
-            if (strncmp(REPORT_PREFIX_ALERT, msg, alert_prefix_len) == 0)
-            {
-                skip_chars = alert_prefix_len;
-
-                GtkWidget *dialog = gtk_message_dialog_new(GTK_WINDOW(g_wnd_assistant),
-                    GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
-                    GTK_MESSAGE_WARNING,
-                    GTK_BUTTONS_CLOSE,
-                    "%s", msg + skip_chars);
-                tagged_msg = tag_url(msg + skip_chars, "\n");
-                gtk_message_dialog_set_markup(GTK_MESSAGE_DIALOG(dialog), tagged_msg);
-
-                gtk_dialog_run(GTK_DIALOG(dialog));
-                gtk_widget_destroy(dialog);
-            }
-            /* ask dialog with textbox */
-            else if (strncmp(REPORT_PREFIX_ASK, msg, ask_prefix_len) == 0)
-            {
-                skip_chars = ask_prefix_len;
-
-                GtkWidget *dialog = gtk_message_dialog_new(GTK_WINDOW(g_wnd_assistant),
-                    GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
-                    GTK_MESSAGE_QUESTION,
-                    GTK_BUTTONS_OK_CANCEL,
-                    "%s", msg + skip_chars);
-                tagged_msg = tag_url(msg + skip_chars, "\n");
-                gtk_message_dialog_set_markup(GTK_MESSAGE_DIALOG(dialog), tagged_msg);
-
-                GtkWidget *vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
-                GtkWidget *textbox = gtk_entry_new();
-                /* gtk_entry_set_editable(GTK_ENTRY(textbox), TRUE);
-                 * is not available in gtk3, so please use the highlevel
-                 * g_object_set
-                 */
-                g_object_set(G_OBJECT(textbox), "editable", TRUE, NULL);
-                gtk_box_pack_start(GTK_BOX(vbox), textbox, TRUE, TRUE, 0);
-                gtk_widget_show(textbox);
-                if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK)
-                {
-                    const char *text = gtk_entry_get_text(GTK_ENTRY(textbox));
-                    response = xstrdup(text);
-                    log_response = response;
-                }
-                else
-                {
-                    response = xstrdup("");
-                    log_response = "";
-                }
-                gtk_widget_destroy(textbox);
-                gtk_widget_destroy(dialog);
-            }
-            /* ask dialog with passwordbox */
-            else if (strncmp(REPORT_PREFIX_ASK_PASSWORD, msg, ask_password_prefix_len) ==
0)
-            {
-                skip_chars = ask_password_prefix_len;
-
-                GtkWidget *dialog = gtk_message_dialog_new(GTK_WINDOW(g_wnd_assistant),
-                    GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
-                    GTK_MESSAGE_QUESTION,
-                    GTK_BUTTONS_OK_CANCEL,
-                    "%s", msg + skip_chars);
-                tagged_msg = tag_url(msg + skip_chars, "\n");
-                gtk_message_dialog_set_markup(GTK_MESSAGE_DIALOG(dialog), tagged_msg);
-
-                GtkWidget *vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
-                GtkWidget *textbox = gtk_entry_new();
-                /* gtk_entry_set_editable(GTK_ENTRY(textbox), TRUE);
-                 * is not available in gtk3, so please use the highlevel
-                 * g_object_set
-                 */
-                g_object_set(G_OBJECT(textbox), "editable", TRUE, NULL);
-                gtk_entry_set_visibility(GTK_ENTRY(textbox), FALSE);
-                gtk_box_pack_start(GTK_BOX(vbox), textbox, TRUE, TRUE, 0);
-                gtk_widget_show(textbox);
-                if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK)
-                {
-                    const char *text = gtk_entry_get_text(GTK_ENTRY(textbox));
-                    response = xstrdup(text);
-                    log_response = "******"; /* don't log passwords! */
-                }
-                else
-                {
-                    response = xstrdup("");
-                    log_response = "";
-                }
-                gtk_widget_destroy(textbox);
-                gtk_widget_destroy(dialog);
-            }
-            /* yes/no dialog */
-            else if (strncmp(REPORT_PREFIX_ASK_YES_NO, msg, ask_yes_no_prefix_len) == 0)
-            {
-                skip_chars = ask_yes_no_prefix_len;
-
-                GtkWidget *dialog = gtk_message_dialog_new(GTK_WINDOW(g_wnd_assistant),
-                    GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
-                    GTK_MESSAGE_QUESTION,
-                    GTK_BUTTONS_YES_NO,
-                    "%s", msg + skip_chars);
-                tagged_msg = tag_url(msg + skip_chars, "\n");
-                gtk_message_dialog_set_markup(GTK_MESSAGE_DIALOG(dialog), tagged_msg);
-
-                if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_YES)
-                {
-                    response = xstrdup(_("y"));
-                    log_response = "YES";
-                }
-                else
-                {
-                    response = xstrdup("");
-                    log_response = "NO";
-                }
-                gtk_widget_destroy(dialog);
-            }
-            /* else: no special prefix, just forward to log */
-
-            if (response)
-            {
-                unsigned len = strlen(response);
-                response[len++] = '\n';
-                if (full_write(evd->run_state->command_in_fd, response, len) !=
len)
-                {
-                    VERB1 perror_msg("Can't write %u bytes to child's
stdin", len);
-                    free(response);
-                    response = xstrdup("<WRITE ERROR>");
-                    log_response = response;
-                }
-                strbuf_append_char(cmd_output, ' ');
-                strbuf_append_str(cmd_output, log_response);
-                free(response);
-            }
-
-            msg = cmd_output->buf;
-            msg += skip_chars;
-            gtk_label_set_text(g_lbl_event_log, msg);
-
-            strbuf_append_char(cmd_output, '\n');
-            msg = cmd_output->buf;
-            msg += skip_chars;
-            append_to_textview(evd->tv_log, msg);
-            save_to_event_log(evd, msg);
-
-            strbuf_clear(cmd_output);
-
-            /* jump to next line */
-            raw = newline + 1;
-            free(tagged_msg);
-        }
-
-        /* beginning of next line. the line continues by next read() */
-        strbuf_append_str(cmd_output, raw);
-    }
-
-    if (r < 0 && errno == EAGAIN)
-        /* We got all buffered data, but fd is still open. Done for now */
-        return TRUE; /* "please don't remove this event (yet)" */
-
-    /* EOF/error */
-
-    strbuf_clear(cmd_output);
-
-    unexport_event_config(evd->env_list);
-    evd->env_list = NULL;
-
-    /* Wait for child to actually exit, collect status */
-    int status;
-    safe_waitpid(evd->run_state->command_pid, &status, 0);
-    int retval = WEXITSTATUS(status);
-    if (WIFSIGNALED(status))
-        retval = WTERMSIG(status) + 128;
-
-    /* Make sure "Cancel" button won't send anything (process is gone) */
-    g_event_child_pid = -1;
-    evd->run_state->command_pid = -1; /* just for consistency */
-
-    /* Write a final message to the log */
-    if (evd->event_log->len != 0 &&
evd->event_log->buf[evd->event_log->len - 1] != '\n')
-        save_to_event_log(evd, "\n");
-    /* If program failed, or if it finished successfully without saying anything... */
-    if (retval != 0 || evd->event_log_state == LOGSTATE_FIRSTLINE)
-    {
-        if (retval != 0) /* If program failed, emit error line */
-            evd->event_log_state = LOGSTATE_ERRLINE;
-        char *msg;
-        if (WIFSIGNALED(status))
-            msg = xasprintf("(killed by signal %u)\n", WTERMSIG(status));
-        else
-            msg = xasprintf("(exited with %u)\n", retval);
-        append_to_textview(evd->tv_log, msg);
-        save_to_event_log(evd, msg);
-        free(msg);
-    }
-
-    /* Append log to FILENAME_EVENT_LOG */
-    update_event_log_on_disk(evd->event_log->buf);
-    strbuf_clear(evd->event_log);
-    evd->event_log_state = LOGSTATE_FIRSTLINE;
-
-    if (geteuid() == 0)
-    {
-        /* Reset mode/uig/gid to correct values for all files created by event run */
-        struct dump_dir *dd = dd_opendir(g_dump_dir_name, 0);
-        if (dd)
-        {
-            dd_sanitize_mode_and_owner(dd);
-            dd_close(dd);
-        }
-    }
-
-    if (retval != 0)
-    {
-	/* If we were running -e EV1 -e EV2, stop if EV1 failed: */
-	g_auto_event_list = NULL;
-    }
-
-    /* Stop if exit code is not 0, or no more commands */
-    if (retval != 0
-     || spawn_next_command_in_evd(evd) < 0
-    ) {
-        VERB1 log("done running event on '%s': %d", g_dump_dir_name,
retval);
-        append_to_textview(evd->tv_log, "\n");
-
-        if (retval)
-            gtk_label_set_text(evd->status_label, evd->error_msg);
-        else
-            gtk_label_set_text(evd->status_label, evd->success_msg);
-
-        /* Free child output buffer */
-        strbuf_free(cmd_output);
-        cmd_output = NULL;
-
-        /* Hide spinner and stop btn */
-        gtk_widget_hide(GTK_WIDGET(g_spinner_event_log));
-        gtk_widget_hide(g_btn_stop);
-        /* Enable (un-gray out) navigation buttons */
-        gtk_widget_set_sensitive(g_btn_close, true);
-        gtk_widget_set_sensitive(g_btn_next, true);
-
-        /*g_source_remove(evd->event_source_id);*/
-        close(evd->fd);
-        free_run_event_state(evd->run_state);
-        strbuf_free(evd->event_log);
-        free(evd);
-
-        reload_problem_data_from_dump_dir();
-        update_gui_state_from_problem_data();
-
-        /* Inform abrt-gui that it is a good idea to rescan the directory */
-        kill(getppid(), SIGCHLD);
-
-        return FALSE; /* "please remove this event" */
-    }
-
-    /* New command was started. Continue waiting for input */
-
-    /* Transplant cmd's output fd onto old one, so that main loop
-     * is none the wiser that fd it waits on has changed
-     */
-    xmove_fd(evd->run_state->command_out_fd, evd->fd);
-    evd->run_state->command_out_fd = evd->fd; /* just to keep it consistent */
-    ndelay_on(evd->fd);
-
-    /* Revive "Cancel" button */
-    g_event_child_pid = evd->run_state->command_pid;
-
-    return TRUE; /* "please don't remove this event (yet)" */
-}
-
-static void start_event_run(const char *event_name,
-                GtkWidget *page,
-                GtkTextView *tv_log,
-                GtkLabel *status_label,
-                const char *start_msg,
-                const char *error_msg,
-                const char *success_msg
-) {
-    /* Start event asynchronously on the dump dir
-     * (synchronous run would freeze GUI until completion)
-     */
-    struct run_event_state *state = new_run_event_state();
-
-    if (prepare_commands(state, g_dump_dir_name, event_name) == 0)
-    {
- no_cmds:
-        /* No commands needed?! (This is untypical) */
-        free_run_event_state(state);
-//TODO: better msg?
-        char *msg = xasprintf(_("No processing for event '%s' is
defined"), event_name);
-        gtk_label_set_text(status_label, msg);
-        free(msg);
-        return;
-    }
-
-    struct dump_dir *dd = dd_opendir(g_dump_dir_name, DD_OPEN_READONLY);
-    dd = steal_if_needed(dd);
-    int locked = (dd && dd->locked);
-    dd_close(dd);
-    if (!locked)
-    {
-        free_run_event_state(state);
-        return; /* user refused to steal, or write error, etc... */
-    }
-
-    set_excluded_envvar();
-    GList *env_list = export_event_config(event_name);
-
-    if (spawn_next_command(state, g_dump_dir_name, event_name) < 0)
-    {
-        unexport_event_config(env_list);
-        goto no_cmds;
-    }
-    g_event_child_pid = state->command_pid;
-
-    /* At least one command is needed, and we started first one.
-     * Hook its output fd to the main loop.
-     */
-    struct analyze_event_data *evd = xzalloc(sizeof(*evd));
-    evd->run_state = state;
-    evd->event_name = event_name;
-    evd->env_list = env_list;
-    evd->page_widget = page;
-    evd->status_label = status_label;
-    evd->tv_log = tv_log;
-    evd->error_msg = error_msg;
-    evd->success_msg = success_msg;
-    evd->event_log = strbuf_new();
-    evd->fd = state->command_out_fd;
-    ndelay_on(evd->fd);
-    evd->channel = g_io_channel_unix_new(evd->fd);
-    /*evd->event_source_id = */ g_io_add_watch(evd->channel,
-            G_IO_IN | G_IO_ERR | G_IO_HUP, /* need HUP to detect EOF w/o any data */
-            consume_cmd_output,
-            evd
-    );
-
-    gtk_label_set_text(status_label, start_msg);
-
-    VERB1 log("running event '%s' on '%s'", event_name,
g_dump_dir_name);
-    char *msg = xasprintf("--- Running %s ---\n", event_name);
-    append_to_textview(evd->tv_log, msg);
-    free(msg);
-
-    gtk_widget_show(GTK_WIDGET(g_spinner_event_log));
-    gtk_widget_show(g_btn_stop);
-    /* Disable (gray out) navigation buttons */
-    gtk_widget_set_sensitive(g_btn_close, false);
-    gtk_widget_set_sensitive(g_btn_next, false);
-}
-
-
 /* Backtrace checkbox handling */
 
 static void add_warning(const char *warning)
@@ -1693,127 +1235,12 @@ static void clear_warnings(void)
     gtk_container_foreach(GTK_CONTAINER(g_box_warning_labels), &remove_child_widget,
NULL);
 }
 
-static void check_bt_rating_and_allow_send(void)
-{
-    int minimal_rating = 0;
-    bool send = true;
-
-    /*
-     * FIXME: this should be bind to a reporter not to a compoment
-     * but so far only oopses don't have rating, so for now we
-     * skip the "kernel" manually
-     */
-    const char *analyzer = get_problem_item_content_or_NULL(g_cd, FILENAME_ANALYZER);
-//FIXME: say "no" to special casing!
-    if (analyzer && strcmp(analyzer, "Kerneloops") != 0)
-    {
-        const char *rating_str = get_problem_item_content_or_NULL(g_cd,
FILENAME_RATING);
-//COMPAT, remove after 2.1 release
-        if (!rating_str)
-            rating_str = get_problem_item_content_or_NULL(g_cd, "rating");
-
-        if (rating_str)
-        {
-            char *endptr;
-            errno = 0;
-            long rating = strtol(rating_str, &endptr, 10);
-            if (errno != 0 || endptr == rating_str || *endptr != '\0')
-            {
-                add_warning(_("Reporting disabled because the rating does not
contain a number '%s'."));
-                send = false;
-            }
-
-            GList *li = g_list_selected_reporters;
-            while (li != NULL)
-            {
-                /* need to obey the highest minimal rating of all selected reporters
-                 * FIXME: check this when selecting the reporter and allow select
-                 * only usable ones
-                 */
-                event_config_t *cfg = get_event_config((const char *)li->data);
-                if (cfg->ec_minimal_rating > minimal_rating)
-                {
-                    minimal_rating = cfg->ec_minimal_rating;
-                    VERB1 log("%s reporter sets the minimal rating to: %i",
(const char *)li->data, minimal_rating);
-                }
-
-                li = g_list_next(li);
-            };
-
-            if (rating == minimal_rating) /* bt is usable, but not complete, so show a
warning */
-            {
-                add_warning(_("The backtrace is incomplete, please make sure you
provide the steps to reproduce."));
-            }
-
-            if (rating < minimal_rating)
-            {
-                //FIXME: see CreporterAssistant: 394 for ideas
-                add_warning(_("Reporting disabled because the backtrace is
unusable."));
-                send = false;
-            }
-        }
-    }
-    gtk_widget_set_sensitive(g_btn_next, send);
-}
-
 static void on_bt_approve_toggle(GtkToggleButton *togglebutton, gpointer user_data)
 {
     gtk_widget_set_sensitive(g_btn_next, gtk_toggle_button_get_active(g_tb_approve_bt));
 }
 
-static void toggle_eb_comment(void)
-{
-    /* The page doesn't exist with report-only option */
-    if (pages[PAGENO_EDIT_COMMENT].page_widget == NULL)
-        return;
-
-    bool good =
-        gtk_text_buffer_get_char_count(gtk_text_view_get_buffer(g_tv_comment)) >= 10
-        || gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(g_cb_no_comment));
-
-    /* Allow next page only when the comment has at least 10 chars */
-    gtk_widget_set_sensitive(g_btn_next, good);
-
-    /* And show the eventbox with label */
-    if (good)
-        gtk_widget_hide(GTK_WIDGET(g_eb_comment));
-    else
-        gtk_widget_show(GTK_WIDGET(g_eb_comment));
-}
-
-static void on_comment_changed(GtkTextBuffer *buffer, gpointer user_data)
-{
-    toggle_eb_comment();
-}
-
-static void on_no_comment_toggled(GtkToggleButton *togglebutton, gpointer user_data)
-{
-    toggle_eb_comment();
-}
-
-
-static void on_show_event_list_cb(GtkWidget *button, gpointer user_data)
-{
-    show_events_list_dialog(GTK_WINDOW(g_wnd_assistant));
-}
-
-#if 0
-static void log_ready_state(void)
-{
-    char buf[NUM_PAGES+1];
-    for (int i = 0; i < NUM_PAGES; i++)
-    {
-        char ch = '_';
-        if (pages[i].page_widget)
-            ch = gtk_assistant_get_page_complete(g_assistant, pages[i].page_widget) ?
'+' : '-';
-        buf[i] = ch;
-    }
-    buf[NUM_PAGES] = 0;
-    log("Completeness:[%s]", buf);
-}
-#endif
-
-static gboolean highligh_word_in_tabs(const char *search_word, int flags)
+static gboolean highligh_word_in_tabs(const char *search_word, int flags)
 {
     gboolean found = false;
     GtkTextBuffer *buffer;
@@ -1926,45 +1353,460 @@ static void highlight_forbidden(void)
     list_free_with_free(forbidden_words);
 }
 
-static gint select_next_page_no(gint current_page_no, gpointer data);
+static void process_step_done_callback_fn(struct elp_thread_args *args)
+{
+    /*
+    if (PAGENO_EVENT_PROGRESS == gtk_notebook_get_current_page(g_assistant))
+        event_list_process_loop_next_step(args);
+    */
+}
+
+static void process_start_callback_fn(struct elp_thread_args *args)
+{
+    GList *need_config = NULL;
+    GHashTable *errors = NULL;
+    for(const GList* e = g_auto_event_list; e; e = g_list_next(e))
+    {
+        event_config_t *ec = get_event_config(e->data);
+        errors = validate_event_config(ec);
+        if (errors != NULL)
+        {
+            g_hash_table_unref(errors);
+            need_config = g_list_prepend(need_config, e->data);
+        }
+    }
 
-static void on_page_prepare(GtkNotebook *assistant, GtkWidget *page, gpointer user_data)
+    if (need_config)
+    {
+        gdk_threads_enter();
+        show_event_list_opt_error_dialog(need_config);
+        gdk_threads_leave();
+        g_list_free(need_config);
+    }
+
+    return;
+}
+
+static void process_finish_callback_fn(struct elp_thread_args  *args)
+{
+    free_event_list_process(elp_thread_args_get_process(args));
+
+    gdk_threads_enter();
+
+    if (!g_expert_mode)
+        gtk_main_quit();
+    else
+        gtk_notebook_set_current_page(g_assistant,
pages[PAGENO_EVENT_SELECTOR].page_no);
+
+    gdk_threads_leave();
+}
+
+static void on_btn_cancel_event(GtkButton *button)
 {
-    //int page_no = gtk_assistant_get_current_page(g_assistant);
-    //log_ready_state();
+    if (g_event_process)
+        elp_thread_loop_kill_command(g_event_process);
+}
+
+static void on_next_btn_cb(GtkWidget *btn, gpointer user_data)
+{
+    const gint current_page_no = gtk_notebook_get_current_page(g_assistant);
+    const gint next_page_no =  select_next_page_no(current_page_no);
+
+    if (g_reviewing_data || !elp_thread_is_runnig(g_event_process))
+        gtk_notebook_set_current_page(g_assistant, next_page_no);
+    else
+        elp_thread_loop_next_step(g_event_process);
+}
+
+static void gtk_alert(const char *msg, void *args)
+{
+    gdk_threads_enter();
 
-    /* This suppresses [Last] button: assistant thinks that
-     * we never have this page ready unless we are on it
-     * -> therefore there is at least one non-ready page
-     * -> therefore it won't show [Last]
+    GtkWidget *dialog = gtk_message_dialog_new(GTK_WINDOW(g_wnd_assistant),
+            GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
+            GTK_MESSAGE_WARNING,
+            GTK_BUTTONS_CLOSE,
+            "%s", msg);
+    char *tagged_msg = tag_url(msg, "\n");
+    gtk_message_dialog_set_markup(GTK_MESSAGE_DIALOG(dialog), tagged_msg);
+    free(tagged_msg);
+
+    gtk_dialog_run(GTK_DIALOG(dialog));
+    gtk_widget_destroy(dialog);
+
+    gdk_threads_leave();
+}
+
+static char *gtk_ask(const char *msg, void *args)
+{
+    gdk_threads_enter();
+
+    GtkWidget *dialog = gtk_message_dialog_new(GTK_WINDOW(g_wnd_assistant),
+            GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
+            GTK_MESSAGE_QUESTION,
+            GTK_BUTTONS_OK_CANCEL,
+            "%s", msg);
+    char *tagged_msg = tag_url(msg, "\n");
+    gtk_message_dialog_set_markup(GTK_MESSAGE_DIALOG(dialog), tagged_msg);
+    free(tagged_msg);
+
+    GtkWidget *vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
+    GtkWidget *textbox = gtk_entry_new();
+    /* gtk_entry_set_editable(GTK_ENTRY(textbox), TRUE);
+     * is not available in gtk3, so please use the highlevel
+     * g_object_set
      */
-    // Doesn't work: if Completeness:[++++++-+++],
-    // then [Last] btn will still be shown.
-    //gtk_assistant_set_page_complete(g_assistant,
-    //            pages[PAGENO_REVIEW_DATA].page_widget,
-    //            pages[PAGENO_REVIEW_DATA].page_widget == page
-    //);
+    g_object_set(G_OBJECT(textbox), "editable", TRUE, NULL);
+    gtk_box_pack_start(GTK_BOX(vbox), textbox, TRUE, TRUE, 0);
+    gtk_widget_show(textbox);
 
-    if (pages[PAGENO_SUMMARY].page_widget == page)
+    char *response = NULL;
+    if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK)
     {
-        if (!g_expert_mode)
-        {
-            /* Skip intro screen */
-            int n = select_next_page_no(pages[PAGENO_SUMMARY].page_no, NULL);
-            VERB2 log("switching to page_no:%d", n);
-            gtk_notebook_set_current_page(assistant, n);
-            return;
-        }
+        const char *text = gtk_entry_get_text(GTK_ENTRY(textbox));
+        response = xstrdup(text);
     }
+    else
+        response = xstrdup("");
+
+    gtk_widget_destroy(textbox);
+    gtk_widget_destroy(dialog);
 
-    if (pages[PAGENO_EDIT_ELEMENTS].page_widget == page)
+    gdk_threads_leave();
+
+    return response;
+}
+
+static int gtk_ask_yes_no(const char *msg, void *args)
+{
+    gdk_threads_enter();
+
+    GtkWidget *dialog = gtk_message_dialog_new(GTK_WINDOW(g_wnd_assistant),
+            GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
+            GTK_MESSAGE_QUESTION,
+            GTK_BUTTONS_YES_NO,
+            "%s", msg);
+    char *tagged_msg = tag_url(msg, "\n");
+    gtk_message_dialog_set_markup(GTK_MESSAGE_DIALOG(dialog), tagged_msg);
+    free(tagged_msg);
+
+    const int ret = gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_YES;
+
+    gtk_widget_destroy(dialog);
+
+    gdk_threads_leave();
+
+    return ret;
+}
+
+static int gtk_ask_password(const char *msg, char **password, void *args)
+{
+    gdk_threads_enter();
+
+    GtkWidget *dialog = gtk_message_dialog_new(GTK_WINDOW(g_wnd_assistant),
+            GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
+            GTK_MESSAGE_QUESTION,
+            GTK_BUTTONS_OK_CANCEL,
+            "%s", msg);
+    char *tagged_msg = tag_url(msg, "\n");
+    gtk_message_dialog_set_markup(GTK_MESSAGE_DIALOG(dialog), tagged_msg);
+    free(tagged_msg);
+
+    GtkWidget *vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
+    GtkWidget *textbox = gtk_entry_new();
+    /* gtk_entry_set_editable(GTK_ENTRY(textbox), TRUE);
+     * is not available in gtk3, so please use the highlevel
+     * g_object_set
+     */
+    g_object_set(G_OBJECT(textbox), "editable", TRUE, NULL);
+    gtk_entry_set_visibility(GTK_ENTRY(textbox), FALSE);
+    gtk_box_pack_start(GTK_BOX(vbox), textbox, TRUE, TRUE, 0);
+    gtk_widget_show(textbox);
+
+    char *response = NULL;
+    int ret = 0;
+    if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK)
     {
-        clear_warnings();
-        check_bt_rating_and_allow_send();
-        highlight_forbidden();
-        show_warnings();
+        ret = 1;
+        const char *text = gtk_entry_get_text(GTK_ENTRY(textbox));
+        response = xstrdup(text);
     }
+    else
+        response = xstrdup("");
+
+    gtk_widget_destroy(textbox);
+    gtk_widget_destroy(dialog);
+
+    if (password)
+        *password = response;
+    else
+        free(response);
+
+    gdk_threads_leave();
+
+    return ret;
+}
+
+static void gtk_command_started(pid_t pid, void *args)
+{
+    gdk_threads_enter();
+
+    VERB3 log("Running event command %d", pid);
+
+    gdk_threads_leave();
+}
+
+static void gtk_command_msg_processed(const char *msg, const char *raw_input, const char
*rsp, void *args)
+{
+    gdk_threads_enter();
+
+    gtk_label_set_text(g_lbl_event_log, msg);
+    append_to_textview(g_tv_event_log, msg);
+    append_to_textview(g_tv_event_log, "\n");
+
+    gdk_threads_leave();
+}
+
+static void gtk_command_finished(int retval, int status, const char *err_msg, void
*args)
+{
+    gdk_threads_enter();
+
+    if (err_msg)
+    {
+        char *msg;
+        msg = xasprintf("(%s)\n", err_msg);
+        append_to_textview(g_tv_event_log, msg);
+        free(msg);
+    }
+
+    gdk_threads_leave();
+}
+
+static enum elp_signal_ret gtk_next_event_selected(struct event_list_process *process)
+{
+    gdk_threads_enter();
+
+    if (!g_expert_mode)
+    {   /* In the expert mode an executed list was build from g_event_list */
+        /* therefore we have to care about a selected event only in not expert mode */
+        free(g_event_selected);
+        g_event_selected = xstrdup(elp_get_current_event(process));
+    }
+
+    gdk_threads_leave();
+
+    return ELPSR_CONTINUE;
+}
+
+static enum elp_signal_ret gtk_review_data(struct event_list_process *process)
+{
+    gdk_threads_enter();
+
+    g_reviewing_data = true;
+
+    if (get_problem_item_content_or_NULL(g_cd, FILENAME_COMMENT))
+        gtk_notebook_set_current_page(g_assistant, pages[PAGENO_EDIT_ELEMENTS].page_no);
+    else
+        gtk_notebook_set_current_page(g_assistant, pages[PAGENO_EDIT_COMMENT].page_no);
+
+    gdk_threads_leave();
+
+    return ELPSR_CONTINUE;
+}
+
+static enum elp_signal_ret gtk_run_event(struct event_list_process *process)
+{
+    gdk_threads_enter();
+
+    set_excluded_envvar();
+    const char *event_name = elp_get_current_event(process);
+    log("running event '%s' on '%s'", event_name,
g_dump_dir_name);
+    export_event_config(event_name);
+
+    gtk_label_set_text(g_lbl_event_log, _("Processing..."));
+
+    char *msg = xasprintf("--- Running %s ---\n", event_name);
+    append_to_textview(g_tv_event_log, msg);
+    free(msg);
+
+    gtk_widget_show(GTK_WIDGET(g_spinner_event_log));
+    gtk_widget_show(g_btn_stop);
+    /* Disable (gray out) navigation buttons */
+    gtk_widget_set_sensitive(g_btn_close, false);
+    gtk_widget_set_sensitive(g_btn_next, false);
+
+    gtk_notebook_set_current_page(g_assistant, PAGENO_EVENT_PROGRESS);
+
+    gdk_threads_leave();
+
+    return ELPSR_CONTINUE;
+}
+
+static void event_finished(const char *event_name, const char *message)
+{
+    //unexport_event_config(event_name);
 
+    VERB1 log("done running event on '%s'", g_dump_dir_name);
+    append_to_textview(g_tv_event_log, "\n");
+    gtk_label_set_text(g_lbl_event_log, message);
+
+    /* Hide spinner and stop btn */
+    gtk_widget_hide(GTK_WIDGET(g_spinner_event_log));
+    gtk_widget_hide(g_btn_stop);
+    /* Enable (un-gray out) navigation buttons */
+    gtk_widget_set_sensitive(g_btn_close, true);
+    gtk_widget_set_sensitive(g_btn_next, true);
+
+    reload_problem_data_from_dump_dir();
+    update_gui_state_from_problem_data();
+
+    /* Inform abrt-gui that it is a good idea to rescan the directory */
+    kill(getppid(), SIGCHLD);
+}
+
+static enum elp_signal_ret gtk_event_done(struct event_list_process *process)
+{
+    gdk_threads_enter();
+
+    const char *const event_name = elp_get_current_event(process);
+    const enum elp_event_run_status status = elp_get_last_event_status(process);
+    switch(status)
+    {
+        case ELP_ERS_SUCCESSFUL:
+            event_finished(event_name,
+                           _("Processing finished, please proceed to the next
step."));
+            break;
+
+        case ELP_ERS_FAILED:
+            event_finished(event_name,
+                           _("Processing failed. You can try another operation if
available."));
+            break;
+
+        case ELP_ERS_NOT_FOUND:
+            event_finished(event_name,
+                           _("We are so sorry, it is not possible to find any
processing for this problem."));
+            break;
+
+        case ELP_ERS_NONE:
+            /* fall throug */
+        default:
+            error_msg_and_die("unexpected event return status '%d'",
status);
+            break;
+    }
+
+    gdk_threads_leave();
+    return ELPSR_CONTINUE;
+}
+
+static enum elp_signal_ret gtk_finished(struct event_list_process *process)
+{
+    gdk_threads_enter();
+
+    gtk_notebook_set_current_page(g_assistant, PAGENO_EVENT_PROGRESS);
+    gtk_label_set_text(g_lbl_event_log, _("Thank you!"));
+
+    gdk_threads_leave();
+
+    return ELPSR_CONTINUE;
+}
+
+static enum elp_signal_ret gtk_configuration_issue(struct event_list_process *process)
+{
+
+    enum elp_signal_ret ret = ELPSR_CONTINUE;
+
+    if (!g_expert_mode)
+    {
+        const struct elp_configuration_issue *last =
elp_get_last_configuration_issue(process);
+
+        char *detail = format_glist_of_strings(last->issues, "* %s",
"\n");
+        event_config_t *ec = get_event_config(last->event_name);
+
+        char *warning = xasprintf("Processing of '%s' has following
problems:\n%s",
+                                    ec ? ec->screen_name : last->event_name,
detail);
+
+        gdk_threads_enter();
+        if (last->usability == EUS_LOW)
+            add_warning(warning);
+        else if (last->usability == EUS_UNUSABLE)
+            show_error_as_msgbox_mts(warning, false);
+        gdk_threads_leave();
+
+        free(warning);
+        free(detail);
+        ret = last->usability == EUS_UNUSABLE ? ELPSR_FINISH : ELPSR_CONTINUE;
+    }
+
+    return ret;
+}
+
+static void toggle_eb_comment(void)
+{
+    /* The page doesn't exist with report-only option */
+    if (pages[PAGENO_EDIT_COMMENT].page_widget == NULL)
+        return;
+
+    bool good =
+        gtk_text_buffer_get_char_count(gtk_text_view_get_buffer(g_tv_comment)) >= 10
+        || gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(g_cb_no_comment));
+
+    /* Allow next page only when the comment has at least 10 chars */
+    gtk_widget_set_sensitive(g_btn_next, good);
+
+    /* And show the eventbox with label */
+    if (good)
+        gtk_widget_hide(GTK_WIDGET(g_eb_comment));
+    else
+        gtk_widget_show(GTK_WIDGET(g_eb_comment));
+}
+
+static void on_comment_changed(GtkTextBuffer *buffer, gpointer user_data)
+{
+    toggle_eb_comment();
+}
+
+static void on_no_comment_toggled(GtkToggleButton *togglebutton, gpointer user_data)
+{
+    toggle_eb_comment();
+}
+
+
+static void on_show_event_list_cb(GtkWidget *button, gpointer user_data)
+{
+    show_events_list_dialog(GTK_WINDOW(g_wnd_assistant));
+}
+
+#if 0
+static void log_ready_state(void)
+{
+    char buf[NUM_PAGES+1];
+    for (int i = 0; i < NUM_PAGES; i++)
+    {
+        char ch = '_';
+        if (pages[i].page_widget)
+            ch = gtk_assistant_get_page_complete(g_assistant, pages[i].page_widget) ?
'+' : '-';
+        buf[i] = ch;
+    }
+    buf[NUM_PAGES] = 0;
+    log("Completeness:[%s]", buf);
+}
+#endif
+
+static void start_event_list_process(const GList *event_list)
+{
+    if (g_run_obs)
+        free_command_log_run_event_observer(g_run_obs);
+
+    g_run_obs = new_command_log_run_event_observer(g_dump_dir_name, &g_gtk_run_obs);
+
+    struct event_list_process *proc =
+        new_event_list_process(event_list, &g_process_impl, g_run_impl, g_run_obs,
g_dump_dir_name, NULL);
+
+    elp_thread_run(g_event_process, proc);
+}
+
+static void on_page_prepare(GtkNotebook *assistant, GtkWidget *page, gpointer user_data)
+{
     /* Save text fields if changed */
     save_items_from_notepad();
     save_text_from_text_view(g_tv_comment, FILENAME_COMMENT);
@@ -1972,6 +1814,8 @@ static void on_page_prepare(GtkNotebook *assistant, GtkWidget *page,
gpointer us
     if (pages[PAGENO_SUMMARY].page_widget == page
      || pages[PAGENO_REVIEW_DATA].page_widget == page
     ) {
+        elp_thread_loop_next_step(g_event_process);
+
         GtkWidget *w = GTK_WIDGET(g_tv_details);
         GtkContainer *c = GTK_CONTAINER(gtk_widget_get_parent(w));
         if (c)
@@ -1988,139 +1832,67 @@ static void on_page_prepare(GtkNotebook *assistant, GtkWidget
*page, gpointer us
         if (pages[PAGENO_REVIEW_DATA].page_widget == page)
         {
             gtk_widget_set_sensitive(g_btn_next,
gtk_toggle_button_get_active(g_tb_approve_bt));
-            update_ls_details_checkboxes();
+            update_ls_details_checkboxes(g_event_selected);
         }
     }
 
-    if (pages[PAGENO_EDIT_COMMENT].page_widget == page)
+    if (pages[PAGENO_EDIT_COMMENT].page_widget == page )
     {
         gtk_widget_set_sensitive(g_btn_next, false);
         on_comment_changed(gtk_text_view_get_buffer(g_tv_comment), NULL);
     }
-    //log_ready_state();
 
-    if (pages[PAGENO_EVENT_PROGRESS].page_widget == page)
+    if (pages[PAGENO_EDIT_ELEMENTS].page_widget == page )
     {
-        VERB2 log("g_event_selected:'%s'", g_event_selected);
-        if (g_event_selected
-         && g_event_selected[0]
-        ) {
-            start_event_run(g_event_selected,
-                    pages[PAGENO_EVENT_PROGRESS].page_widget,
-                    g_tv_event_log,
-                    g_lbl_event_log,
-                    _("Processing..."),
-                    _("Processing failed. You can try another operation if
available."),
-                    _("Processing finished, please proceed to the next step.")
-            );
-
-            if (g_auto_event_list)
-            {
-                g_auto_event_list = g_auto_event_list->next;
-                VERB1 log("next -e EVENT:%s", g_auto_event_list ?
(char*)g_auto_event_list->data : "NULL");
-            }
-        }
+        clear_warnings();
+        highlight_forbidden();
+        show_warnings();
     }
 }
 
-static gint select_next_page_no(gint current_page_no, gpointer data)
+static gint select_next_page_no(gint current_page_no)
 {
     GtkWidget *page;
 
-    if (g_report_only)
-    {
-        /* In only-report mode, we only need to wrap back at the end */
-        page = gtk_notebook_get_nth_page(g_assistant, current_page_no);
-        if (page == pages[PAGENO_EVENT_DONE].page_widget)
-            current_page_no = 0;
-        else
-            current_page_no++;
-        VERB1 log("%s: selected page #%d", __func__, current_page_no);
-        return current_page_no;
-    }
-
- again:
     VERB1 log("%s: current_page_no:%d", __func__, current_page_no);
-    current_page_no++;
     page = gtk_notebook_get_nth_page(g_assistant, current_page_no);
 
     if (pages[PAGENO_EVENT_SELECTOR].page_widget == page)
     {
-        if (!g_expert_mode)
-        {
-            VERB1 log("selected -e EVENT:%s on page: %d",
(char*)g_auto_event_list->data, current_page_no);
-            free(g_event_selected);
-            g_event_selected = xstrdup((char*)g_auto_event_list->data);
-            /*
-             * We don't remove the list element, because GTK calls
select_next_page_no()
-             * spuriously (for example, it calls it twice for first page).
-             */
-
-            if (check_event_config(g_event_selected) != 0)
-            {
-                goto again;
-            }
+        if(!g_expert_mode)
+            error_msg_and_die("Event selector is enabled only in export
mode.");
 
-            current_page_no = pages[PAGENO_EVENT_SELECTOR].page_no + 1;
-            goto event_was_selected;
+        struct dump_dir *dd = dd_opendir(g_dump_dir_name, DD_OPEN_READONLY);
+        dd = steal_if_needed(dd);
+        const int locked = dd && dd->locked;
+        dd_close(dd);
 
-        }
-    }
+        if (!locked)
+            return current_page_no;
 
-    if (pages[PAGENO_EVENT_SELECTOR + 1].page_widget == page)
-    {
- event_was_selected:
-        if (!g_event_selected)
-        {
-            /* Go back to selectors */
-            current_page_no = pages[PAGENO_EVENT_SELECTOR].page_no - 1;
-            goto again;
-        }
+        g_list_free(g_auto_event_list);
+        g_auto_event_list = NULL;
+        g_auto_event_list = g_list_prepend(g_auto_event_list, g_event_selected);
 
-        event_config_t *cfg = get_event_config(g_event_selected);
-        if (cfg && cfg->ec_skip_review)
-        {
-            current_page_no = pages[PAGENO_EVENT_PROGRESS].page_no - 1;
-            goto again;
-        }
-        if (!get_problem_item_content_or_NULL(g_cd, FILENAME_BACKTRACE))
-            goto again; /* no backtrace, skip this page */
+        start_event_list_process(g_auto_event_list);
     }
 
-#if 0
-    if (pages[PAGENO_EDIT_COMMENT].page_widget == page)
-    {
-        if (get_problem_item_content_or_NULL(g_cd, FILENAME_COMMENT))
-            goto again; /* no comment, skip this page */
-    }
-#endif
+    ++current_page_no;
+
+    if (pages[PAGENO_REVIEW_DATA].page_widget == page)
+        g_reviewing_data = false;
 
     if (pages[PAGENO_EVENT_DONE].page_widget == page)
-    {
-        if (g_auto_event_list)
-        {
-            /* Go back to selectors */
-            current_page_no = pages[PAGENO_SUMMARY].page_no;
-        }
-        goto again;
-    }
+        current_page_no = pages[PAGENO_EVENT_SELECTOR].page_no;
 
     if (pages[PAGENO_NOT_SHOWN].page_widget == page)
-    {
-        if (!g_expert_mode)
-            exit(0);
-        /* No! this would SEGV (infinitely recurse into select_next_page_no) */
-        /*gtk_assistant_commit(g_assistant);*/
-        current_page_no = pages[PAGENO_EVENT_SELECTOR].page_no - 1;
-        goto again;
-    }
+        current_page_no = pages[PAGENO_EVENT_SELECTOR].page_no;
 
     VERB1 log("%s: selected page #%d", __func__, current_page_no);
     return current_page_no;
 }
 
 
-
 static void highlight_widget(GtkWidget *widget, gpointer *user_data)
 {
     gtk_drag_highlight(widget);
@@ -2296,7 +2068,7 @@ static void on_btn_add_file(GtkButton *button)
                         reload_problem_data_from_dump_dir();
                         update_gui_state_from_problem_data();
                         /* Set flags for the new item */
-                        update_ls_details_checkboxes();
+                        update_ls_details_checkboxes(g_event_selected);
                     }
                 }
                 free(new_name);
@@ -2381,18 +2153,6 @@ static gint on_key_press_event_in_item_list(GtkTreeView *treeview,
GdkEventKey *
 /* wizard.glade file as a string WIZARD_GLADE_CONTENTS: */
 #include "wizard_glade.c"
 
-static void on_next_btn_cb(GtkWidget *btn, gpointer user_data)
-{
-    gint current_page_no = gtk_notebook_get_current_page(g_assistant);
-    gint next_page_no = select_next_page_no(current_page_no, NULL);
-
-    /* if pageno is not change 'switch-page' signal is not emitted */
-    if (current_page_no == next_page_no)
-        on_page_prepare(g_assistant, gtk_notebook_get_nth_page(g_assistant,
next_page_no), NULL);
-    else
-        gtk_notebook_set_current_page(g_assistant, next_page_no);
-}
-
 static void add_pages(void)
 {
     GError *error = NULL;
@@ -2424,23 +2184,11 @@ static void add_pages(void)
     dd_close(dd);
 
     int i;
-    int page_no = 0;
     for (i = 0; page_names[i] != NULL; i++)
     {
-        char *delim = strrchr(page_names[i], '_');
-        if (!not_reportable && delim)
-        {
-            if (g_report_only && (strncmp(delim + 1, "report",
strlen("report"))) != 0)
-            {
-                pages[i].page_widget = NULL;
-                pages[i].page_no = -1;
-                continue;
-            }
-        }
-
         GtkWidget *page = GTK_WIDGET(gtk_builder_get_object(g_builder, page_names[i]));
         pages[i].page_widget = page;
-        pages[i].page_no = page_no++;
+        pages[i].page_no = i;
         gtk_notebook_append_page(g_assistant, page, gtk_label_new(pages[i].title));
         VERB1 log("added page: %s", page_names[i]);
     }
@@ -2568,10 +2316,53 @@ static void init_pages(void)
     init_page(&pages[7], PAGE_NOT_SHOWN          , ""                      
  );
 }
 
+static gboolean gtk_g_idle_prepare(GSource *source_data, gint *timeout)
+{
+    return TRUE;
+}
+
+static gboolean gtk_g_idle_check(GSource *source)
+{
+    return TRUE;
+}
+
+static gboolean gtk_g_idle_dispatch(GSource *source, GSourceFunc callback, gpointer 
user_data)
+{
+    /* Start processing of list of events */
+    gdk_threads_enter();
+
+    struct dump_dir *dd = dd_opendir(g_dump_dir_name, DD_OPEN_READONLY);
+    dd = steal_if_needed(dd);
+    const int locked = dd && dd->locked;
+    dd_close(dd);
+
+    gdk_threads_leave();
+
+    if (!locked)
+    {
+        gtk_main_quit();
+        return FALSE;
+    }
+
+    start_event_list_process(g_auto_event_list);
+    elp_thread_loop_next_step(g_event_process);
+    return FALSE;
+}
+
+struct gtk_assistant_source
+{
+    GSource source;
+};
+
 void create_assistant(void)
 {
+
     g_expert_mode = !g_auto_event_list;
 
+    /* Run event callback for gtk are wrapped with logging implementation */
+    /* TODO : missing clean up */
+    g_run_impl = &g_gtk_run_impl;
+
     g_monospace_font = pango_font_description_from_string("monospace");
     g_builder = gtk_builder_new();
 
@@ -2599,6 +2390,7 @@ void create_assistant(void)
     gtk_widget_hide(g_btn_stop);
 
     g_wnd_assistant = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL));
+
     gtk_container_add(GTK_CONTAINER(g_wnd_assistant), GTK_WIDGET(g_box_assistant));
 
     gtk_window_set_default_size(g_wnd_assistant, DEFAULT_WIDTH, DEFAULT_HEIGHT);
@@ -2627,6 +2419,26 @@ void create_assistant(void)
 
     g_signal_connect(g_search_entry_bt, "changed", G_CALLBACK(search_timeout),
NULL);
 
-    /* switch to right starting page */
-    on_page_prepare(g_assistant, gtk_notebook_get_nth_page(g_assistant, 0), NULL);
+    elp_thread_args_set_on_step_done(g_event_process, process_step_done_callback_fn);
+    elp_thread_args_set_on_start(g_event_process, process_start_callback_fn);
+    elp_thread_args_set_on_finish(g_event_process, process_finish_callback_fn);
+
+    g_gui_thread_id = pthread_self();
+
+    if (!g_expert_mode)
+    {
+        static GSourceFuncs idle_funcs = {
+            .prepare=gtk_g_idle_prepare,
+            .check=gtk_g_idle_check,
+            .dispatch=gtk_g_idle_dispatch,
+            .finalize=NULL,
+            .closure_callback=NULL,
+            .closure_marshal=NULL
+        };
+
+        struct gtk_assistant_source *const gtk_assistant_source =
+            (struct gtk_assistant_source*)g_source_new(&idle_funcs,
sizeof(*gtk_assistant_source));
+
+        g_source_attach((GSource*)gtk_assistant_source,
g_main_context_get_thread_default());
+    }
 }
diff --git a/src/gui-wizard-gtk/wizard.glade b/src/gui-wizard-gtk/wizard.glade
index 41924eb..7029677 100644
--- a/src/gui-wizard-gtk/wizard.glade
+++ b/src/gui-wizard-gtk/wizard.glade
@@ -178,7 +178,7 @@
   <object class="GtkWindow" id="window2">
     <property name="can_focus">False</property>
     <child>
-      <object class="GtkVBox" id="page_2_report">
+      <object class="GtkVBox" id="page_2">
         <property name="visible">True</property>
         <property name="can_focus">False</property>
         <property name="border_width">10</property>
@@ -485,7 +485,7 @@
   <object class="GtkWindow" id="window4">
     <property name="can_focus">False</property>
     <child>
-      <object class="GtkVBox" id="page_4_report">
+      <object class="GtkVBox" id="page_4">
         <property name="visible">True</property>
         <property name="can_focus">False</property>
         <property name="border_width">10</property>
@@ -598,7 +598,7 @@
   <object class="GtkWindow" id="window5">
     <property name="can_focus">False</property>
     <child>
-      <object class="GtkVBox" id="page_5_report">
+      <object class="GtkVBox" id="page_5">
         <property name="visible">True</property>
         <property name="can_focus">False</property>
         <property name="border_width">10</property>
@@ -683,7 +683,7 @@
   <object class="GtkWindow" id="window6">
     <property name="can_focus">False</property>
     <child>
-      <object class="GtkVBox" id="page_6_report">
+      <object class="GtkVBox" id="page_6">
         <property name="visible">True</property>
         <property name="can_focus">False</property>
         <property name="border_width">10</property>
@@ -727,7 +727,7 @@
   <object class="GtkWindow" id="window7">
     <property name="can_focus">False</property>
     <child>
-      <object class="GtkVBox" id="page_7_report">
+      <object class="GtkVBox" id="page_7">
         <property name="visible">True</property>
         <property name="can_focus">False</property>
         <property name="border_width">10</property>
diff --git a/src/gui-wizard-gtk/wizard.h b/src/gui-wizard-gtk/wizard.h
index a818828..64e6a4b 100644
--- a/src/gui-wizard-gtk/wizard.h
+++ b/src/gui-wizard-gtk/wizard.h
@@ -25,6 +25,8 @@ void create_assistant(void);
 void update_gui_state_from_problem_data(void);
 void show_error_as_msgbox(const char *msg);
 
+struct elp_thread_args;
+extern struct elp_thread_args *g_event_process;
 
 extern char *g_glade_file;
 extern char *g_dump_dir_name;
-- 
1.7.10.2