rename connecT -> connect now that the old API is dead

[oweals/gnunet.git] / src / util / test_service.c

diff --git a/src/util/test_service.c b/src/util/test_service.c
index fa35da6e9cd4a27eecb760cb6869f6cb421e837d..d2136b42f0a8881a89a175e506e79e26ec6eda7b 100644 (file)
--- a/src/util/test_service.c
+++ b/src/util/test_service.c
@@ -1,10 +1,10 @@
 /*
      This file is part of GNUnet.
 /*
      This file is part of GNUnet.

-     (C) 2009 Christian Grothoff (and other contributing authors)
+     Copyright (C) 2009, 2013, 2016 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
 
      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


@@ -14,326 +14,191 @@
 
      You should have received a copy of the GNU General Public License
      along with GNUnet; see the file COPYING.  If not, write to the
 
      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.

 */
 /**
  * @file util/test_service.c
  * @brief tests for service.c
 */
 /**
  * @file util/test_service.c
  * @brief tests for service.c

+ * @author Christian Grothoff

  */
 #include "platform.h"
  */
 #include "platform.h"

-#include "gnunet_common.h"
-#include "gnunet_client_lib.h"
-#include "gnunet_getopt_lib.h"
-#include "gnunet_program_lib.h"
-#include "gnunet_service_lib.h"
-#include "gnunet_scheduler_lib.h"
-#include "gnunet_time_lib.h"
-
-
-#define VERBOSE GNUNET_NO
-
-#define PORT 12435
+#include "gnunet_util_lib.h"

 
 

+/**
+ * Message type we use for testing.
+ */

 #define MY_TYPE 256
 
 #define MY_TYPE 256
 

-static struct GNUNET_SCHEDULER_Handle *sched;
+static int global_ret = 1;

 
 

-static struct GNUNET_SERVICE_Context *sctx;
-
-static int ok = 1;
+static struct GNUNET_MQ_Handle *mq;

 
 
 static void
 
 
 static void

-end_it (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+handle_recv (void *cls,
+            const struct GNUNET_MessageHeader *message)

 {
 {

-  struct GNUNET_CLIENT_Connection *client = cls;
-
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Shutting down service\n");
-  GNUNET_CLIENT_service_shutdown (client);
-  if (sctx != NULL)    
-    GNUNET_SERVICE_stop (sctx);
-  else
-    GNUNET_SCHEDULER_shutdown (sched);
-  ok = 0;
-}
-
-
-static size_t
-build_msg (void *cls, size_t size, void *buf)
-{
-  struct GNUNET_CLIENT_Connection *client = cls;
-  struct GNUNET_MessageHeader *msg = buf;
-
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Client connected, transmitting\n");
-  GNUNET_assert (size >= sizeof (struct GNUNET_MessageHeader));
-  msg->type = htons (MY_TYPE);
-  msg->size = htons (sizeof (struct GNUNET_MessageHeader));
-  GNUNET_SCHEDULER_add_continuation (sched,
-                                     &end_it,
-                                     client,
-                                     GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-  return sizeof (struct GNUNET_MessageHeader);
-}
-
-static void
-ready (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
-{
-  const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
-  struct GNUNET_CLIENT_Connection *client;
-
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Service confirmed running\n");
-  sched = tc->sched;
-  GNUNET_assert (0 != (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE));
-  client = GNUNET_CLIENT_connect (tc->sched, "test_service", cfg);
-  GNUNET_assert (client != NULL);
+  struct GNUNET_SERVICE_Client *client = cls;
+  

   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,

-              "Client connecting, waiting to transmit\n");
-  GNUNET_CLIENT_notify_transmit_ready (client,
-                                       sizeof (struct GNUNET_MessageHeader),
-                                       GNUNET_TIME_UNIT_SECONDS,
-                                       GNUNET_NO, &build_msg, client);
-}
-
-static void
-recv_cb (void *cls,
-         struct GNUNET_SERVER_Client *client,
-         const struct GNUNET_MessageHeader *message)
-{
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Receiving client message...\n");
-  GNUNET_SERVER_receive_done (client, GNUNET_OK);
-}
-
-static struct GNUNET_SERVER_MessageHandler myhandlers[] = {
-  {&recv_cb, NULL, MY_TYPE, sizeof (struct GNUNET_MessageHeader)},
-  {NULL, NULL, 0, 0}
-};
-
-
-
-
-static void
-runner (void *cls,
-        struct GNUNET_SCHEDULER_Handle *sched,
-        struct GNUNET_SERVER_Handle *server,
-        const struct GNUNET_CONFIGURATION_Handle *cfg)
-{
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Service initializing\n");
-  GNUNET_SERVER_add_handlers (server, myhandlers);
-  GNUNET_CLIENT_service_test (sched,
-                              "test_service",
-                              cfg, GNUNET_TIME_UNIT_SECONDS, &ready,
-                              (void *) cfg);
+             "Received client message...\n");
+  GNUNET_SERVICE_client_continue (client);
+  global_ret = 2;
+  GNUNET_MQ_destroy (mq);
+  mq = NULL;

 }
 
 
 /**
 }
 
 
 /**

- * Main method, starts scheduler with task1,
- * checks that "ok" is correct at the end.
+ * Function called when the client connects to the service.
+ *
+ * @param cls the name of the service
+ * @param c connecting client
+ * @param mq message queue to talk to the client
+ * @return @a c so we have the client handle in the future

  */
  */

-static int
-check ()
+static void *
+connect_cb (void *cls,
+           struct GNUNET_SERVICE_Client *c,
+           struct GNUNET_MQ_Handle *mq)

 {
 {

-  ok = 1;
-  char *const argv[] = {
-    "test_service",
-    "-c",
-    "test_service_data.conf",
-    "-L",
-#if VERBOSE
-    "DEBUG",
-#else
-    "WARNING",
-#endif
-    NULL
-  };
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting service\n");
-  GNUNET_assert (GNUNET_OK ==
-                 GNUNET_SERVICE_run (5,
-                                     argv,
-                                     "test_service",
-                                     &runner, &ok));
-  GNUNET_assert (0 == ok);
-  return ok;
+  /* FIXME: in the future, do something with mq
+     to test sending messages to the client! */
+  return c;

 }
 
 }
 

-static void 
-ready6 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
-{
-  const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
-  struct GNUNET_CLIENT_Connection *client;
-
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "V6 ready\n");
-  sched = tc->sched;
-  GNUNET_assert (0 != (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE));
-  client = GNUNET_CLIENT_connect (tc->sched, "test_service6", cfg);
-  GNUNET_assert (client != NULL);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "V6 client connected\n");
-  GNUNET_CLIENT_notify_transmit_ready (client,
-                                       sizeof (struct GNUNET_MessageHeader),
-                                       GNUNET_TIME_UNIT_SECONDS,
-                                       GNUNET_NO, &build_msg, client);
-}

 
 

+/**
+ * Function called when the client disconnects.
+ *
+ * @param cls our service name
+ * @param c disconnecting client
+ * @param internal_cls must match @a c
+ */ 

 static void
 static void

-runner6 (void *cls,
-         struct GNUNET_SCHEDULER_Handle *sched,
-         struct GNUNET_SERVER_Handle *server,
-         const struct GNUNET_CONFIGURATION_Handle *cfg)
+disconnect_cb (void *cls,
+              struct GNUNET_SERVICE_Client *c,
+              void *internal_cls)

 {
 {

-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Initializing v6 service\n");
-  GNUNET_SERVER_add_handlers (server, myhandlers);
-  GNUNET_CLIENT_service_test (sched,
-                              "test_service6",
-                              cfg, GNUNET_TIME_UNIT_SECONDS, &ready6,
-                              (void *) cfg);
+  GNUNET_assert (c == internal_cls);
+  if (2 == global_ret)
+  {
+    GNUNET_SCHEDULER_shutdown ();
+    global_ret = 0;
+  }

 }
 
 }
 

+

 /**
 /**

- * Main method, starts scheduler with task1,
- * checks that "ok" is correct at the end.
+ * Initialization function of the service.  Starts
+ * a client to connect to the service.
+ *
+ * @param cls the name of the service (const char *)
+ * @param cfg the configuration we use
+ * @param sh handle to the service

  */
  */

-static int
-check6 ()
+static void
+service_init (void *cls,
+             const struct GNUNET_CONFIGURATION_Handle *cfg,
+             struct GNUNET_SERVICE_Handle *sh)

 {
 {

-  char *const argv[] = {
-    "test_service6",
-    "-c",
-    "test_service_data.conf",
-    "-L",
-#if VERBOSE
-    "DEBUG",
-#else
-    "WARNING",
-#endif
-    NULL
-  };
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting v6 service\n");
-  GNUNET_assert (GNUNET_OK ==
-                 GNUNET_SERVICE_run (5,
-                                     argv,
-                                     "test_service6",
-                                     &runner6, &ok));
-  GNUNET_assert (0 == ok);
-  return ok;
+  const char *service_name = cls;
+  struct GNUNET_MQ_Envelope *env;
+  struct GNUNET_MessageHeader *msg;
+  
+  mq = GNUNET_CLIENT_connect (cfg,
+                              service_name,
+                              NULL,
+                              NULL,
+                              NULL);
+  GNUNET_assert (NULL != mq);
+  env = GNUNET_MQ_msg (msg,
+                       MY_TYPE);
+  GNUNET_MQ_send (mq,
+                  env);

 }
 
 
 /**
 }
 
 
 /**

- * Main method, starts scheduler with task1,
- * checks that "ok" is correct at the end.
+ * Main method, starts the service and initiates
+ * the running of the test.
+ *
+ * @param sname name of the service to run

  */
 static int
  */
 static int

-check6d ()
+check (const char *sname)

 {
 {

-  ok = 1;
-  char *const argv[] = {
-    "test_service6",
-    "-c",
-    "test_service_data.conf",
-    "-L",
-#if VERBOSE
-    "DEBUG",
-#else
-    "WARNING",
-#endif
-    "-d",
-    NULL
+  struct GNUNET_MQ_MessageHandler myhandlers[] = {
+    GNUNET_MQ_hd_fixed_size (recv,
+                            MY_TYPE,
+                            struct GNUNET_MessageHeader,
+                            NULL),
+    GNUNET_MQ_handler_end ()

   };
   };

-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting V6 as daemon\n");
-  GNUNET_assert (GNUNET_OK ==
-                 GNUNET_SERVICE_run (6,
-                                     argv,
-                                     "test_service6",
-                                     &runner6, &ok));
-  GNUNET_break (0 == ok);
-  return ok;
-}
-
-
-static void
-start_stop_main (void *cls,
-                 struct GNUNET_SCHEDULER_Handle *sched,
-                 char *const *args,
-                 const char *cfgfile,
-                 const struct GNUNET_CONFIGURATION_Handle *cfg)
-{
-  int *ret = cls;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Starting service using start method\n");
-  sctx = GNUNET_SERVICE_start ("test_service", sched, cfg);
-  runner (cls, sched, GNUNET_SERVICE_get_server (sctx), cfg);
-  *ret = 0;
-}
-
-
-static int
-check_start_stop ()
-{

   char *const argv[] = {
   char *const argv[] = {

-    "test-service-program",
+    (char *) sname,

     "-c",
     "test_service_data.conf",
     "-c",
     "test_service_data.conf",

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

     NULL
   };
     NULL
   };

-  const struct GNUNET_GETOPT_CommandLineOption options[] = {
-    GNUNET_GETOPT_OPTION_END
-  };
-  int ret = 1;
-  GNUNET_assert (GNUNET_OK ==
-                 GNUNET_PROGRAM_run (5,
-                                     argv,
-                                     "test-service-program",
-                                     "no help",
-                                     options, &start_stop_main, &ret));
-
-  GNUNET_break (0 == ret);
-  return ret;
+  
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+             "Starting `%s' service\n",
+             sname);
+  global_ret = 1;
+  GNUNET_assert (0 ==
+                 GNUNET_SERVICE_ruN_ (3,
+                                     argv,
+                                     sname,
+                                     GNUNET_SERVICE_OPTION_NONE,
+                                     &service_init,
+                                     &connect_cb,
+                                     &disconnect_cb,
+                                     (void *) sname,
+                                     myhandlers));
+  return global_ret;

 }
 
 
 int
 }
 
 
 int

-main (int argc, char *argv[])
+main (int argc,
+      char *argv[])

 {
   int ret = 0;
 {
   int ret = 0;

-  struct GNUNET_NETWORK_Handle *s;
+  struct GNUNET_NETWORK_Handle *s = NULL;

 
   GNUNET_log_setup ("test-service",
 
   GNUNET_log_setup ("test-service",

-#if VERBOSE
-                    "DEBUG",
-#else

                     "WARNING",
                     "WARNING",

-#endif

                     NULL);
                     NULL);

-  ret += check ();
-  ret += check ();
-  s = GNUNET_NETWORK_socket_create (PF_INET6, SOCK_STREAM, 0);
+  ret += check ("test_service");
+  ret += check ("test_service");
+#ifndef MINGW
+  s = GNUNET_NETWORK_socket_create (PF_INET6,
+                                   SOCK_STREAM,
+                                   0);
+#endif

   if (NULL == s)
   if (NULL == s)

+  {
+    if ( (errno == ENOBUFS) ||
+        (errno == ENOMEM) ||
+        (errno == ENFILE) ||
+        (errno == EACCES) )

     {
     {

-      if ((errno == ENOBUFS) ||
-          (errno == ENOMEM) || (errno == ENFILE) || (errno == EACCES))
-        {
-          GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "socket");
-          return 1;
-        }
-      fprintf (stderr,
-               "IPv6 support seems to not be available (%s), not testing it!\n",
-               strerror (errno));
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
+                          "socket");
+      return 1;

     }
     }

+    FPRINTF (stderr,
+             "IPv6 support seems to not be available (%s), not testing it!\n",
+             strerror (errno));
+  }

   else
   else

-    {
-      GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (s));
-      ret += check6 ();
-      ret += check6d ();        /* with daemonization */
-    }
-  ret += check_start_stop ();
-
+  {
+    GNUNET_break (GNUNET_OK ==
+                 GNUNET_NETWORK_socket_close (s));
+    ret += check ("test_service6");
+  }

   return ret;
 }
 
   return ret;
 }