+
+/**
+ * Function called when a shutdown peers operation is ready
+ *
+ * @param cls the closure from GNUNET_TESTBED_operation_create_()
+ */
+static void
+opstart_shutdown_peers (void *cls)
+{
+ struct OperationContext *opc = cls;
+ struct GNUNET_MQ_Envelope *env;
+ struct GNUNET_TESTBED_ShutdownPeersMessage *msg;
+
+ opc->state = OPC_STATE_STARTED;
+ env = GNUNET_MQ_msg (msg,
+ GNUNET_MESSAGE_TYPE_TESTBED_SHUTDOWN_PEERS);
+ msg->operation_id = GNUNET_htonll (opc->id);
+ GNUNET_TESTBED_insert_opc_ (opc->c,
+ opc);
+ GNUNET_MQ_send (opc->c->mq,
+ env);
+}
+
+
+/**
+ * Callback which will be called when shutdown peers operation is released
+ *
+ * @param cls the closure from GNUNET_TESTBED_operation_create_()
+ */
+static void
+oprelease_shutdown_peers (void *cls)
+{
+ struct OperationContext *opc = cls;
+
+ switch (opc->state)
+ {
+ case OPC_STATE_STARTED:
+ GNUNET_TESTBED_remove_opc_ (opc->c, opc);
+ /* no break; continue */
+ case OPC_STATE_INIT:
+ GNUNET_free (opc->data);
+ break;
+ case OPC_STATE_FINISHED:
+ break;
+ }
+ GNUNET_free (opc);
+}
+
+
+/**
+ * Stops and destroys all peers. Is equivalent of calling
+ * GNUNET_TESTBED_peer_stop() and GNUNET_TESTBED_peer_destroy() on all peers,
+ * except that the peer stop event and operation finished event corresponding to
+ * the respective functions are not generated. This function should be called
+ * when there are no other pending operations. If there are pending operations,
+ * it will return NULL
+ *
+ * @param c the controller to send this message to
+ * @param op_cls closure for the operation
+ * @param cb the callback to call when all peers are stopped and destroyed
+ * @param cb_cls the closure for the callback
+ * @return operation handle on success; NULL if any pending operations are
+ * present
+ */
+struct GNUNET_TESTBED_Operation *
+GNUNET_TESTBED_shutdown_peers (struct GNUNET_TESTBED_Controller *c,
+ void *op_cls,
+ GNUNET_TESTBED_OperationCompletionCallback cb,
+ void *cb_cls)
+{
+ struct OperationContext *opc;
+ struct ShutdownPeersData *data;
+
+ if (0 != GNUNET_CONTAINER_multihashmap32_size (c->opc_map))
+ return NULL;
+ data = GNUNET_new (struct ShutdownPeersData);
+ data->cb = cb;
+ data->cb_cls = cb_cls;
+ opc = GNUNET_new (struct OperationContext);
+ opc->c = c;
+ opc->op_cls = op_cls;
+ opc->data = data;
+ opc->id = GNUNET_TESTBED_get_next_op_id (c);
+ opc->type = OP_SHUTDOWN_PEERS;
+ opc->state = OPC_STATE_INIT;
+ opc->op = GNUNET_TESTBED_operation_create_ (opc, &opstart_shutdown_peers,
+ &oprelease_shutdown_peers);
+ GNUNET_TESTBED_operation_queue_insert_ (opc->c->opq_parallel_operations,
+ opc->op);
+ GNUNET_TESTBED_operation_begin_wait_ (opc->op);
+ return opc->op;
+}
+
+
+/**
+ * Return the index of the peer inside of the total peer array,
+ * aka. the peer's "unique ID".
+ *
+ * @param peer Peer handle.
+ *
+ * @return The peer's unique ID.
+ */
+uint32_t
+GNUNET_TESTBED_get_index (const struct GNUNET_TESTBED_Peer *peer)
+{
+ return peer->unique_id;
+}
+
+
+/**
+ * Remove a barrier and it was the last one in the barrier hash map, destroy the
+ * hash map
+ *
+ * @param barrier the barrier to remove
+ */
+void
+GNUNET_TESTBED_barrier_remove_ (struct GNUNET_TESTBED_Barrier *barrier)
+{
+ struct GNUNET_TESTBED_Controller *c = barrier->c;
+
+ GNUNET_assert (NULL != c->barrier_map); /* No barriers present */
+ GNUNET_assert (GNUNET_OK ==
+ GNUNET_CONTAINER_multihashmap_remove (c->barrier_map,
+ &barrier->key,
+ barrier));
+ GNUNET_free (barrier->name);
+ GNUNET_free (barrier);
+ if (0 == GNUNET_CONTAINER_multihashmap_size (c->barrier_map))
+ {
+ GNUNET_CONTAINER_multihashmap_destroy (c->barrier_map);
+ c->barrier_map = NULL;
+ }
+}
+
+
+/**
+ * Initialise a barrier and call the given callback when the required percentage
+ * of peers (quorum) reach the barrier OR upon 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
+ * @param echo GNUNET_YES to echo the barrier crossed status message back to the
+ * controller
+ * @return barrier handle; 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,
+ int echo)
+{
+ struct GNUNET_TESTBED_BarrierInit *msg;
+ struct GNUNET_MQ_Envelope *env;
+ struct GNUNET_TESTBED_Barrier *barrier;
+ struct GNUNET_HashCode key;
+ 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 == controller->barrier_map)
+ controller->barrier_map = GNUNET_CONTAINER_multihashmap_create (3, GNUNET_YES);
+ if (GNUNET_YES ==
+ GNUNET_CONTAINER_multihashmap_contains (controller->barrier_map,
+ &key))
+ {
+ GNUNET_break (0);
+ return NULL;
+ }
+ LOG_DEBUG ("Initialising barrier `%s'\n", name);
+ barrier = GNUNET_new (struct GNUNET_TESTBED_Barrier);
+ barrier->c = controller;
+ barrier->name = GNUNET_strdup (name);
+ barrier->cb = cb;
+ barrier->cls = cls;
+ barrier->echo = echo;
+ GNUNET_memcpy (&barrier->key, &key, sizeof (struct GNUNET_HashCode));
+ GNUNET_assert (GNUNET_OK ==
+ GNUNET_CONTAINER_multihashmap_put (controller->barrier_map,
+ &barrier->key,
+ barrier,
+ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST));
+
+ env = GNUNET_MQ_msg_extra (msg,
+ name_len,
+ GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_INIT);
+ msg->quorum = (uint8_t) quorum;
+ GNUNET_memcpy (msg->name,
+ barrier->name,
+ name_len);
+ GNUNET_MQ_send (barrier->c->mq,
+ env);
+ return barrier;
+}
+
+
+/**
+ * Initialise a barrier and call the given callback when the required percentage
+ * of peers (quorum) reach the barrier OR upon 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
+ */
+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)
+{
+ return GNUNET_TESTBED_barrier_init_ (controller,
+ name, quorum, cb, cls, GNUNET_YES);
+}
+
+
+/**
+ * Cancel a barrier.
+ *
+ * @param barrier the barrier handle
+ */
+void
+GNUNET_TESTBED_barrier_cancel (struct GNUNET_TESTBED_Barrier *barrier)
+{
+ struct GNUNET_MQ_Envelope *env;
+ struct GNUNET_TESTBED_BarrierCancel *msg;
+ size_t slen;
+
+ slen = strlen (barrier->name);
+ env = GNUNET_MQ_msg_extra (msg,
+ slen,
+ GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_CANCEL);
+ GNUNET_memcpy (msg->name,
+ barrier->name,
+ slen);
+ GNUNET_MQ_send (barrier->c->mq,
+ env);
+ GNUNET_TESTBED_barrier_remove_ (barrier);
+}
+
+