Make Smman catch SIGUSR1 signals to reload rules. Make Smman v2.0.0

10 files changed, 102 insertions, 14 deletions

diff --git a/configure.ac b/configure.ac
index 0c0c1c2..5f3b7f6 100644
--- a/configure.ac
+++ b/configure.ac
@@ -1,6 +1,6 @@
-m4_define([v_maj], [1])
+m4_define([v_maj], [2])
 m4_define([v_min], [0])
-m4_define([v_mic], [1])
+m4_define([v_mic], [0])
 m4_define([v_ver], [v_maj.v_min.v_mic])
 
 AC_INIT([smman], [v_ver], [kuri@efl.so])
diff --git a/src/bin/filter.c b/src/bin/filter.c
index fec905e..a75c364 100644
--- a/src/bin/filter.c
+++ b/src/bin/filter.c
@@ -2,9 +2,32 @@
 #include <glob.h>
 
 static void
-_filter_rules_free(void *data)
+_filter_rules_free(void *data EINA_UNUSED)
 {
-   rules_rule_free((Rule *)data);
+}
+
+Eina_Bool
+filter_reload(void *data,
+              int type EINA_UNUSED,
+              void *ev EINA_UNUSED)
+{
+   Smman *smman = data;
+   Filter *filter;
+
+   DBG("smman[%p]", smman);
+
+   EINA_INLIST_FOREACH(smman->filters, filter)
+     {
+        spy_file_pause(filter->sf);
+        eina_hash_free(filter->rules);
+        filter->rules = eina_hash_string_superfast_new(_filter_rules_free);
+     }
+
+   rules_purge(smman->rules);
+
+   rules_load(smman->rules, filter_load, filter_load_done,
+              filter_load_error, smman);
+   return EINA_TRUE;
 }
 
 Filter *
@@ -90,12 +113,31 @@ filter_load_done(void *data,
                  Rules *rules)
 {
    Smman *smman;
+   Filter *filter;
+   Eina_Inlist *l;
 
    smman = data;
    if (smman->rules != rules)
      return;
 
    DBG("smman[%p] rules[%p]", smman, rules);
+
+   EINA_INLIST_FOREACH_SAFE(smman->filters, l, filter)
+     {
+        if (eina_hash_population(filter->rules))
+          {
+             DBG("Resuming sf[%p]", filter->sf);
+             spy_file_resume(filter->sf);
+             continue;
+          }
+
+        DBG("Freeing filter %s", filter->filename);
+        smman->filters = eina_inlist_remove(smman->filters, smman->filters);
+        spy_file_free(filter->sf);
+        free((char *)filter->filename);
+        eina_hash_free(filter->rules);
+        free(filter);
+     }
 }
 
 void
diff --git a/src/bin/main.c b/src/bin/main.c
index 9a73992..34d45b9 100644
--- a/src/bin/main.c
+++ b/src/bin/main.c
@@ -77,6 +77,7 @@ init(void)
      }
 
    smman->ev.sl = ecore_event_handler_add(SPY_EVENT_LINE,log_line_event, smman);
+   smman->ev.su = ecore_event_handler_add(ECORE_EVENT_SIGNAL_USER, filter_reload, smman);
    return smman;
 }
 
diff --git a/src/bin/smman.h b/src/bin/smman.h
index d912ffa..55584a7 100644
--- a/src/bin/smman.h
+++ b/src/bin/smman.h
@@ -29,7 +29,8 @@ typedef struct _Smman
 
    struct
    {
-      Ecore_Event_Handler *sl; /* SPY_EVENT_LINE */
+      Ecore_Event_Handler *sl, /* SPY_EVENT_LINE */
+                          *su; /* ECORE_EVENT_SIGNAL_USER */
    } ev;
 } Smman;
 
@@ -53,6 +54,7 @@ void config_error(void *data, Conf *conf, const char *errstr);
 void filter_load(void *data, Rules *rules, Rule *rule);
 void filter_load_done(void *data, Rules *rules);
 void filter_load_error(void *data, Rules *rules, const char *errstr);
+Eina_Bool filter_reload(void *data, int type, void *ev);
 
 Eina_Bool log_line_event(void *data, int type, void *event);
 
diff --git a/src/include/Rules.h b/src/include/Rules.h
index fbd30be..fc8518d 100644
--- a/src/include/Rules.h
+++ b/src/include/Rules.h
@@ -44,6 +44,7 @@ int rules_init(void);
 int rules_shutdown(void);
 
 Rules * rules_new(const char *directory);
+void rules_purge(Rules *rules);
 Eina_Bool rules_load(Rules *rules, Rules_Progress_Cb progress_cb, Rules_Done_Cb done_cb, Rules_Error_Cb error_cb, void *data);
 
 void rules_rule_free(Rule *rule);
diff --git a/src/include/Spy.h b/src/include/Spy.h
index 4064d62..3590075 100644
--- a/src/include/Spy.h
+++ b/src/include/Spy.h
@@ -16,6 +16,7 @@ int spy_shutdown(void);
 Spy * spy_new(void);
 void spy_free(Spy *spy);
 
+void spy_file_free(Spy_File *sf);
 Spy_File * spy_file_new(Spy *spy, const char *file);
 Spy_File * spy_file_get(Spy *spy, const char *file);
 const char * spy_file_name_get(Spy_File *sf);
diff --git a/src/lib/rules/rules_load.c b/src/lib/rules/rules_load.c
index c961739..a4f24af 100644
--- a/src/lib/rules/rules_load.c
+++ b/src/lib/rules/rules_load.c
@@ -83,6 +83,8 @@ rules_load_rule(void *data,
      }
    eina_iterator_free(it);
    rl->cb.progress((void *)rl->cb.data, rl->rules, rule);
+   rl->rules->rules = eina_inlist_append(rl->rules->rules,
+                                         EINA_INLIST_GET(rule));
 }
 
 void
@@ -127,10 +129,13 @@ rules_load_ls(void *data,
 }
 
 void
-rules_load_ls_done(void *data EINA_UNUSED,
+rules_load_ls_done(void *data,
                    Eio_File *handler EINA_UNUSED)
 {
+   Rules_Load *rl = data;
    DBG("End of rules listing.");
+   rl->cb.done((void *)rl->cb.data, rl->rules);
+   free(rl);
 }
 
 
diff --git a/src/lib/rules/rules_main.c b/src/lib/rules/rules_main.c
index e1f73a8..208dead 100644
--- a/src/lib/rules/rules_main.c
+++ b/src/lib/rules/rules_main.c
@@ -7,20 +7,26 @@ int _rules_log_dom_global = -1;
 void
 rules_rule_free(Rule *rule)
 {
-   Rule_Regex *rr;
+   char *s;
    EINA_SAFETY_ON_NULL_RETURN(rule);
 
    free((char *)rule->name);
    free((char *)rule->spec.filename);
    free((char *)rule->spec.source_host);
    free((char *)rule->spec.source_path);
-   free((char *)rule->spec.tags);
 
-   EINA_INLIST_FOREACH(rule->spec.regex, rr)
+   EINA_LIST_FREE(rule->spec.tags, s)
+     free(s);
+
+   while (rule->spec.regex)
      {
+        Rule_Regex *rr = EINA_INLIST_CONTAINER_GET(rule->spec.regex, Rule_Regex);
+        rule->spec.regex = eina_inlist_remove(rule->spec.regex,rule->spec.regex);
+        regfree(&(rr->preg));
         free((char *)rr->regex);
         free(rr);
      }
+   free(rule);
 }
 
 Rules *
@@ -33,6 +39,17 @@ rules_new(const char *directory)
    return rules;
 }
 
+void
+rules_purge(Rules *rules)
+{
+   while (rules->rules)
+     {
+        Rule *rule = EINA_INLIST_CONTAINER_GET(rules->rules, Rule);
+        rules->rules = eina_inlist_remove(rules->rules, rules->rules);
+        rules_rule_free(rule);
+     }
+}
+
 Eina_Bool
 rules_load(Rules *rules,
            Rules_Progress_Cb progress_cb,
diff --git a/src/lib/spy/spy_main.c b/src/lib/spy/spy_main.c
index 3cc7f0c..1e512a0 100644
--- a/src/lib/spy/spy_main.c
+++ b/src/lib/spy/spy_main.c
@@ -26,12 +26,30 @@ spy_free(Spy *spy)
    EINA_SAFETY_ON_NULL_RETURN(spy);
 
    EINA_INLIST_FOREACH_SAFE(spy->files, l, sf)
+     spy_file_free(sf);
+   free(spy);
+}
+
+void
+spy_file_free(Spy_File *sf)
+{
+   Spy_File *tmp;
+
+   EINA_SAFETY_ON_NULL_RETURN(sf);
+
+   EINA_INLIST_FOREACH(sf->spy->files, tmp)
      {
-        free((char *)sf->name);
-        ecore_timer_del(sf->poll.timer);
-        eina_strbuf_free(sf->read.buf);
+        if (sf != tmp)
+          continue;
+
+        sf->spy->files = eina_inlist_remove(sf->spy->files, sf->spy->files);
+        break;
      }
-   free(spy);
+
+   free((char *)sf->name);
+   ecore_timer_del(sf->poll.timer);
+   eina_strbuf_free(sf->read.buf);
+   free(sf);
 }
 
 void
@@ -107,7 +125,7 @@ spy_file_new(Spy *spy, const char *file)
 
    sf->poll.size = st.st_size;
    sf->poll.timer = ecore_timer_loop_add(0.3, spy_file_poll, sf);
-   ecore_timer_precision_set(1.0);
+   sf->spy = spy;
 
    spy->files = eina_inlist_append(spy->files, EINA_INLIST_GET(sf));
    DBG("spy_file[%p] size[%zd]", sf, st.st_size);
diff --git a/src/lib/spy/spy_private.h b/src/lib/spy/spy_private.h
index 26ddfae..4851bc9 100644
--- a/src/lib/spy/spy_private.h
+++ b/src/lib/spy/spy_private.h
@@ -19,6 +19,7 @@ struct _Spy_File
    EINA_INLIST;
    const char *name;
    const void *data;
+   Spy *spy;
 
    struct
    {