X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Fhostlist%2Ftest_gnunet_daemon_hostlist_learning.c;h=43199bd91e571b002fd99653ca40949546d1175d;hb=956380b60d975e1a86784dae08555d6acdedb3b2;hp=fb9446bc4665a8b5cbd317f1dacbfeeb84f28729;hpb=a61f7e5a34d22fbaca6473e323a8f57500c8ca92;p=oweals%2Fgnunet.git diff --git a/src/hostlist/test_gnunet_daemon_hostlist_learning.c b/src/hostlist/test_gnunet_daemon_hostlist_learning.c index fb9446bc4..43199bd91 100644 --- a/src/hostlist/test_gnunet_daemon_hostlist_learning.c +++ b/src/hostlist/test_gnunet_daemon_hostlist_learning.c @@ -4,7 +4,7 @@ GNUnet 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, or (at your + by the Free Software Foundation; either version 3, or (at your option) any later version. GNUnet is distributed in the hope that it will be useful, but @@ -28,6 +28,7 @@ #include "gnunet_core_service.h" #include "gnunet_transport_service.h" #include "gnunet_resolver_service.h" +#include "gnunet_statistics_service.h" #define VERBOSE GNUNET_YES @@ -37,12 +38,19 @@ /** * How long until wait until testcases fails */ -#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 20) -#define CHECK_INTERVALL GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 2) +#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 180) +#define CHECK_INTERVALL GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1) static int timeout; +static int adv_sent; static int adv_arrived; +static int learned_hostlist_saved; +static int learned_hostlist_downloaded; + +static char * current_adv_uri; + +static const struct GNUNET_CONFIGURATION_Handle *cfg; static struct GNUNET_SCHEDULER_Handle *sched; static GNUNET_SCHEDULER_TaskIdentifier timeout_task; @@ -53,8 +61,8 @@ struct PeerContext struct GNUNET_CONFIGURATION_Handle *cfg; struct GNUNET_TRANSPORT_Handle *th; struct GNUNET_MessageHeader *hello; - struct GNUNET_ARM_Handle *arm; struct GNUNET_CORE_Handle *core; + struct GNUNET_STATISTICS_Handle *stats; #if START_ARM pid_t arm_pid; #endif @@ -64,9 +72,39 @@ static struct PeerContext adv_peer; static struct PeerContext learn_peer; -static void -clean_up (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) +static struct GNUNET_STATISTICS_GetHandle * download_stats; +static struct GNUNET_STATISTICS_GetHandle * urisrecv_stat; +static struct GNUNET_STATISTICS_GetHandle * advsent_stat; + +static void shutdown_testcase() { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Shutdown testcase....\n"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Stopping Timeout Task.\n"); + if (timeout_task != GNUNET_SCHEDULER_NO_TASK) + { + GNUNET_SCHEDULER_cancel (sched, timeout_task); + timeout_task = GNUNET_SCHEDULER_NO_TASK; + } + + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Stopping Statistics Task.\n"); +/* + if ((NULL != learn_peer.stats) && (NULL != download_stats)) + GNUNET_STATISTICS_get_cancel (download_stats); + if ((NULL != learn_peer.stats) && (NULL != urisrecv_stat)) + GNUNET_STATISTICS_get_cancel (urisrecv_stat); + if ((NULL != adv_peer.stats) && (NULL != advsent_stat)) + GNUNET_STATISTICS_get_cancel (advsent_stat); +*/ + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Stopping Statistics Check Task.\n"); + if ((check_task != GNUNET_SCHEDULER_NO_TASK) && (sched !=NULL)) + { + GNUNET_SCHEDULER_cancel (sched, check_task); + check_task = GNUNET_SCHEDULER_NO_TASK; + } + + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Freeing uri\n"); + if ( NULL != current_adv_uri ) GNUNET_free (current_adv_uri); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from Transport.\n"); if (adv_peer.th != NULL) { GNUNET_TRANSPORT_disconnect (adv_peer.th); @@ -77,6 +115,8 @@ clean_up (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) GNUNET_TRANSPORT_disconnect (learn_peer.th); learn_peer.th = NULL; } + + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from Core.\n"); if (adv_peer.core != NULL) { GNUNET_CORE_disconnect (adv_peer.core); @@ -87,25 +127,37 @@ clean_up (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) GNUNET_CORE_disconnect (learn_peer.core); learn_peer.core = NULL; } + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Asking ARM to stop core services\n"); + + +#if START_ARM + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Killing hostlist server ARM process.\n"); + if (0 != PLIBC_KILL (adv_peer.arm_pid, SIGTERM)) + GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill"); + if (GNUNET_OS_process_wait(adv_peer.arm_pid) != GNUNET_OK) + GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Hostlist server ARM process %u stopped\n", adv_peer.arm_pid); +#endif + + +#if START_ARM + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Killing hostlist client ARM process.\n"); + if (0 != PLIBC_KILL (learn_peer.arm_pid, SIGTERM)) + GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill"); + if (GNUNET_OS_process_wait(learn_peer.arm_pid) != GNUNET_OK) + GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Hostlist client ARM process %u stopped\n", learn_peer.arm_pid); +#endif + + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Shutting down scheduler\n"); GNUNET_SCHEDULER_shutdown (sched); -} + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Shutdown complete....\n"); -static void shutdown_testcase() -{ - if (timeout_task != GNUNET_SCHEDULER_NO_TASK) - { - GNUNET_SCHEDULER_cancel (sched, - timeout_task); - timeout_task = GNUNET_SCHEDULER_NO_TASK; - } - if (check_task != GNUNET_SCHEDULER_NO_TASK) - { - GNUNET_SCHEDULER_cancel (sched, - check_task); - check_task = GNUNET_SCHEDULER_NO_TASK; - } - GNUNET_SCHEDULER_add_now (sched, - &clean_up, NULL); } /** @@ -115,20 +167,111 @@ static void timeout_error (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { timeout_task = GNUNET_SCHEDULER_NO_TASK; + if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN)) + return; GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Timeout while executing testcase, test failed.\n"); timeout = GNUNET_YES; - clean_up (NULL, tc); + shutdown_testcase(); +} + +static int +process_downloads (void *cls, + const char *subsystem, + const char *name, + uint64_t value, + int is_persistent) +{ + download_stats = NULL; + if ( (value == 2) && (learned_hostlist_downloaded == GNUNET_NO) ) + { + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + _("Peer has successfully downloaded advertised URI \n")); + learned_hostlist_downloaded = GNUNET_YES; + shutdown_testcase(); + } + return GNUNET_OK; +} + +static int +process_uris_recv (void *cls, + const char *subsystem, + const char *name, + uint64_t value, + int is_persistent) +{ + urisrecv_stat = NULL; + if ( ((struct PeerContext *) cls == &learn_peer) && (value == 1) && (learned_hostlist_saved == GNUNET_NO)) + { + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + _("Peer has successfully saved advertised URI \n")); + learned_hostlist_saved = GNUNET_YES; + } + return GNUNET_OK; } +static int +process_adv_sent (void *cls, + const char *subsystem, + const char *name, + uint64_t value, + int is_persistent) +{ + advsent_stat = NULL; + if ( (value >= 1) && (adv_sent == GNUNET_NO)) + { + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + _("Server has successfully sent advertisement\n")); + adv_sent = GNUNET_YES; + } + return GNUNET_OK; +} + + /** * Check the server statistics regularly */ static void check_statistics (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Checking server stats...\n"); + char *stat; + + check_task = GNUNET_SCHEDULER_NO_TASK; + if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN)) + return; + + GNUNET_asprintf (&stat, + gettext_noop("# advertised URI `%s' downloaded"), + current_adv_uri); + if ( NULL != learn_peer.stats) + { + download_stats = GNUNET_STATISTICS_get (learn_peer.stats, + "hostlist", + stat, + GNUNET_TIME_UNIT_MINUTES, + NULL, + &process_downloads, + &learn_peer); + + urisrecv_stat = GNUNET_STATISTICS_get (learn_peer.stats, + "hostlist", + gettext_noop("# advertised hostlist URIs"), + GNUNET_TIME_UNIT_MINUTES, + NULL, + &process_uris_recv, + &learn_peer); + } + GNUNET_free (stat); + if ( NULL != adv_peer.stats) + { + advsent_stat = GNUNET_STATISTICS_get (adv_peer.stats, + "hostlist", + gettext_noop("# hostlist advertisements send"), + GNUNET_TIME_UNIT_MINUTES, + NULL, + &process_adv_sent, + NULL); + } check_task = GNUNET_SCHEDULER_add_delayed (sched, CHECK_INTERVALL, &check_statistics, @@ -145,11 +288,8 @@ static int ad_arrive_handler (void *cls, uint32_t distance) { char *hostname; - char *expected_uri = GNUNET_malloc (MAX_URL_LEN); - char *recv_uri; - + char *expected_uri; unsigned long long port; - size_t size; const struct GNUNET_MessageHeader * incoming; if (-1 == GNUNET_CONFIGURATION_get_value_number (adv_peer.cfg, @@ -157,41 +297,35 @@ static int ad_arrive_handler (void *cls, "HTTPPORT", &port)) { - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, - "Could not read advertising server's configuration\n" ); - return GNUNET_SYSERR; - } - hostname = GNUNET_RESOLVER_local_hostname_get (); - if (NULL != hostname) - { - size = strlen (hostname); - if (size + 15 > MAX_URL_LEN) - { - GNUNET_break (0); - } - else - { - GNUNET_asprintf (&expected_uri, - "http://%s:%u/", - hostname, - (unsigned int) port); - } + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Could not read advertising server's configuration\n" ); + return GNUNET_SYSERR; } + if ( GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string (adv_peer.cfg, + "HOSTLIST", + "EXTERNAL_DNS_NAME", + &hostname)) + hostname = GNUNET_RESOLVER_local_fqdn_get (); + + GNUNET_asprintf (&expected_uri, + "http://%s:%u/", + hostname != NULL ? hostname : "localhost", + (unsigned int) port); incoming = (const struct GNUNET_MessageHeader *) message; - recv_uri = (char*) &incoming[1]; - if ( 0 == strcmp( expected_uri, recv_uri ) ) - { - GNUNET_log (GNUNET_ERROR_TYPE_INFO, - "Recieved hostlist advertisement with URI `%s'as expected\n", recv_uri); - adv_arrived = GNUNET_YES; - } + current_adv_uri = strdup ((char*) &incoming[1]); + if ( 0 == strcmp( expected_uri, current_adv_uri ) ) + { + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + "Recieved hostlist advertisement with URI `%s' as expected\n", current_adv_uri); + adv_arrived = GNUNET_YES; + adv_sent = GNUNET_YES; + } else GNUNET_log (GNUNET_ERROR_TYPE_ERROR, - "Expected URI `%s' and recieved URI `%s' differ\n", expected_uri, recv_uri); - GNUNET_free ( expected_uri ); - GNUNET_free ( hostname ); - shutdown_testcase(); + "Expected URI `%s' and recieved URI `%s' differ\n", expected_uri, current_adv_uri); + GNUNET_free (expected_uri); + GNUNET_free_non_null (hostname); return GNUNET_OK; } @@ -228,27 +362,29 @@ setup_learn_peer (struct PeerContext *p, const char *cfgname) result = remove (filename); if (result == 0) GNUNET_log (GNUNET_ERROR_TYPE_INFO, - _("Hostlist hostlist file `%s' was removed\n"),filename); + _("Hostlist file `%s' was removed\n"),filename); } } - GNUNET_free ( filename ); - GNUNET_ARM_start_services (p->cfg, sched, "core", NULL); + if ( NULL != filename) GNUNET_free ( filename ); p->core = GNUNET_CORE_connect (sched, p->cfg, - GNUNET_TIME_UNIT_FOREVER_REL, - NULL, - NULL, - NULL, NULL, - NULL, GNUNET_NO, - NULL, GNUNET_NO, - learn_handlers ); + GNUNET_TIME_UNIT_FOREVER_REL, + NULL, + NULL, + NULL, NULL, NULL, + NULL, GNUNET_NO, + NULL, GNUNET_NO, + learn_handlers ); GNUNET_assert ( NULL != p->core ); + p->stats = GNUNET_STATISTICS_create (sched, "hostlist", p->cfg); + GNUNET_assert ( NULL != p->stats ); } static void setup_adv_peer (struct PeerContext *p, const char *cfgname) { + p->cfg = GNUNET_CONFIGURATION_create (); #if START_ARM p->arm_pid = GNUNET_OS_start_process (NULL, NULL, "gnunet-service-arm", @@ -259,103 +395,46 @@ setup_adv_peer (struct PeerContext *p, const char *cfgname) "-c", cfgname, NULL); #endif GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname)); - GNUNET_ARM_start_services (p->cfg, sched, "core", NULL); -} - - - -static void -waitpid_task (void *cls, - const struct GNUNET_SCHEDULER_TaskContext *tc) -{ - struct PeerContext *p = cls; - -#if START_ARM - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Killing ARM process.\n"); - if (0 != PLIBC_KILL (p->arm_pid, SIGTERM)) - GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill"); - if (GNUNET_OS_process_wait(p->arm_pid) != GNUNET_OK) - GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid"); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "ARM process %u stopped\n", p->arm_pid); -#endif - GNUNET_CONFIGURATION_destroy (p->cfg); -} - - -static void -stop_cb (void *cls, - int success) -{ - struct PeerContext *p = cls; - - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - success - ? "ARM stopped core service\n" - : "ARM failed to stop core service\n"); - GNUNET_ARM_disconnect (p->arm); - p->arm = NULL; - /* make sure this runs after all other tasks are done */ - GNUNET_SCHEDULER_add_delayed (sched, - GNUNET_TIME_UNIT_SECONDS, - &waitpid_task, p); -} - - -static void -stop_arm (struct PeerContext *p) -{ - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Asking ARM to stop core service\n"); - p->arm = GNUNET_ARM_connect (p->cfg, sched, NULL); - GNUNET_ARM_stop_service (p->arm, "core", GNUNET_TIME_UNIT_SECONDS, - &stop_cb, p); -} - + p->stats = GNUNET_STATISTICS_create (sched, "hostlist", p->cfg); + GNUNET_assert ( NULL != p->stats ); -/** - * Try again to connect to transport service. - */ -static void -shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) -{ - stop_arm (&adv_peer); - stop_arm (&learn_peer); } - static void run (void *cls, struct GNUNET_SCHEDULER_Handle *s, char *const *args, const char *cfgfile, - const struct GNUNET_CONFIGURATION_Handle *cfg) + const struct GNUNET_CONFIGURATION_Handle *c) { timeout = GNUNET_NO; - adv_arrived = GNUNET_NO; + adv_sent =GNUNET_NO; + + adv_arrived = 0; + learned_hostlist_saved = GNUNET_NO; + learned_hostlist_downloaded = GNUNET_NO; + + cfg = c; sched = s; + + setup_adv_peer (&adv_peer, "test_learning_adv_peer.conf"); + setup_learn_peer (&learn_peer, "test_learning_learn_peer.conf"); timeout_task = GNUNET_SCHEDULER_add_delayed (sched, TIMEOUT, &timeout_error, NULL); + check_task = GNUNET_SCHEDULER_add_delayed (sched, CHECK_INTERVALL, &check_statistics, NULL); - GNUNET_SCHEDULER_add_delayed (sched, - GNUNET_TIME_UNIT_FOREVER_REL, - &shutdown_task, - NULL); - setup_adv_peer (&adv_peer, "test_learning_adv_peer.conf"); - setup_learn_peer (&learn_peer, "test_learning_learn_peer.conf"); } - static int check () { - char *const argv[] = { "test-gnunet-daemon-hostlist", + unsigned int failed; + char *const argv[] = { "test-gnunet-daemon-hostlist-learning", "-c", "learning_data.conf", #if VERBOSE "-L", "DEBUG", @@ -367,10 +446,45 @@ check () }; GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1, - argv, "test-gnunet-daemon-hostlist", + argv, "test-gnunet-daemon-hostlist-learning", "nohelp", options, &run, NULL); - if ( (timeout == GNUNET_YES) || (adv_arrived == GNUNET_NO)) + failed = GNUNET_NO; + + if (learned_hostlist_downloaded == GNUNET_YES) + return GNUNET_NO; + + if (timeout == GNUNET_YES) + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Testcase could not set up two communicating peers, timeout\n"); + failed = GNUNET_YES; + } + if (adv_arrived != GNUNET_YES) + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Learning peer did not receive advertisement from server\n"); + failed = GNUNET_YES; + } + if ( learned_hostlist_saved == GNUNET_NO ) + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Peer1: Advertised hostlist was not saved in datastore\n"); + failed = GNUNET_YES; + } + if (learned_hostlist_downloaded == GNUNET_NO) + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Peer1: Advertised hostlist could not be downloaded from server\n"); + failed = GNUNET_YES; + } + if (adv_sent == GNUNET_NO) + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Advertised was not sent from server to client\n"); + failed = GNUNET_YES; + } + if ( GNUNET_YES == failed ) return GNUNET_YES; else return GNUNET_NO; @@ -394,6 +508,12 @@ main (int argc, char *argv[]) ret = check (); GNUNET_DISK_directory_remove ("/tmp/test-gnunetd-hostlist-peer-1"); GNUNET_DISK_directory_remove ("/tmp/test-gnunetd-hostlist-peer-2"); + if ( GNUNET_YES == GNUNET_DISK_file_test ("hostlists_learn_peer.file") ) + { + if ( remove ("hostlists_learn_peer.file") == 0) + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + _("Hostlist file hostlists_learn_peer.file was removed\n")); + } return ret; }