fix #3284: support lib/MULTIARCH/ paths in installation, use GNUNET_PREFIX=@libdir...

[oweals/gnunet.git] / src / core / test_core_api_start_only.c

diff --git a/src/core/test_core_api_start_only.c b/src/core/test_core_api_start_only.c
index 8994b31a7364512a5bba492373f04f122c844ab9..255de0319da72d695cd4d33c20a595730ae3fa80 100644 (file)
--- a/src/core/test_core_api_start_only.c
+++ b/src/core/test_core_api_start_only.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
 
      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
      option) any later version.
 
      GNUnet is distributed in the hope that it will be useful, but


@@ -23,7 +23,6 @@
  *        connects to the core service and shuts down again
  */
 #include "platform.h"
  *        connects to the core service and shuts down again
  */
 #include "platform.h"

-#include "gnunet_common.h"

 #include "gnunet_arm_service.h"
 #include "gnunet_core_service.h"
 #include "gnunet_getopt_lib.h"
 #include "gnunet_arm_service.h"
 #include "gnunet_core_service.h"
 #include "gnunet_getopt_lib.h"


@@ -31,15 +30,7 @@
 #include "gnunet_program_lib.h"
 #include "gnunet_scheduler_lib.h"
 
 #include "gnunet_program_lib.h"
 #include "gnunet_scheduler_lib.h"
 

-#define VERBOSE GNUNET_NO
-
-#define START_ARM GNUNET_YES
-
-
-/**
- * How long until we give up on transmitting the message?
- */
-#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)
+#define TIMEOUT 5

 
 #define MTYPE 12345
 
 
 #define MTYPE 12345
 


@@ -48,21 +39,19 @@ struct PeerContext
   struct GNUNET_CONFIGURATION_Handle *cfg;
   struct GNUNET_CORE_Handle *ch;
   struct GNUNET_PeerIdentity id;
   struct GNUNET_CONFIGURATION_Handle *cfg;
   struct GNUNET_CORE_Handle *ch;
   struct GNUNET_PeerIdentity id;

-#if START_ARM
-  pid_t arm_pid;
-#endif
+  struct GNUNET_OS_Process *arm_proc;

 };
 
 static struct PeerContext p1;
 
 static struct PeerContext p2;
 
 };
 
 static struct PeerContext p1;
 
 static struct PeerContext p2;
 

-static struct GNUNET_SCHEDULER_Handle *sched;
+static GNUNET_SCHEDULER_TaskIdentifier timeout_task_id;

 
 static int ok;
 
 #if VERBOSE
 
 static int ok;
 
 #if VERBOSE

-#define OKPP do { ok++; fprintf (stderr, "Now at stage %u at %s:%u\n", ok, __FILE__, __LINE__); } while (0)
+#define OKPP do { ok++; FPRINTF (stderr, "Now at stage %u at %s:%u\n", ok, __FILE__, __LINE__); } while (0)

 #else
 #define OKPP do { ok++; } while (0)
 #endif
 #else
 #define OKPP do { ok++; } while (0)
 #endif


@@ -70,38 +59,28 @@ static int ok;
 
 
 static void
 
 
 static void

-connect_notify (void *cls,
-                const struct GNUNET_PeerIdentity *peer,
-               struct GNUNET_TIME_Relative latency,
-               uint32_t distance)
+connect_notify (void *cls, const struct GNUNET_PeerIdentity *peer)

 {
 }
 
 
 static void
 {
 }
 
 
 static void

-disconnect_notify (void *cls,
-                   const struct GNUNET_PeerIdentity *peer)
+disconnect_notify (void *cls, const struct GNUNET_PeerIdentity *peer)

 {
 }
 
 
 static int
 {
 }
 
 
 static int

-inbound_notify (void *cls,
-                const struct GNUNET_PeerIdentity *other,
-                const struct GNUNET_MessageHeader *message,
-               struct GNUNET_TIME_Relative latency,
-               uint32_t distance)
+inbound_notify (void *cls, const struct GNUNET_PeerIdentity *other,
+                const struct GNUNET_MessageHeader *message)

 {
   return GNUNET_OK;
 }
 
 
 static int
 {
   return GNUNET_OK;
 }
 
 
 static int

-outbound_notify (void *cls,
-                 const struct GNUNET_PeerIdentity *other,
-                 const struct GNUNET_MessageHeader *message,
-                struct GNUNET_TIME_Relative latency,
-                uint32_t distance)
+outbound_notify (void *cls, const struct GNUNET_PeerIdentity *other,
+                 const struct GNUNET_MessageHeader *message)

 {
   return GNUNET_OK;
 }
 {
   return GNUNET_OK;
 }


@@ -112,98 +91,107 @@ static struct GNUNET_CORE_MessageHandler handlers[] = {
 };
 
 
 };
 
 

+static void
+shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  GNUNET_CORE_disconnect (p1.ch);
+  p1.ch = NULL;
+  GNUNET_CORE_disconnect (p2.ch);
+  p2.ch = NULL;
+  ok = 0;
+}
+

 
 static void
 init_notify (void *cls,
 
 static void
 init_notify (void *cls,

-             struct GNUNET_CORE_Handle *server,
-             const struct GNUNET_PeerIdentity *my_identity,
-             const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *publicKey)
+             const struct GNUNET_PeerIdentity *my_identity)

 {
   struct PeerContext *p = cls;
 
 {
   struct PeerContext *p = cls;
 

-  GNUNET_assert (server != NULL);
-  p->ch = server;
-  if (cls == &p1)
-    {
-      /* connect p2 */
-      GNUNET_CORE_connect (sched,
-                           p2.cfg,
-                           TIMEOUT,
-                           &p2,
-                           &init_notify,
-                          NULL,
-                           &connect_notify,
-                           &disconnect_notify,
-                           &inbound_notify,
-                           GNUNET_YES,
-                           &outbound_notify, GNUNET_YES, handlers);
-    }
+  if (p == &p1)
+  {
+    /* connect p2 */
+    p2.ch =
+        GNUNET_CORE_connect (p2.cfg, &p2, &init_notify, &connect_notify,
+                             &disconnect_notify, &inbound_notify, GNUNET_YES,
+                             &outbound_notify, GNUNET_YES, handlers);
+  }

   else
   else

-    {
-      GNUNET_assert (cls == &p2);
-      GNUNET_CORE_disconnect (p1.ch);
-      GNUNET_CORE_disconnect (p2.ch);
-      GNUNET_ARM_stop_services (p1.cfg, sched, "core", NULL);
-      GNUNET_ARM_stop_services (p2.cfg, sched, "core", NULL);
-
-      ok = 0;
-    }
+  {
+    GNUNET_assert (p == &p2);
+    GNUNET_SCHEDULER_cancel (timeout_task_id);
+    GNUNET_SCHEDULER_add_now (&shutdown_task, NULL);
+  }

 }
 
 
 static void
 setup_peer (struct PeerContext *p, const char *cfgname)
 {
 }
 
 
 static void
 setup_peer (struct PeerContext *p, const char *cfgname)
 {

+  char *binary;
+
+  binary = GNUNET_OS_get_libexec_binary_path ("gnunet-service-arm");

   p->cfg = GNUNET_CONFIGURATION_create ();
   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
+  p->arm_proc =
+    GNUNET_OS_start_process (GNUNET_YES, GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
+                            NULL, NULL,
+                            binary,
+                            "gnunet-service-arm",
+                            "-c", cfgname, NULL);

   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));

-  GNUNET_ARM_start_services (p->cfg, sched, "core", NULL);
+  GNUNET_free (binary);

 }
 
 
 static void
 }
 
 
 static void

-run (void *cls,
-     struct GNUNET_SCHEDULER_Handle *s,
-     char *const *args,
-     const char *cfgfile, 
+timeout_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  FPRINTF (stderr, "%s",  "Timeout.\n");
+  if (p1.ch != NULL)
+  {
+    GNUNET_CORE_disconnect (p1.ch);
+    p1.ch = NULL;
+  }
+  if (p2.ch != NULL)
+  {
+    GNUNET_CORE_disconnect (p2.ch);
+    p2.ch = NULL;
+  }
+  ok = 42;
+}
+
+
+static void
+run (void *cls, char *const *args, const char *cfgfile,

      const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   GNUNET_assert (ok == 1);
   OKPP;
      const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   GNUNET_assert (ok == 1);
   OKPP;

-  sched = s;

   setup_peer (&p1, "test_core_api_peer1.conf");
   setup_peer (&p2, "test_core_api_peer2.conf");
   setup_peer (&p1, "test_core_api_peer1.conf");
   setup_peer (&p2, "test_core_api_peer2.conf");

-  GNUNET_CORE_connect (sched,
-                       p1.cfg,
-                       TIMEOUT,
-                       &p1,
-                       &init_notify,
-                      NULL,
-                       &connect_notify,
-                       &disconnect_notify,
-                       &inbound_notify,
-                       GNUNET_YES, &outbound_notify, GNUNET_YES, handlers);
+  timeout_task_id =
+      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
+                                    (GNUNET_TIME_UNIT_MINUTES, TIMEOUT),
+                                    &timeout_task, NULL);
+  p1.ch =
+      GNUNET_CORE_connect (p1.cfg, &p1, &init_notify, &connect_notify,
+                           &disconnect_notify, &inbound_notify, GNUNET_YES,
+                           &outbound_notify, GNUNET_YES, handlers);

 }
 
 
 static void
 stop_arm (struct PeerContext *p)
 {
 }
 
 
 static void
 stop_arm (struct PeerContext *p)
 {

-#if START_ARM
-  if (0 != PLIBC_KILL (p->arm_pid, SIGTERM))
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Stopping peer\n");
+  if (0 != GNUNET_OS_process_kill (p->arm_proc, GNUNET_TERM_SIG))

     GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
     GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");

-  if (GNUNET_OS_process_wait(p->arm_pid) != GNUNET_OK)
+  if (GNUNET_OS_process_wait (p->arm_proc) != GNUNET_OK)

     GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
     GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");

-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "ARM process %u stopped\n", p->arm_pid);
-#endif
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "ARM process %u stopped\n",
+              GNUNET_OS_process_get_pid (p->arm_proc));
+  GNUNET_OS_process_destroy (p->arm_proc);
+  p->arm_proc = NULL;

   GNUNET_CONFIGURATION_destroy (p->cfg);
 }
 
   GNUNET_CONFIGURATION_destroy (p->cfg);
 }
 


@@ -211,40 +199,38 @@ stop_arm (struct PeerContext *p)
 static int
 check ()
 {
 static int
 check ()
 {

-  char *const argv[] = { "test-core-api",
+  char *const argv[] = { "test-core-api-start-only",

     "-c",
     "test_core_api_data.conf",
     "-c",
     "test_core_api_data.conf",

-#if VERBOSE
-    "-L", "DEBUG",
-#endif

     NULL
   };
   struct GNUNET_GETOPT_CommandLineOption options[] = {
     GNUNET_GETOPT_OPTION_END
   };
     NULL
   };
   struct GNUNET_GETOPT_CommandLineOption options[] = {
     GNUNET_GETOPT_OPTION_END
   };

+  GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-peer-1");
+  GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-peer-2");

 
   ok = 1;
 
   ok = 1;

-  GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1,
-                      argv, "test-core-api", "nohelp", options, &run, &ok);
+  GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1, argv,
+                      "test-core-api-start-only", "nohelp", options, &run, &ok);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test finished\n");

   stop_arm (&p1);
   stop_arm (&p2);
   return ok;
 }
 
   stop_arm (&p1);
   stop_arm (&p2);
   return ok;
 }
 

+

 int
 main (int argc, char *argv[])
 {
   int ret;
 
 int
 main (int argc, char *argv[])
 {
   int ret;
 

-  GNUNET_log_setup ("test-core-api",
-#if VERBOSE
-                    "DEBUG",
-#else
+  GNUNET_log_setup ("test-core-api-start-only",

                     "WARNING",
                     "WARNING",

-#endif

                     NULL);
   ret = check ();
                     NULL);
   ret = check ();

-
+  GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-peer-1");
+  GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-peer-2");

   return ret;
 }
 
   return ret;
 }