NNTPGrab

#include 

#include "nntpgrab_utils.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);

    ng_plugin_create_event(plugin_data, "counter_data_changed", 0);

    ng_plugin_set_required_event(plugin_data, "part_failed");

    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);

    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;

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_if_fail(plugin_data != NULL);

    counter_data = (CounterData*) plugin_data->priv;

    g_return_if_fail(counter_data != 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);

}

    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;

    }

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_if_fail(counter_data != NULL);

    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;

}

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;

    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++;

}