path: root/e-util/e-logger.c

/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
 *
 *  Authors: Srinivasa Ragavan <sragavan@gnome.org>
 *
 *
 *  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.
 *
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#include <glib.h>
#include <glib/gi18n.h>
#include <glib/gstdio.h>
#include "e-logger.h"
#include "e-mktemp.h"

/* 5 Minutes */
#define TIMEOUT_INTERVAL    300000 

#define E_LOGGER_GET_PRIVATE(obj) \
    (G_TYPE_INSTANCE_GET_PRIVATE \
    ((obj), E_TYPE_LOGGER, ELoggerPrivate))

struct _ELoggerPrivate {
    gchar *component;
    gchar *logfile;
    FILE *fp;

    guint timer;
};

enum {
    PROP_0,
    PROP_COMPONENT
};

static gpointer parent_class;

static gboolean
flush_logfile (ELogger *logger)
{
    fflush (logger->priv->fp);
    logger->priv->timer = 0;

    return FALSE;
}

static void
logger_set_component (ELogger *logger,
                      const gchar *component)
{
    gchar *temp;

    g_return_if_fail (logger->priv->component == NULL);

    temp = g_strdup_printf ("%s.log.XXXXXX", component);

    logger->priv->component = g_strdup (component);
    logger->priv->logfile = e_mktemp (temp);
    logger->priv->fp = g_fopen (logger->priv->logfile, "w");
    logger->priv->timer = 0;

    g_free (temp);
}

static void
logger_set_property (GObject *object,
                     guint property_id,
                     const GValue *value,
                     GParamSpec *pspec)
{
    switch (property_id) {
        case PROP_COMPONENT:
            logger_set_component (
                E_LOGGER (object),
                g_value_get_string (value));
            return;
    }

    G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}

static void
logger_get_property (GObject *object,
                     guint property_id,
                     GValue *value,
                     GParamSpec *pspec)
{
    switch (property_id) {
        case PROP_COMPONENT:
            g_value_set_string (
                value, e_logger_get_component (
                E_LOGGER (object)));
            return;
    }

    G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}

static void
logger_finalize (GObject *object)
{
    ELogger *logger = E_LOGGER (object);

    if (logger->priv->timer)
        g_source_remove (logger->priv->timer);
    flush_logfile (logger);
    fclose (logger->priv->fp);

    g_free (logger->priv->component);
    g_free (logger->priv->logfile);

    /* Chain up to parent's finalize() method. */
    G_OBJECT_CLASS (parent_class)->finalize (object);
}

static void
logger_class_init (ELoggerClass *class)
{
    GObjectClass *object_class;

    parent_class = g_type_class_peek_parent (class);
    g_type_class_add_private (class, sizeof (ELoggerPrivate));

    object_class = G_OBJECT_CLASS (class);
    object_class->set_property = logger_set_property;
    object_class->get_property = logger_get_property;
    object_class->finalize = logger_finalize;

    g_object_class_install_property (
        object_class,
        PROP_COMPONENT,
        g_param_spec_string (
            "component",
            _("Component"),
            _("Name of the component being logged"),
            "anonymous",
            G_PARAM_READWRITE |
            G_PARAM_CONSTRUCT_ONLY));
}

static void
logger_init (ELogger *logger)
{
    logger->priv = E_LOGGER_GET_PRIVATE (logger);
}

GType
e_logger_get_type (void)
{
    static GType type = 0;

    if (G_UNLIKELY (type == 0)) {
        static const GTypeInfo type_info = {
            sizeof (ELoggerClass),
            (GBaseInitFunc) NULL,
            (GBaseFinalizeFunc) NULL,
            (GClassInitFunc) logger_class_init,
            (GClassFinalizeFunc) NULL,
            NULL,  /* class_data */
            sizeof (ELogger),
            0,     /* n_preallocs */
            (GInstanceInitFunc) logger_init,
            NULL   /* value_table */
        };

        type = g_type_register_static (
            G_TYPE_OBJECT, "ELogger", &type_info, 0);
    }

    return type;
}

ELogger *
e_logger_create (gchar *component)
{
    g_return_val_if_fail (component != NULL, NULL);

    return g_object_new (E_TYPE_LOGGER, "component", component, NULL);
}

const gchar *
e_logger_get_component (ELogger *logger)
{
    g_return_val_if_fail (E_IS_LOGGER (logger), NULL);

    return logger->priv->component;
}

static void
set_dirty (ELogger *logger)
{
    if (logger->priv->timer)
        return;

    logger->priv->timer = g_timeout_add (
        TIMEOUT_INTERVAL, (GSourceFunc) flush_logfile, logger);
}

void
e_logger_log (ELogger *logger,
              gint level,
              gchar *primary,
              gchar *secondary)
{
    time_t t = time (NULL);

    g_return_if_fail (E_LOGGER (logger));
    g_return_if_fail (primary != NULL);
    g_return_if_fail (secondary != NULL);

    fprintf (logger->priv->fp, "%d:%ld:%s\n", level, t, primary);
    fprintf (logger->priv->fp, "%d:%ld:%s\n", level, t, secondary);
    set_dirty (logger);
}

void 
e_logger_get_logs (ELogger *logger,
                   ELogFunction func,
                   gpointer data)
{
    FILE *fp;
    gchar buf[250];

    g_return_if_fail (E_LOGGER (logger));
    g_return_if_fail (func != NULL);

    /* Flush everything before we get the logs */
    fflush (logger->priv->fp);  
    fp = g_fopen (logger->priv->logfile, "r");

    if (!fp) {
        fprintf (stderr, "Cannot open log file '%s' for reading! No flush yet?\n", logger->priv->logfile ? logger->priv->logfile : "[null]");
        return;
    }

    while (!feof (fp)) {
        gchar *tmp;
        size_t len;

        tmp = fgets (buf, sizeof (buf), fp);
        if (!tmp)
            break;

        len = strlen (tmp);
        if (len > 0 && tmp [len - 1] != '\n' && !feof (fp)) {
            /* there are more characters on a row than 249, so read them all */
            GString *str = g_string_sized_new (1024);

            g_string_append (str, tmp);

            while (!feof (fp) && len > 0 && tmp [len - 1] != '\n') {
                tmp = fgets (buf, sizeof (buf), fp);
                if (!tmp)
                    break;

                len = strlen (tmp);
                g_string_append (str, tmp);
            }

            func (str->str, data);

            g_string_free (str, TRUE);
        } else
            func (tmp, data);
    }

    fclose (fp);
}