Adding libspy.

It needs to be used by smman as this will consume less cpu cycles than
managing inotify events. When having a lot of logs, inotify events gets
too annoying, thus the fact that we miss some of them.

With libspy, files will be polled periodically, no matter the activity
on them.

5 files changed, 445 insertions, 1 deletions

diff --git a/src/include/Spy.h b/src/include/Spy.h
new file mode 100644
index 0000000..cc13da7
--- /dev/null
+++ b/src/include/Spy.h
@@ -0,0 +1,25 @@
+#ifndef SPY_H
+#define SPY_H
+#include <Eina.h>
+#include <Ecore.h>
+#include <Eio.h>
+
+extern int SPY_EVENT_LINE;
+
+typedef struct _Spy Spy;
+typedef struct _Spy_File Spy_File;
+typedef struct _Spy_Line Spy_Line;
+
+int spy_init(void);
+int spy_shutdown(void);
+
+Spy * spy_new(void);
+void spy_free(Spy *spy);
+
+Spy_File *spy_file_new(Spy *spy, const char *file);
+const char * spy_line_get(Spy_Line *sl);
+const char *spy_file_name_get(Spy_File *sf);
+void spy_file_data_set(Spy_File *sf, const void *data);
+const void *spy_file_data_get(Spy_File *sf);
+
+#endif
diff --git a/src/lib/Makefile.mk b/src/lib/Makefile.mk
index a4e2945..88771bb 100644
--- a/src/lib/Makefile.mk
+++ b/src/lib/Makefile.mk
@@ -1,10 +1,20 @@
 MAINTAINERCLEANFILES += src/lib/*.gc{no,da}
 
 noinst_LTLIBRARIES = \
-src/lib/libconf.la
+src/lib/libconf.la \
+src/lib/libspy.la
 
 src_lib_libconf_la_SOURCES = \
 src/lib/conf.c \
 src/include/Conf.h
 src_lib_libconf_la_CFLAGS = $(LIBS_CFLAGS) $(EXTRA_CPPFLAGS)
 src_lib_libconf_la_LDFLAGS = $(LIBS_CFLAGS)
+
+src_lib_libspy_la_SOURCES = \
+src/lib/spy/spy_file.c \
+src/lib/spy/spy_main.c \
+src/lib/spy/spy_private.h \
+src/include/Spy.h
+src_lib_libspy_la_CFLAGS = $(LIBS_CFLAGS) $(EXTRA_CPPFLAGS)
+src_lib_libspy_la_LDFLAGS = $(LIBS_CFLAGS)
+
diff --git a/src/lib/spy/spy_file.c b/src/lib/spy/spy_file.c
new file mode 100644
index 0000000..397862e
--- /dev/null
+++ b/src/lib/spy/spy_file.c
@@ -0,0 +1,208 @@
+#include "spy_private.h"
+
+static void
+_spy_file_job(void *data)
+{
+   spy_file_poll(data);
+}
+
+void
+_spy_file_line_free(void *d1,
+                    void *d2 EINA_UNUSED)
+{
+   Spy_Line *sl = d1;
+
+   free((char *)sl->line);
+   free(sl);
+}
+
+void
+_spy_file_line_extract(Spy_File *sf)
+{
+   const char *s,
+              *p,
+              *p1;
+   size_t rm = 0;
+   Spy_Line *sl;
+
+   s = eina_strbuf_string_get(sf->read.buf);
+   p = s;
+
+   while ((p1=strchr(p, '\n')))
+     {
+        size_t l = p1 - p;
+        char *line;
+
+        rm += l;
+
+        if (!l)
+          goto end;
+
+        line = strndup(p, l);
+
+        DBG("Line = %s len=%zd", line, l);
+        sl = calloc(1, sizeof(Spy_Line));
+        if (!sl)
+          {
+             ERR("Failed to allocate Spy_Line");
+             free(line);
+          }
+
+        sl->sf = sf;
+        sl->line = line;
+        ecore_event_add(SPY_EVENT_LINE, sl, _spy_file_line_free, sl);
+        end:
+        p = p1 + 1;
+     }
+
+   eina_strbuf_remove(sf->read.buf, 0, rm);
+}
+
+void
+_spy_file_cb(void *data,
+             Ecore_Thread *thread EINA_UNUSED)
+{
+   Spy_File *sf;
+   size_t nbr = 0,
+          toread = 0,
+          left = 0;
+   char buf[512];
+
+   sf = data;
+   DBG("sf[%p]", sf);
+
+   sf->read.fd = fopen(sf->name, "r");
+   if (!sf->read.fd)
+     {
+        ERR("Failed to open %s : %s", sf->name, strerror(errno));
+        return;
+     }
+
+   fseeko(sf->read.fd, sf->read.offset, SEEK_SET);
+   left = sf->read.length;
+
+   while (nbr != (size_t)sf->read.length)
+     {
+        toread = (left < 512) ? left : 512;
+
+        if (fread(buf, toread, 1, sf->read.fd) != 1)
+          {
+             ERR("Error while reading file %s : %s",
+                 sf->name, strerror(errno));
+             fclose(sf->read.fd);
+             return;
+          }
+        eina_strbuf_append_length(sf->read.buf, buf, toread);
+        _spy_file_line_extract(sf);
+        nbr += toread;
+     }
+   fclose(sf->read.fd);
+   sf->read.fd = NULL;
+}
+
+void
+_spy_file_end_cb(void *data,
+                 Ecore_Thread *thread EINA_UNUSED)
+{
+   Spy_File *sf;
+
+   sf = data;
+   DBG("sf[%p]", sf);
+
+   ecore_timer_thaw(sf->poll.timer);
+   ecore_timer_reset(sf->poll.timer);
+
+   ecore_job_add(_spy_file_job, sf);
+}
+
+void
+_spy_file_cancel_cb(void *data EINA_UNUSED,
+                    Ecore_Thread *thread EINA_UNUSED)
+{}
+
+Eina_Bool
+spy_file_poll(void *data)
+{
+   Spy_File *sf;
+   off_t size,
+         toread;
+   struct stat st;
+   Ecore_Thread *et;
+
+   sf = data;
+   DBG("spy_file[%p] file[%s]", sf, sf->name);
+
+   /* We should have different actions made depending on error type. */
+   if (stat(sf->name, &st))
+     {
+        ERR("Failed to get size of %s : %s", sf->name, strerror(errno));
+        return EINA_TRUE;
+     }
+
+   size = st.st_size;
+DBG("size=%zu", size);
+   if (sf->poll.size == size)
+     return EINA_TRUE;
+
+   /* File has been trunc! */
+   if (sf->poll.size > size)
+     {
+         DBG("spy_file[%p] File trunc!", sf);
+         sf->poll.size = 0;
+
+         if (!size)
+           return EINA_TRUE;
+     }
+
+   /* We have data to read! */
+   DBG("spy_file[%p] File activity!", sf);
+
+   toread = size - sf->poll.size;
+
+   DBG("spy_file[%p] len_old=%zu len_new=%zu toread=%zu",
+       sf, sf->poll.size, size, toread);
+
+   sf->read.offset = sf->poll.size;
+   sf->read.length = toread;
+
+
+   et = ecore_thread_run(_spy_file_cb,
+                         _spy_file_end_cb,
+                         _spy_file_cancel_cb,
+                         sf);
+   if (!et)
+     {
+        ERR("Failed to create reading thread");
+        return EINA_TRUE;
+     }
+
+   ecore_timer_freeze(sf->poll.timer);
+   sf->poll.size = size;
+   return EINA_TRUE;
+}
+
+const char *
+spy_line_get(Spy_Line *sl)
+{
+   return sl->line;
+}
+
+
+const char *
+spy_file_name_get(Spy_File *sf)
+{
+   return sf->name;
+}
+
+void
+spy_file_data_set(Spy_File *sf,
+                  const void *data)
+{
+   sf->data = (const void *)data;
+}
+
+const void *
+spy_file_data_get(Spy_File *sf)
+{
+   return sf->data;
+}
diff --git a/src/lib/spy/spy_main.c b/src/lib/spy/spy_main.c
new file mode 100644
index 0000000..8084050
--- /dev/null
+++ b/src/lib/spy/spy_main.c
@@ -0,0 +1,157 @@
+#include "spy_private.h"
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+static int _spy_init_count = 0;
+int _spy_log_dom_global = -1;
+
+int SPY_EVENT_LINE = 0;
+
+Spy *
+spy_new(void)
+{
+   Spy *spy;
+
+   spy = calloc(1, sizeof(Spy));
+   DBG("spy[%p]", spy);
+   return spy;
+}
+
+void
+spy_free(Spy *spy)
+{
+   Eina_Inlist *l;
+   Spy_File *sf;
+   EINA_SAFETY_ON_NULL_RETURN(spy);
+
+   EINA_INLIST_FOREACH_SAFE(spy->files, l, sf)
+     {
+        free((char *)sf->name);
+        ecore_timer_del(sf->poll.timer);
+        eina_strbuf_free(sf->read.buf);
+     }
+   free(spy);
+}
+
+Spy_File *
+spy_file_new(Spy *spy, const char *file)
+{
+   Spy_File *sf;
+   struct stat st;
+
+   DBG("spy[%p] file[%s]", spy, file);
+
+   if (access(file, R_OK))
+     {
+        ERR("Failed to access %s : %s", file, strerror(errno));
+        return EINA_FALSE;
+     }
+
+   sf = calloc(1, sizeof(Spy_File));
+   if (!sf)
+     {
+        ERR("Failed to allocate Spy_File structure");
+        return EINA_FALSE;
+     }
+
+   sf->name = (const char *)strdup(file);
+   if (!sf->name)
+     {
+        ERR("Failed to dupe string \"%s\"", file);
+        goto free_sf;
+     }
+
+   if (stat(file, &st))
+     {
+        ERR("Failed to get size of %s : %s", file, strerror(errno));
+        goto free_name;
+     }
+
+   sf->read.buf = eina_strbuf_new();
+   if (!sf->read.buf)
+     {
+        ERR("Failed to create stringbuffer");
+        goto free_name;
+     }
+
+   sf->poll.size = st.st_size;
+   sf->poll.timer = ecore_timer_add(5.0, spy_file_poll, sf);
+
+   spy->files = eina_inlist_append(spy->files, EINA_INLIST_GET(sf));
+   DBG("spy_file[%p] size[%zd]", sf, st.st_size);
+   return sf;
+
+free_name:
+   free((char *)sf->name);
+free_sf:
+   free(sf);
+   return NULL;
+}
+
+
+int
+spy_init(void)
+{
+   if (++_spy_init_count != 1)
+     return _spy_init_count;
+
+   if (!eina_init())
+     {
+        fprintf(stderr, "Spy can not initialize Eina\n");
+        return --_spy_init_count;
+     }
+
+   _spy_log_dom_global = eina_log_domain_register("spy", EINA_COLOR_RED);
+   if (_spy_log_dom_global < 0)
+     {
+        EINA_LOG_ERR("Spy can not create a general log domain");
+        goto shutdown_eina;
+     }
+
+   if (!ecore_init())
+     {
+        ERR("Can not initialize Ecore");
+        goto unregister_log_domain;
+     }
+
+   if (!eio_init())
+     {
+        ERR("Can not initialize Eio");
+        goto shutdown_ecore;
+     }
+
+   SPY_EVENT_LINE = ecore_event_type_new();
+
+   return _spy_init_count;
+
+shutdown_ecore:
+   ecore_shutdown();
+unregister_log_domain:
+   eina_log_domain_unregister(_spy_log_dom_global);
+   _spy_log_dom_global = -1;
+shutdown_eina:
+   eina_shutdown();
+   return --_spy_init_count;
+}
+
+
+int
+spy_shutdown(void)
+{
+   if (_spy_init_count <= 0)
+     {
+        fprintf(stderr, "Spy init count not greater than 0 in shutdown.");
+        return 0;
+     }
+
+   if (--_spy_init_count != 0)
+     return _spy_init_count;
+
+   eio_shutdown();
+   ecore_shutdown();
+   eina_log_domain_unregister(_spy_log_dom_global);
+   _spy_log_dom_global = -1;
+   eina_shutdown();
+   return _spy_init_count;
+}
diff --git a/src/lib/spy/spy_private.h b/src/lib/spy/spy_private.h
new file mode 100644
index 0000000..287ea44
--- /dev/null
+++ b/src/lib/spy/spy_private.h
@@ -0,0 +1,44 @@
+#include <Spy.h>
+
+extern int _spy_log_dom_global;
+
+#define ERR(...) EINA_LOG_DOM_ERR(_spy_log_dom_global, __VA_ARGS__)
+#define DBG(...) EINA_LOG_DOM_DBG(_spy_log_dom_global, __VA_ARGS__)
+#define NFO(...) EINA_LOG_DOM_INFO(_spy_log_dom_global, __VA_ARGS__)
+#define WRN(...) EINA_LOG_DOM_WARN(_spy_log_dom_global, __VA_ARGS__)
+#define CRI(...) EINA_LOG_DOM_CRIT(_spy_log_dom_global, __VA_ARGS__)
+
+struct _Spy
+{
+   Eina_Inlist *files;
+};
+
+
+struct _Spy_File
+{
+   EINA_INLIST;
+   const char *name;
+   const void *data;
+
+   struct
+   {
+      Ecore_Timer *timer;
+      off_t size;
+   } poll;
+
+   struct
+   {
+      FILE *fd;
+      off_t offset,
+            length;
+      Eina_Strbuf *buf;
+   } read;
+};
+
+struct _Spy_Line
+{
+   Spy_File *sf;
+   const char *line;
+};
+
+Eina_Bool spy_file_poll(void *data);