X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Ffs%2Ftest_fs_namespace.c;h=b8325d8d86cc6cf4258899950bf02db1571b056d;hb=0d8487a744066dce7d097fb91ae0f965033c79ea;hp=d0db8dfcf43484cba3960948bce37c6d1f5be196;hpb=8a25345d472b2ef4c94567b77dbaea777789e399;p=oweals%2Fgnunet.git diff --git a/src/fs/test_fs_namespace.c b/src/fs/test_fs_namespace.c index d0db8dfcf..b8325d8d8 100644 --- a/src/fs/test_fs_namespace.c +++ b/src/fs/test_fs_namespace.c @@ -1,10 +1,10 @@ /* This file is part of GNUnet. - (C) 2005, 2006, 2008, 2009 Christian Grothoff (and other contributing authors) + Copyright (C) 2005-2013 GNUnet e.V. 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 @@ -14,8 +14,8 @@ You should have received a copy of the GNU General Public License along with GNUnet; see the file COPYING. If not, write to the - Free Software Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. */ /** @@ -23,157 +23,282 @@ * @brief Test for fs_namespace.c * @author Christian Grothoff */ - #include "platform.h" #include "gnunet_util_lib.h" -#include "gnunet_arm_service.h" +#include "gnunet_testing_lib.h" #include "gnunet_fs_service.h" -#define START_ARM GNUNET_YES -static struct GNUNET_SCHEDULER_Handle *sched; +static struct GNUNET_CRYPTO_EcdsaPublicKey nsid; + +static struct GNUNET_FS_Uri *sks_expect_uri; -static struct PeerContext p1; +static struct GNUNET_FS_Uri *ksk_expect_uri; static struct GNUNET_FS_Handle *fs; +static struct GNUNET_FS_SearchContext *sks_search; -struct PeerContext -{ - struct GNUNET_CONFIGURATION_Handle *cfg; -#if START_ARM - pid_t arm_pid; -#endif -}; +static struct GNUNET_FS_SearchContext *ksk_search; +static struct GNUNET_SCHEDULER_Task * kill_task; -static void * -progress_cb (void *cls, - const struct GNUNET_FS_ProgressInfo *event) +static int update_started; + +static int err; + + +static void +abort_ksk_search_task (void *cls) { - return NULL; + if (ksk_search != NULL) + { + GNUNET_FS_search_stop (ksk_search); + ksk_search = NULL; + if (sks_search == NULL) + { + GNUNET_FS_stop (fs); + if (NULL != kill_task) + GNUNET_SCHEDULER_cancel (kill_task); + } + } } static void -setup_peer (struct PeerContext *p, const char *cfgname) +abort_sks_search_task (void *cls) { - p->cfg = GNUNET_CONFIGURATION_create (); -#if START_ARM - p->arm_pid = GNUNET_OS_start_process ("gnunet-service-arm", - "gnunet-service-arm", -#if VERBOSE - "-L", "DEBUG", -#endif - "-c", cfgname, NULL); -#endif - GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname)); - GNUNET_ARM_start_services (p->cfg, sched, "core", NULL); + if (sks_search == NULL) + return; + GNUNET_FS_search_stop (sks_search); + sks_search = NULL; + if (ksk_search == NULL) + { + GNUNET_FS_stop (fs); + if (NULL != kill_task) + GNUNET_SCHEDULER_cancel (kill_task); + } } static void -stop_arm (struct PeerContext *p) +do_timeout (void *cls) +{ + err = 1; + FPRINTF (stderr, "%s", "Operation timed out\n"); + kill_task = NULL; + abort_sks_search_task (NULL); + abort_ksk_search_task (NULL); +} + + +static void * +progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event) { -#if START_ARM - 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); + switch (event->status) + { + case GNUNET_FS_STATUS_SEARCH_RESULT: + if (sks_search == event->value.search.sc) + { + if (!GNUNET_FS_uri_test_equal + (sks_expect_uri, event->value.search.specifics.result.uri)) + { + FPRINTF (stderr, "%s", "Wrong result for sks search!\n"); + err = 1; + } + /* give system 1ms to initiate update search! */ + GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MILLISECONDS, + &abort_sks_search_task, NULL); + } + else if (ksk_search == event->value.search.sc) + { + if (!GNUNET_FS_uri_test_equal + (ksk_expect_uri, event->value.search.specifics.result.uri)) + { + FPRINTF (stderr, "%s", "Wrong result for ksk search!\n"); + err = 1; + } + GNUNET_SCHEDULER_add_now (&abort_ksk_search_task, NULL); + } + else + { + FPRINTF (stderr, "%s", "Unexpected search result received!\n"); + GNUNET_break (0); + } + break; + case GNUNET_FS_STATUS_SEARCH_ERROR: + FPRINTF (stderr, "Error searching file: %s\n", + event->value.search.specifics.error.message); + if (sks_search == event->value.search.sc) + GNUNET_SCHEDULER_add_now (&abort_sks_search_task, NULL); + else if (ksk_search == event->value.search.sc) + GNUNET_SCHEDULER_add_now (&abort_ksk_search_task, NULL); + else + GNUNET_break (0); + break; + case GNUNET_FS_STATUS_SEARCH_START: + GNUNET_assert ((NULL == event->value.search.cctx) || + (0 == strcmp ("sks_search", event->value.search.cctx)) || + (0 == strcmp ("ksk_search", event->value.search.cctx))); + if (NULL == event->value.search.cctx) + { + GNUNET_assert (0 == strcmp ("sks_search", event->value.search.pctx)); + update_started = GNUNET_YES; + } + GNUNET_assert (1 == event->value.search.anonymity); + break; + case GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED: + return NULL; + case GNUNET_FS_STATUS_SEARCH_STOPPED: + return NULL; + default: + FPRINTF (stderr, "Unexpected event: %d\n", event->status); + break; + } + return event->value.search.cctx; } -#if 0 static void -spcb (void *cls, - const char *name, - const GNUNET_HashCode * key) +publish_cont (void *cls, const struct GNUNET_FS_Uri *ksk_uri, const char *emsg) { + char *msg; + struct GNUNET_FS_Uri *sks_uri; + char sbuf[1024]; + char buf[1024]; + char *ret; + + if (NULL != emsg) + { + FPRINTF (stderr, "Error publishing: %s\n", emsg); + err = 1; + GNUNET_FS_stop (fs); + return; + } + ret = GNUNET_STRINGS_data_to_string (&nsid, sizeof (nsid), buf, sizeof (buf)); + GNUNET_assert (NULL != ret); + ret[0] = '\0'; + GNUNET_snprintf (sbuf, sizeof (sbuf), "gnunet://fs/sks/%s/this", buf); + sks_uri = GNUNET_FS_uri_parse (sbuf, &msg); + if (NULL == sks_uri) + { + FPRINTF (stderr, "failed to parse URI `%s': %s\n", sbuf, msg); + err = 1; + GNUNET_FS_stop (fs); + GNUNET_free_non_null (msg); + return; + } + ksk_search = + GNUNET_FS_search_start (fs, ksk_uri, 1, GNUNET_FS_SEARCH_OPTION_NONE, + "ksk_search"); + sks_search = + GNUNET_FS_search_start (fs, sks_uri, 1, GNUNET_FS_SEARCH_OPTION_NONE, + "sks_search"); + GNUNET_FS_uri_destroy (sks_uri); } -#endif static void -publish_cont (void *cls, - const struct GNUNET_FS_Uri *uri, - const char *emsg) +sks_cont (void *cls, const struct GNUNET_FS_Uri *uri, const char *emsg) { - struct GNUNET_FS_SearchContext *search; + struct GNUNET_CONTAINER_MetaData *meta; + struct GNUNET_FS_Uri *ksk_uri; + char *msg; + struct GNUNET_FS_BlockOptions bo; + + if (NULL == uri) + { + fprintf (stderr, "Error publishing: %s\n", emsg); + err = 1; + GNUNET_FS_stop (fs); + return; + } + meta = GNUNET_CONTAINER_meta_data_create (); + msg = NULL; + ksk_uri = GNUNET_FS_uri_parse ("gnunet://fs/ksk/ns-search", &msg); + GNUNET_assert (NULL == msg); + ksk_expect_uri = GNUNET_FS_uri_dup (uri); + bo.content_priority = 1; + bo.anonymity_level = 1; + bo.replication_level = 0; + bo.expiration_time = + GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES); + GNUNET_FS_publish_ksk (fs, ksk_uri, meta, uri, &bo, + GNUNET_FS_PUBLISH_OPTION_NONE, &publish_cont, NULL); + GNUNET_FS_uri_destroy (ksk_uri); + GNUNET_CONTAINER_meta_data_destroy (meta); +} - GNUNET_assert (NULL == emsg); - fprintf (stderr, "Starting namespace search...\n"); - search = GNUNET_FS_search_start (fs, uri, 1, "ns-search"); + +static void +adv_cont (void *cls, const struct GNUNET_FS_Uri *uri, const char *emsg) +{ + struct GNUNET_CONTAINER_MetaData *meta; + struct GNUNET_CRYPTO_EcdsaPrivateKey *ns; + struct GNUNET_FS_BlockOptions bo; + + if (NULL != emsg) + { + FPRINTF (stderr, "Error publishing: %s\n", emsg); + err = 1; + GNUNET_FS_stop (fs); + return; + } + ns = GNUNET_CRYPTO_ecdsa_key_create (); + meta = GNUNET_CONTAINER_meta_data_create (); + sks_expect_uri = GNUNET_FS_uri_dup (uri); + bo.content_priority = 1; + bo.anonymity_level = 1; + bo.replication_level = 0; + bo.expiration_time = + GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES); + GNUNET_CRYPTO_ecdsa_key_get_public (ns, &nsid); + GNUNET_FS_publish_sks (fs, ns, "this", "next", meta, uri, + &bo, GNUNET_FS_PUBLISH_OPTION_NONE, &sks_cont, NULL); + GNUNET_CONTAINER_meta_data_destroy (meta); + GNUNET_free (ns); } static void testNamespace () { - struct GNUNET_FS_Namespace *ns; - struct GNUNET_FS_Uri *adv; - struct GNUNET_FS_Uri *rootUri; + struct GNUNET_CRYPTO_EcdsaPrivateKey *ns; + struct GNUNET_FS_BlockOptions bo; struct GNUNET_CONTAINER_MetaData *meta; - struct GNUNET_TIME_Absolute expiration; + struct GNUNET_FS_Uri *ksk_uri; + struct GNUNET_FS_Uri *sks_uri; - expiration = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES); + ns = GNUNET_CRYPTO_ecdsa_key_create (); meta = GNUNET_CONTAINER_meta_data_create (); - adv = GNUNET_FS_uri_ksk_create ("testNamespace", NULL); - ns = GNUNET_FS_namespace_create (fs, - "testNamespace"); - rootUri = GNUNET_FS_namespace_advertise (fs, - ns, - meta, - 1, 1, - expiration, - adv, - "root"); - GNUNET_assert (NULL != rootUri); - GNUNET_FS_publish_sks (fs, - ns, - "this", - "next", - meta, - rootUri, - expiration, - 1, 1, - GNUNET_FS_PUBLISH_OPTION_NONE, - &publish_cont, - NULL); + ksk_uri = GNUNET_FS_uri_parse ("gnunet://fs/ksk/testnsa", NULL); + bo.content_priority = 1; + bo.anonymity_level = 1; + bo.replication_level = 0; + bo.expiration_time = + GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES); + sks_uri = GNUNET_FS_uri_sks_create (&nsid, "root"); + GNUNET_FS_publish_ksk (fs, + ksk_uri, meta, sks_uri, + &bo, GNUNET_FS_PUBLISH_OPTION_NONE, + &adv_cont, NULL); + GNUNET_FS_uri_destroy (sks_uri); + kill_task = + GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES, &do_timeout, + NULL); + GNUNET_FS_uri_destroy (ksk_uri); GNUNET_CONTAINER_meta_data_destroy (meta); + GNUNET_free (ns); } -#if 0 - fprintf (stderr, "Completed namespace search...\n"); - GNUNET_assert (GNUNET_OK == GNUNET_FS_namespace_delete (NULL, cfg, &pid)); - GNUNET_assert (GNUNET_SYSERR == GNUNET_FS_namespace_delete (NULL, cfg, &pid)); - GNUNET_FS_uri_destroy (rootURI); - GNUNET_FS_uri_destroy (advURI); - GNUNET_assert (match == 1); - return 0; -} -#endif - 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 *cfg, + struct GNUNET_TESTING_Peer *peer) { - sched = s; - setup_peer (&p1, "test_fs_download_data.conf"); - fs = GNUNET_FS_start (sched, - cfg, - "test-fs-namespace", - &progress_cb, - NULL, - GNUNET_FS_FLAGS_NONE, - GNUNET_FS_OPTIONS_END); + fs = GNUNET_FS_start (cfg, "test-fs-namespace", &progress_cb, NULL, + GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END); testNamespace (); } @@ -181,34 +306,12 @@ run (void *cls, int main (int argc, char *argv[]) { - char *const argvx[] = { - "test-fs-namespace", - "-c", - "test_fs_namespace_data.conf", -#if VERBOSE - "-L", "DEBUG", -#endif - NULL - }; - struct GNUNET_GETOPT_CommandLineOption options[] = { - GNUNET_GETOPT_OPTION_END - }; - - GNUNET_log_setup ("test_fs_namespace", -#if VERBOSE - "DEBUG", -#else - "WARNING", -#endif - NULL); - GNUNET_PROGRAM_run ((sizeof (argvx) / sizeof (char *)) - 1, - argvx, "test-fs-namespace", - "nohelp", options, &run, NULL); - stop_arm (&p1); - GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-namespace/"); - return 0; + if (0 != GNUNET_TESTING_peer_run ("test-fs-namespace", + "test_fs_namespace_data.conf", + &run, NULL)) + return 1; + return err; } - /* end of test_fs_namespace.c */