/*
This file is part of GNUnet.
- (C) 2008--2013 Christian Grothoff (and other contributing authors)
+ Copyright (C) 2008--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
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 testbed/testbed_api_barriers.c
* @brief API implementation for testbed barriers
- * @author Sree Harsha Totakura <sreeharsha@totakura.in>
+ * @author Sree Harsha Totakura <sreeharsha@totakura.in>
*/
-
#include "platform.h"
#include "gnunet_testbed_service.h"
#include "testbed_api.h"
/**
- * Handle for barrier
+ * Logging shorthand
+ */
+#define LOG(type, ...) \
+ GNUNET_log_from (type, "testbed-api-barriers", __VA_ARGS__);
+
+/**
+ * Debug logging shorthand
+ */
+#define LOG_DEBUG(...) \
+ LOG (GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__);
+
+
+/**
+ * Barrier wait handle
*/
-struct GNUNET_TESTBED_Barrier
+struct GNUNET_TESTBED_BarrierWaitHandle
{
/**
- * hashcode identifying this barrier in the hashmap
+ * The name of the barrier
*/
- struct GNUNET_HashCode key;
+ char *name;
/**
- * The controller handle given while initiliasing this barrier
+ * Then configuration used for the client connection
*/
- struct GNUNET_TESTBED_Controller *c;
-
+ struct GNUNET_CONFIGURATION_Handle *cfg;
+
/**
- * The name of the barrier
+ * The testbed-barrier service message queue.
*/
- char *name;
+ struct GNUNET_MQ_Handle *mq;
/**
- * The continuation callback to call when we have a status update on this
+ * The barrier wait callback
*/
- GNUNET_TESTBED_barrier_status_cb cb;
+ GNUNET_TESTBED_barrier_wait_cb cb;
/**
- * the closure for the above callback
+ * The closure for @e cb.
*/
- void *cls;
-
+ void *cb_cls;
};
+
/**
- * handle for hashtable of barrier handles
+ * Check if barrier status message is well-formed.
+ *
+ * @param cls closure
+ * @param msg received message
+ * @return #GNUNET_OK if the message is well-formed.
*/
-static struct GNUNET_CONTAINER_MultiHashMap *barrier_map;
+static int
+check_status (void *cls,
+ const struct GNUNET_TESTBED_BarrierStatusMsg *msg)
+{
+ /* FIXME: this fails to actually check that the message
+ follows the protocol spec (0-terminations!). However,
+ not critical as #handle_status() doesn't interpret the
+ variable-size part anyway right now. */
+ return GNUNET_OK;
+}
/**
- * Remove a barrier and it was the last one in the barrier hash map, destroy the
- * hash map
+ * Type of a function to call when we receive a message
+ * from the service.
*
- * @param barrier the barrier to remove
+ * @param cls closure
+ * @param msg received message
*/
static void
-barrier_remove (struct GNUNET_TESTBED_Barrier *barrier)
+handle_status (void *cls,
+ const struct GNUNET_TESTBED_BarrierStatusMsg *msg)
{
- GNUNET_assert (NULL != barrier_map); /* No barriers present */
- GNUNET_assert (GNUNET_OK ==
- GNUNET_CONTAINER_multihashmap_remove (barrier_map,
- &barrier->key,
- barrier));
- GNUNET_free (barrier->name);
- GNUNET_free (barrier);
- if (0 == GNUNET_CONTAINER_multihashmap_size (barrier_map))
+ struct GNUNET_TESTBED_BarrierWaitHandle *h = cls;
+
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Got barrier status %d\n",
+ (int) ntohs (msg->status));
+ switch (ntohs (msg->status))
{
- GNUNET_CONTAINER_multihashmap_destroy (barrier_map);
- barrier_map = NULL;
+ case GNUNET_TESTBED_BARRIERSTATUS_ERROR:
+ h->cb (h->cb_cls,
+ h->name,
+ GNUNET_SYSERR);
+ break;
+ case GNUNET_TESTBED_BARRIERSTATUS_INITIALISED:
+ h->cb (h->cb_cls,
+ h->name,
+ GNUNET_SYSERR);
+ GNUNET_break (0);
+ break;
+ case GNUNET_TESTBED_BARRIERSTATUS_CROSSED:
+ h->cb (h->cb_cls,
+ h->name,
+ GNUNET_OK);
+ break;
+ default:
+ GNUNET_break_op (0);
+ h->cb (h->cb_cls,
+ h->name,
+ GNUNET_SYSERR);
+ break;
}
+ GNUNET_TESTBED_barrier_wait_cancel (h);
}
/**
- * Handler for GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_STATUS messages
+ * Generic error handler, called with the appropriate error code and
+ * the same closure specified at the creation of the message queue.
+ * Not every message queue implementation supports an error handler.
*
- * @param c the controller handle to determine the connection this message
- * belongs to
- * @param msg the barrier status message
- * @return GNUNET_OK to keep the connection active; GNUNET_SYSERR to tear it
- * down signalling an error
+ * @param cls closure with the `struct GNUNET_TESTBED_BarrierWaitHandle *`
+ * @param error error code
*/
-int
-GNUNET_TESTBED_handle_barrier_status_ (struct GNUNET_TESTBED_Controller *c,
- const struct GNUNET_TESTBED_BarrierStatusMsg
- *msg)
+static void
+mq_error_handler (void *cls,
+ enum GNUNET_MQ_Error error)
{
- struct GNUNET_TESTBED_Barrier *barrier;
- char *emsg;
- const char *name;
- struct GNUNET_HashCode key;
- size_t emsg_len;
- int status;
- uint16_t msize;
- uint16_t name_len;
-
- emsg = NULL;
- barrier = NULL;
- msize = ntohs (msg->header.size);
- name = msg->data;
- name_len = ntohs (msg->name_len);
- if ( (sizeof (struct GNUNET_TESTBED_BarrierStatusMsg) + name_len + 1 > msize)
- || ('\0' != name[name_len]) )
- {
- GNUNET_break_op (0);
- return GNUNET_SYSERR;
- }
- status = ntohs (msg->status);
- if (BARRIER_STATUS_ERROR == status)
- {
- status = -1;
- emsg_len = msize - (sizeof (struct GNUNET_TESTBED_BarrierStatusMsg) + name_len
- + 1);
- if (0 == emsg_len)
- {
- GNUNET_break_op (0);
- return GNUNET_SYSERR;
- }
- emsg_len++;
- emsg = GNUNET_malloc (emsg_len);
- emsg_len--;
- emsg[emsg_len] = '\0';
- (void) memcpy (emsg, msg->data + name_len + 1, emsg_len);
- }
- if (NULL == barrier_map)
- goto cleanup;
- GNUNET_CRYPTO_hash (name, name_len, &key);
- barrier = GNUNET_CONTAINER_multihashmap_get (barrier_map, &key);
- if (NULL == barrier)
- goto cleanup;
- GNUNET_assert (NULL != barrier->cb);
- barrier->cb (barrier->cls, name, barrier, status, emsg);
- if (BARRIER_STATUS_INITIALISED == status)
- return GNUNET_OK; /* just initialised; skip cleanup */
-
- cleanup:
- GNUNET_free_non_null (emsg);
- if (NULL != barrier)
- barrier_remove (barrier);
- return GNUNET_OK;
+ struct GNUNET_TESTBED_BarrierWaitHandle *h = cls;
+
+ h->cb (h->cb_cls,
+ h->name,
+ GNUNET_SYSERR);
+ GNUNET_TESTBED_barrier_wait_cancel (h);
}
/**
- * Initialise a barrier and call the given callback when the required percentage
- * of peers (quorum) reach the barrier OR upon error.
+ * Wait for a barrier to be crossed. This function should be called by the
+ * peers which have been started by the testbed. If the peer is not started by
+ * testbed this function may return error
*
- * @param controller the handle to the controller
- * @param name identification name of the barrier
- * @param quorum the percentage of peers that is required to reach the barrier.
- * Peers signal reaching a barrier by calling
- * GNUNET_TESTBED_barrier_reached().
- * @param cb the callback to call when the barrier is reached or upon error.
- * Cannot be NULL.
- * @param cls closure for the above callback
- * @return barrier handle; NULL upon error
+ * @param name the name of the barrier
+ * @param cb the barrier wait callback
+ * @param cb_cls the closure for @a cb
+ * @return barrier wait handle which can be used to cancel the waiting at
+ * anytime before the callback is called. NULL upon error.
*/
-struct GNUNET_TESTBED_Barrier *
-GNUNET_TESTBED_barrier_init (struct GNUNET_TESTBED_Controller *controller,
- const char *name,
- unsigned int quorum,
- GNUNET_TESTBED_barrier_status_cb cb, void *cls)
+struct GNUNET_TESTBED_BarrierWaitHandle *
+GNUNET_TESTBED_barrier_wait (const char *name,
+ GNUNET_TESTBED_barrier_wait_cb cb,
+ void *cb_cls)
{
- struct GNUNET_TESTBED_Barrier *barrier;
- struct GNUNET_HashCode key;
+ struct GNUNET_TESTBED_BarrierWaitHandle *h
+ = GNUNET_new (struct GNUNET_TESTBED_BarrierWaitHandle);
+ struct GNUNET_MQ_MessageHandler handlers[] = {
+ GNUNET_MQ_hd_var_size (status,
+ GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_STATUS,
+ struct GNUNET_TESTBED_BarrierStatusMsg,
+ h),
+ GNUNET_MQ_handler_end ()
+ };
+ struct GNUNET_MQ_Envelope *env;
+ struct GNUNET_TESTBED_BarrierWait *msg;
+ const char *cfg_filename;
size_t name_len;
-
- GNUNET_assert (quorum <= 100);
+
GNUNET_assert (NULL != cb);
- name_len = strlen (name);
- GNUNET_assert (0 < name_len);
- GNUNET_CRYPTO_hash (name, name_len, &key);
- if (NULL == barrier_map)
- barrier_map = GNUNET_CONTAINER_multihashmap_create (3, GNUNET_YES);
- if (GNUNET_YES ==
- GNUNET_CONTAINER_multihashmap_contains (barrier_map, &key))
+ cfg_filename = getenv (ENV_TESTBED_CONFIG);
+ if (NULL == cfg_filename)
{
- GNUNET_break (0);
+ LOG (GNUNET_ERROR_TYPE_ERROR,
+ "Are you running under testbed?\n");
+ GNUNET_free (h);
return NULL;
}
- barrier = GNUNET_malloc (sizeof (struct GNUNET_TESTBED_Barrier));
- barrier->name = GNUNET_strdup (name);
- barrier->cb = cb;
- barrier->cls = cls;
- (void) memcpy (&barrier->key, &key, sizeof (struct GNUNET_HashCode));
- GNUNET_assert (GNUNET_OK ==
- GNUNET_CONTAINER_multihashmap_put (barrier_map, &barrier->key,
- barrier,
- GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST));
- return barrier;
+ h->cfg = GNUNET_CONFIGURATION_create ();
+ if (GNUNET_OK !=
+ GNUNET_CONFIGURATION_load (h->cfg,
+ cfg_filename))
+ {
+ LOG (GNUNET_ERROR_TYPE_ERROR,
+ "Unable to load configuration from file `%s'\n",
+ cfg_filename);
+ GNUNET_CONFIGURATION_destroy (h->cfg);
+ GNUNET_free (h);
+ return NULL;
+ }
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Waiting on barrier `%s'\n",
+ name);
+ h->name = GNUNET_strdup (name);
+ h->cb = cb;
+ h->cb_cls = cb_cls;
+ h->mq = GNUNET_CLIENT_connect (h->cfg,
+ "testbed-barrier",
+ handlers,
+ &mq_error_handler,
+ h);
+ if (NULL == h->mq)
+ {
+ LOG (GNUNET_ERROR_TYPE_ERROR,
+ "Unable to connect to local testbed-barrier service\n");
+ GNUNET_TESTBED_barrier_wait_cancel (h);
+ return NULL;
+ }
+ name_len = strlen (name); /* NOTE: unusual to not have 0-termination, change? */
+ env = GNUNET_MQ_msg_extra (msg,
+ name_len,
+ GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_WAIT);
+ GNUNET_memcpy (msg->name,
+ name,
+ name_len);
+ GNUNET_MQ_send (h->mq,
+ env);
+ return h;
}
/**
- * Cancel a barrier.
+ * Cancel a barrier wait handle
*
- * @param barrier the barrier handle
+ * @param h the barrier wait handle
*/
void
-GNUNET_TESTBED_barrier_cancel (struct GNUNET_TESTBED_Barrier *barrier)
+GNUNET_TESTBED_barrier_wait_cancel (struct GNUNET_TESTBED_BarrierWaitHandle *h)
{
- barrier_remove (barrier);
+ if (NULL != h->mq)
+ {
+ GNUNET_MQ_destroy (h->mq);
+ h->mq = NULL;
+ }
+ GNUNET_free (h->name);
+ GNUNET_CONFIGURATION_destroy (h->cfg);
+ GNUNET_free (h);
}
/* end of testbed_api_barriers.c */
projects / oweals / gnunet.git / blobdiff