NNTPGrab

/* 

    Copyright (C) 2005-2010  Erik van Pienbroek

    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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

*/

#include 

#include 

#include "nntpgrab_plugin.h"

#include "nntpgrab_utils.h"

#include "config.h"

typedef struct _counter_server_data {

    NGConfigServer server_info;

    guint64 num_bytes_downloaded;

    guint64 num_parts_succeeded;

    guint64 num_parts_failed;

} CounterServerData;

typedef struct _counter_data {

    time_t stamp_started;

    gboolean data_changed_since_last_announce;

    GList *collected_data;     /* List contains CounterServerData elements */

} CounterData;

static void plugin_counter_free_cached_data(NGPlugin *plugin_data);

static gboolean plugin_counter_load_cached_data(NGPlugin *plugin_data, char **errmsg);

static gboolean plugin_counter_save_cached_data(NGPlugin *plugin_data, char **errmsg);

static gboolean plugin_counter_send_update_announcement(gpointer data);

static CounterServerData *plugin_counter_lookup_server(NGPlugin *plugin_data, const char *servername);

static void plugin_counter_part_done_cb(NGPlugin *plugin_data, const char *servername, int conn_id, const char *collection_name, const char *subject, int part_num, int size, gpointer data);

static void plugin_counter_part_failed_cb(NGPlugin *plugin_data, const char *servername, int conn_id, const char *collection_name, const char *subject, int part_num,int size, gboolean all_servers_tried);

void

nntpgrab_plugin_initialize(NGPlugin *plugin_data)

{

    ng_plugin_set_name(plugin_data, "Download counter");

    ng_plugin_set_version(plugin_data, PACKAGE_VERSION);

    ng_plugin_set_author(plugin_data, "Erik van Pienbroek");

    ng_plugin_set_url(plugin_data, "https://www.nntpgrab.nl");

    ng_plugin_set_description(plugin_data, "Count the amount of download traffic for each configured usenet server ");

    ng_plugin_create_event(plugin_data, "counter_data_changed", 0);

    ng_plugin_set_required_event(plugin_data, "part_done");

    ng_plugin_set_required_event(plugin_data, "part_failed");

}

ngboolean

nntpgrab_plugin_load(NGPlugin *plugin_data, char **errmsg)

{

    ng_plugin_connect_event(plugin_data, "part_done", NG_PLUGIN_FUNCTION(plugin_counter_part_done_cb), NULL);

    ng_plugin_connect_event(plugin_data, "part_failed", NG_PLUGIN_FUNCTION(plugin_counter_part_failed_cb), NULL);

    plugin_data->priv = g_slice_new0(CounterData);

    if (!plugin_counter_load_cached_data(plugin_data, errmsg)) {

        return FALSE;

    }

    /* Make sure the plugin sends update announcements every 10 seconds */

    g_timeout_add_seconds(10, plugin_counter_send_update_announcement, plugin_data);

    plugin_counter_send_update_announcement(plugin_data);

    return TRUE;

}

ngboolean

nntpgrab_plugin_can_unload(NGPlugin *plugin_data, char **reason)

{

    return TRUE;

}

void

nntpgrab_plugin_unload(NGPlugin *plugin_data)

{

    char *errmsg = NULL;

    if (!plugin_counter_save_cached_data(plugin_data, &errmsg)) {

        ng_plugin_emit_log_msg(plugin_data, NG_LOG_LEVEL_WARNING, errmsg);

        g_free(errmsg);

    }

    plugin_counter_free_cached_data(plugin_data);

    g_slice_free(CounterData, plugin_data->priv);

    plugin_data->priv = NULL;

}

void

nntpgrab_plugin_destroy(NGPlugin *plugin_data)

{

}

int

nntpgrab_plugin_get_version(void)

{

    return NNTPGRAB_PLUGIN_API_VERSION;

}

static NGVariant *

get_collected_data(NGPlugin *plugin_data, NGVariant *parameters, char **errmsg)

{

    GVariant *variant_counter;

    GVariant *variant_servers;

    GVariantBuilder *builder_counter;

    GVariantBuilder *builder_servers;

    CounterData *counter_data;

    NGList *servers;

    NGList *list;

    g_return_val_if_fail(plugin_data != NULL, NULL);

    counter_data = (CounterData*) plugin_data->priv;

    g_return_val_if_fail(counter_data != NULL, NULL);

    builder_counter = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));

    g_variant_builder_add(builder_counter, "{sv}", "stamp_started", g_variant_new_uint64((guint64) counter_data->stamp_started));

    builder_servers = g_variant_builder_new(G_VARIANT_TYPE("av"));

    servers = plugin_data->core_funcs.config_get_avail_servers();

    list = servers;

    while (list) {

        const char *servername = (const char*) list->data;

        GVariant *variant_server;

        GVariantBuilder *builder_server;

        CounterServerData *server_data;

        server_data = plugin_counter_lookup_server(plugin_data, servername);

        g_return_val_if_fail(server_data != NULL, NULL);

        builder_server = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));

        g_variant_builder_add(builder_server, "{sv}", "servername", g_variant_new_string(server_data->server_info.servername));

        g_variant_builder_add(builder_server, "{sv}", "num_bytes_downloaded", g_variant_new_uint64(server_data->num_bytes_downloaded));

        g_variant_builder_add(builder_server, "{sv}", "num_parts_succeeded", g_variant_new_uint64(server_data->num_parts_succeeded));

        g_variant_builder_add(builder_server, "{sv}", "num_parts_failed", g_variant_new_uint64(server_data->num_parts_failed));

        variant_server = g_variant_builder_end(builder_server);

        g_variant_builder_add(builder_servers, "v", variant_server);

        list = ng_list_next(list);

    }

    variant_servers = g_variant_builder_end(builder_servers);

    g_variant_builder_add(builder_counter, "{sv}", "collected_data", variant_servers);

    plugin_data->core_funcs.config_free_avail_servers(servers);

    variant_counter = g_variant_builder_end(builder_counter);

    return (NGVariant*) variant_counter;

}

static NGVariant *

reset_collected_data(NGPlugin *plugin_data, NGVariant *parameters, char **errmsg)

{

    plugin_counter_free_cached_data(plugin_data);

    /* Manually emit an update announcement so that all frontends 

     * will know that the collected data was reset */

    plugin_counter_send_update_announcement(plugin_data);

    return (NGVariant*) g_variant_new_boolean(TRUE);

}

NGVariant *

nntpgrab_plugin_call_plugin_method(NGPlugin *plugin_data, const char *method, NGVariant *parameters, char **errmsg)

{

    if (!g_strcmp0(method, "get_collected_data")) {

        return get_collected_data(plugin_data, parameters, errmsg);

    } else if (!g_strcmp0(method, "reset")) {

        return reset_collected_data(plugin_data, parameters, errmsg);

    } else {

        return NULL;

    }

}

static void

plugin_counter_free_cached_data(NGPlugin *plugin_data)

{

    CounterData *counter_data;

    GList *list;

    g_return_if_fail(plugin_data != NULL);

    counter_data = (CounterData*) plugin_data->priv;

    g_return_if_fail(counter_data != NULL);

    list = counter_data->collected_data;

    while (list) {

        CounterServerData *server_data = (CounterServerData*) list->data;

        g_slice_free(CounterServerData, server_data);

        list = g_list_next(list);

    }

    g_list_free(counter_data->collected_data);

    counter_data->collected_data = NULL;

    counter_data->stamp_started = time(NULL);

    counter_data->data_changed_since_last_announce = TRUE;

}

static gboolean

plugin_counter_load_cached_data(NGPlugin *plugin_data, char **errmsg)

{

    CounterData *counter_data;

    GKeyFile *keyfile;

    char *config_dir;

    char *filename;

    GError *err = NULL;

    char **groups;

    int i;

    g_return_val_if_fail(plugin_data != NULL, FALSE);

    g_return_val_if_fail(errmsg != NULL, FALSE);

    counter_data = (CounterData*) plugin_data->priv;

    g_return_val_if_fail(counter_data != NULL, FALSE);

    counter_data->stamp_started = time(NULL);

    config_dir = plugin_data->core_funcs.config_get_config_folder();

    g_return_val_if_fail(config_dir != NULL, FALSE);

    filename = g_build_filename(config_dir, "plugin_counter.conf", NULL);

    ng_free(config_dir);

    if (!g_file_test(filename, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_REGULAR)) {

        /* No cached configuration file exists yet */

        return TRUE;

    }

    /* Clean up old entries */

    plugin_counter_free_cached_data(plugin_data);

    /* Load the contents of the configuration file from disk */

    keyfile = g_key_file_new();

    if (!g_key_file_load_from_file(keyfile, filename, G_KEY_FILE_NONE, &err)) {

        *errmsg = g_strdup_printf("Unable to load file '%s': %s", filename, err->message);

        g_error_free(err);

        g_free(filename);

        return FALSE;

    }

    g_free(filename);

    groups = g_key_file_get_groups(keyfile, NULL);

    i = 0;

    while (groups && groups[i] != NULL) {

        CounterServerData *server_data;

        NGConfigServer server_info;

        /* Only read the stamp_started key from the generic group */

        if (!g_strcmp0(groups[i], "generic")) {

            if (!g_key_file_has_key(keyfile, groups[i], "stamp_started", NULL)) {

                counter_data->stamp_started = time(NULL);

            } else {

                counter_data->stamp_started = (time_t) g_key_file_get_uint64(keyfile, groups[i], "stamp_started", NULL);

            }

            i++;

            continue;

        }

        if (!g_key_file_has_key(keyfile, groups[i], "num_bytes_downloaded", NULL) ||

            !g_key_file_has_key(keyfile, groups[i], "num_parts_succeeded", NULL) ||

            !g_key_file_has_key(keyfile, groups[i], "num_parts_failed", NULL)) {

            /* One or more keys weren't found */

            ng_plugin_emit_log_msg(plugin_data, NG_LOG_LEVEL_INFO, "Server named '%s' was found in counter plugin configuration file, but is missing some keys", groups[i]);

            i++;

            continue;

        }

        /* All required keys are found */

        if (!plugin_data->core_funcs.config_get_server_info(groups[i], &server_info)) {

            /* Server doesn't exist in current NNTPGrab configuration */

            ng_plugin_emit_log_msg(plugin_data, NG_LOG_LEVEL_INFO, "Server named '%s' was found in counter plugin configuration file, but isn't known in the NNTPGrab configuration", groups[i]);

            i++;

            continue;

        }

        server_data = g_slice_new0(CounterServerData);

        server_data->server_info = server_info;

        server_data->num_bytes_downloaded = g_key_file_get_uint64(keyfile, groups[i], "num_bytes_downloaded", NULL);

        server_data->num_parts_succeeded = g_key_file_get_uint64(keyfile, groups[i], "num_parts_succeeded", NULL);

        server_data->num_parts_failed = g_key_file_get_uint64(keyfile, groups[i], "num_parts_failed", NULL);

        counter_data->collected_data = g_list_append(counter_data->collected_data, server_data);

        i++;

    }

    g_key_file_free(keyfile);

    return TRUE;

}

static gboolean

plugin_counter_save_cached_data(NGPlugin *plugin_data, char **errmsg)

{

    GKeyFile *keyfile;

    char *config_dir;

    char *filename;

    GError *err = NULL;

    CounterData *counter_data = (CounterData*) plugin_data->priv;

    GList *list;

    char *contents;

    g_return_val_if_fail(plugin_data != NULL, FALSE);

    g_return_val_if_fail(errmsg != NULL, FALSE);

    g_return_val_if_fail(counter_data != NULL, FALSE);

    keyfile = g_key_file_new();

    g_key_file_set_uint64(keyfile, "generic", "stamp_started", (guint64) counter_data->stamp_started);

    list = counter_data->collected_data;

    while (list) {

        CounterServerData *server_data = (CounterServerData*) list->data;

        g_key_file_set_uint64(keyfile, server_data->server_info.servername, "num_bytes_downloaded", server_data->num_bytes_downloaded);

        g_key_file_set_uint64(keyfile, server_data->server_info.servername, "num_parts_succeeded", server_data->num_parts_succeeded);

        g_key_file_set_uint64(keyfile, server_data->server_info.servername, "num_parts_failed", server_data->num_parts_failed);

        list = g_list_next(list);

    }

    contents = g_key_file_to_data(keyfile, NULL, &err);

    if (!contents) {

        *errmsg = g_strdup(err->message);

        g_error_free(err);

        g_free(contents);

        g_key_file_free(keyfile);

        return FALSE;

    }

    /* Write the configuration to disk */

    config_dir = plugin_data->core_funcs.config_get_config_folder();

    g_return_val_if_fail(config_dir != NULL, FALSE);

    filename = g_build_filename(config_dir, "plugin_counter.conf", NULL);

    g_free(config_dir);

    if (!g_file_set_contents(filename, contents, -1, &err)) {

        *errmsg = g_strdup_printf("Error while saving download counter configuration to file '%s'\n%s", filename, err->message);

        g_error_free(err);

        g_free(contents);

        g_free(filename);

        g_key_file_free(keyfile);

        return FALSE;

    }

    g_free(contents);

    g_free(filename);

    g_key_file_free(keyfile);

    return TRUE;

}

static gboolean

plugin_counter_send_update_announcement(gpointer data)

{

    static int times_been_here = 0;

    CounterData *counter_data;

    NGPlugin *plugin_data = (NGPlugin*) data;

    g_return_val_if_fail(plugin_data != NULL, FALSE);

    g_return_val_if_fail(plugin_data->priv != NULL, FALSE);

    counter_data = (CounterData*) plugin_data->priv;

    /* Only send a new announcement when something got changed */

    if (!counter_data->data_changed_since_last_announce) {

        return TRUE;

    }

    ng_plugin_emit_event(plugin_data, "counter_data_changed", NULL);

    counter_data->data_changed_since_last_announce = FALSE;

    /* Periodically (every 60 seconds) save the cached data back to disk */

    if (times_been_here % 6 == 0) {

        char *errmsg = NULL;

        if (!plugin_counter_save_cached_data(plugin_data, &errmsg)) {

            ng_plugin_emit_log_msg(plugin_data, NG_LOG_LEVEL_WARNING, errmsg);

            g_free(errmsg);

        }

    }

    times_been_here++;

    return TRUE;

}

static CounterServerData*

plugin_counter_lookup_server(NGPlugin *plugin_data, const char *servername)

{

    CounterData *counter_data;

    CounterServerData *server_data;

    GList *list;

    g_return_val_if_fail(plugin_data != NULL, NULL);

    g_return_val_if_fail(servername != NULL, NULL);

    g_return_val_if_fail(plugin_data->priv != NULL, NULL);

    counter_data = (CounterData*) plugin_data->priv;

    list = counter_data->collected_data;

    while (list) {

        server_data = list->data;

        g_return_val_if_fail(server_data != NULL, NULL);

        if (!g_strcmp0(server_data->server_info.servername, servername)) {

            return server_data;

        }

        list = g_list_next(list);

    }

    /* If we got here then there's no entry available for this server. Add it now */

    server_data = g_slice_new0(CounterServerData);

    g_return_val_if_fail(plugin_data->core_funcs.config_get_server_info(servername, &server_data->server_info), NULL);

    server_data->num_bytes_downloaded = 0;

    server_data->num_parts_succeeded = 0;

    server_data->num_parts_failed = 0;

    counter_data->collected_data = g_list_append(counter_data->collected_data, server_data);

    return server_data;

}

static void

plugin_counter_part_done_cb(NGPlugin *plugin_data, const char *servername, int conn_id, const char *collection_name, const char *subject, int part_num, int size, gpointer data)

{

    CounterData *counter_data;

    CounterServerData *server_data;

    /* We only process the part_done event as this is the only event which contains both 

     * the servername and the size of the part. The event traffic_monitor_update contains

     * a more reliable amount of traffic transferred, but doesn't show the per-server

     * traffic which makes it unsuitable for our goal.

     *

     * When only processing this event we will lose some traffic data (for missing parts

     * for example) but that amount of traffic should be low so it should be okay to

     * ignore that type of traffic */

    g_return_if_fail(plugin_data != NULL);

    g_return_if_fail(servername != NULL);

    g_return_if_fail(size >= 0);

    g_return_if_fail(plugin_data->priv != NULL);

    counter_data = (CounterData*) plugin_data->priv;

    server_data = plugin_counter_lookup_server(plugin_data, servername);

    g_return_if_fail(server_data != NULL);

    counter_data->data_changed_since_last_announce = TRUE;

    server_data->num_bytes_downloaded += size;

    server_data->num_parts_succeeded++;

}

static void

plugin_counter_part_failed_cb(NGPlugin *plugin_data, const char *servername, int conn_id, const char *collection_name, const char *subject, int part_num,int size, gboolean all_servers_tried)

{

    CounterData *counter_data;

    CounterServerData *server_data;

    g_return_if_fail(plugin_data != NULL);

    g_return_if_fail(servername != NULL);

    g_return_if_fail(plugin_data->priv != NULL);

    counter_data = (CounterData*) plugin_data->priv;

    server_data = plugin_counter_lookup_server(plugin_data, servername);

    g_return_if_fail(server_data != NULL);

    counter_data->data_changed_since_last_announce = TRUE;

    server_data->num_parts_failed++;

}