2 This file is part of GNUnet
3 (C) 2008--2013 Christian Grothoff (and other contributing authors)
5 GNUnet is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published
7 by the Free Software Foundation; either version 3, or (at your
8 option) any later version.
10 GNUnet is distributed in the hope that it will be useful, but
11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with GNUnet; see the file COPYING. If not, write to the
17 Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18 Boston, MA 02111-1307, USA.
22 * @file testbed/testbed_api.c
23 * @brief API for accessing the GNUnet testing service.
24 * This library is supposed to make it easier to write
25 * testcases and script large-scale benchmarks.
26 * @author Christian Grothoff
27 * @author Sree Harsha Totakura
32 #include "gnunet_testbed_service.h"
33 #include "gnunet_core_service.h"
34 #include "gnunet_constants.h"
35 #include "gnunet_transport_service.h"
36 #include "gnunet_hello_lib.h"
40 #include "testbed_api.h"
41 #include "testbed_api_hosts.h"
42 #include "testbed_api_peers.h"
43 #include "testbed_api_operations.h"
44 #include "testbed_api_sd.h"
47 * Generic logging shorthand
49 #define LOG(kind, ...) \
50 GNUNET_log_from (kind, "testbed-api", __VA_ARGS__)
55 #define LOG_DEBUG(...) \
56 LOG (GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__)
59 * Relative time seconds shorthand
61 #define TIME_REL_SECS(sec) \
62 GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, sec)
66 * Default server message sending retry timeout
68 #define TIMEOUT_REL TIME_REL_SECS(1)
72 * The message queue for sending messages to the controller service
77 * The message to be sent
79 struct GNUNET_MessageHeader *msg;
82 * next pointer for DLL
84 struct MessageQueue *next;
87 * prev pointer for DLL
89 struct MessageQueue *prev;
94 * Context data for forwarded Operation
96 struct ForwardedOperationData
100 * The callback to call when reply is available
102 GNUNET_CLIENT_MessageHandler cc;
105 * The closure for the above callback
113 * Context data for get slave config operations
115 struct GetSlaveConfigData
118 * The id of the slave controller
126 * Context data for controller link operations
128 struct ControllerLinkData
131 * The controller link message
133 struct GNUNET_TESTBED_ControllerLinkRequest *msg;
136 * The id of the host which is hosting the controller to be linked
144 * Date context for OP_SHUTDOWN_PEERS operations
146 struct ShutdownPeersData
149 * The operation completion callback to call
151 GNUNET_TESTBED_OperationCompletionCallback cb;
154 * The closure for the above callback
161 * An entry in the stack for keeping operations which are about to expire
163 struct ExpireOperationEntry
166 * DLL head; new entries are to be inserted here
168 struct ExpireOperationEntry *next;
171 * DLL tail; entries are deleted from here
173 struct ExpireOperationEntry *prev;
176 * The operation. This will be a dangling pointer when the operation is freed
178 const struct GNUNET_TESTBED_Operation *op;
183 * DLL head for list of operations marked for expiry
185 static struct ExpireOperationEntry *exop_head;
188 * DLL tail for list of operation marked for expiry
190 static struct ExpireOperationEntry *exop_tail;
194 * Inserts an operation into the list of operations marked for expiry
196 * @param op the operation to insert
199 exop_insert (struct GNUNET_TESTBED_Operation *op)
201 struct ExpireOperationEntry *entry;
203 entry = GNUNET_malloc (sizeof (struct ExpireOperationEntry));
205 GNUNET_CONTAINER_DLL_insert_tail (exop_head, exop_tail, entry);
210 * Checks if an operation is present in the list of operations marked for
211 * expiry. If the operation is found, it and the tail of operations after it
212 * are removed from the list.
214 * @param op the operation to check
215 * @return GNUNET_NO if the operation is not present in the list; GNUNET_YES if
216 * the operation is found in the list (the operation is then removed
217 * from the list -- calling this function again with the same
218 * paramenter will return GNUNET_NO)
221 exop_check (const struct GNUNET_TESTBED_Operation *const op)
223 struct ExpireOperationEntry *entry;
224 struct ExpireOperationEntry *entry2;
229 while (NULL != entry)
238 if (GNUNET_NO == found)
240 /* Truncate the tail */
241 while (NULL != entry)
243 entry2 = entry->next;
244 GNUNET_CONTAINER_DLL_remove (exop_head, exop_tail, entry);
253 * Context information to be used while searching for operation contexts
258 * The result of the search
260 struct OperationContext *opc;
263 * The id of the operation context we are searching for
270 * Search iterator for searching an operation context
272 * @param cls the serach context
273 * @param key current key code
274 * @param value value in the hash map
275 * @return GNUNET_YES if we should continue to
280 opc_search_iterator (void *cls, uint32_t key, void *value)
282 struct SearchContext *sc = cls;
283 struct OperationContext *opc = value;
285 GNUNET_assert (NULL != opc);
286 GNUNET_assert (NULL == sc->opc);
287 if (opc->id != sc->id)
295 * Returns the operation context with the given id if found in the Operation
296 * context queues of the controller
298 * @param c the controller whose operation context map is searched
299 * @param id the id which has to be checked
300 * @return the matching operation context; NULL if no match found
302 static struct OperationContext *
303 find_opc (const struct GNUNET_TESTBED_Controller *c, const uint64_t id)
305 struct SearchContext sc;
309 GNUNET_assert (NULL != c->opc_map);
311 GNUNET_CONTAINER_multihashmap32_get_multiple (c->opc_map, (uint32_t) id,
312 &opc_search_iterator, &sc))
319 * Inserts the given operation context into the operation context map of the
320 * given controller. Creates the operation context map if one does not exist
323 * @param c the controller
324 * @param opc the operation context to be inserted
327 GNUNET_TESTBED_insert_opc_ (struct GNUNET_TESTBED_Controller *c,
328 struct OperationContext *opc)
330 if (NULL == c->opc_map)
331 c->opc_map = GNUNET_CONTAINER_multihashmap32_create (256);
332 GNUNET_assert (GNUNET_OK ==
333 GNUNET_CONTAINER_multihashmap32_put (c->opc_map,
334 (uint32_t) opc->id, opc,
335 GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
340 * Removes the given operation context from the operation context map of the
343 * @param c the controller
344 * @param opc the operation context to remove
347 GNUNET_TESTBED_remove_opc_ (const struct GNUNET_TESTBED_Controller *c,
348 struct OperationContext *opc)
350 GNUNET_assert (NULL != c->opc_map);
351 GNUNET_assert (GNUNET_YES ==
352 GNUNET_CONTAINER_multihashmap32_remove (c->opc_map,
359 * Handler for forwarded operations
361 * @param c the controller handle
362 * @param opc the opearation context
363 * @param msg the message
366 handle_forwarded_operation_msg (struct GNUNET_TESTBED_Controller *c,
367 struct OperationContext *opc,
368 const struct GNUNET_MessageHeader *msg)
370 struct ForwardedOperationData *fo_data;
373 if (NULL != fo_data->cc)
374 fo_data->cc (fo_data->cc_cls, msg);
375 GNUNET_TESTBED_remove_opc_ (c, opc);
376 GNUNET_free (fo_data);
382 * Handler for GNUNET_MESSAGE_TYPE_TESTBED_ADDHOSTCONFIRM message from
383 * controller (testbed service)
385 * @param c the controller handler
386 * @param msg message received
387 * @return GNUNET_YES if we can continue receiving from service; GNUNET_NO if
391 handle_opsuccess (struct GNUNET_TESTBED_Controller *c,
393 GNUNET_TESTBED_GenericOperationSuccessEventMessage *msg)
395 struct OperationContext *opc;
396 GNUNET_TESTBED_OperationCompletionCallback op_comp_cb;
397 void *op_comp_cb_cls;
398 struct GNUNET_TESTBED_EventInformation event;
401 op_id = GNUNET_ntohll (msg->operation_id);
402 LOG_DEBUG ("Operation %lu successful\n", op_id);
403 if (NULL == (opc = find_opc (c, op_id)))
405 LOG_DEBUG ("Operation not found\n");
408 event.type = GNUNET_TESTBED_ET_OPERATION_FINISHED;
410 event.op_cls = opc->op_cls;
411 event.details.operation_finished.emsg = NULL;
412 event.details.operation_finished.generic = NULL;
414 op_comp_cb_cls = NULL;
419 handle_forwarded_operation_msg (c, opc,
420 (const struct GNUNET_MessageHeader *) msg);
424 case OP_PEER_DESTROY:
426 struct GNUNET_TESTBED_Peer *peer;
429 GNUNET_TESTBED_peer_deregister_ (peer);
435 case OP_SHUTDOWN_PEERS:
437 struct ShutdownPeersData *data;
440 op_comp_cb = data->cb;
441 op_comp_cb_cls = data->cb_cls;
444 GNUNET_TESTBED_cleanup_peers_ ();
447 case OP_MANAGE_SERVICE:
449 struct ManageServiceData *data;
451 GNUNET_assert (NULL != (data = opc->data));
452 op_comp_cb = data->cb;
453 op_comp_cb_cls = data->cb_cls;
461 GNUNET_TESTBED_remove_opc_ (opc->c, opc);
462 opc->state = OPC_STATE_FINISHED;
463 exop_insert (event.op);
464 if (0 != (c->event_mask & (1L << GNUNET_TESTBED_ET_OPERATION_FINISHED)))
467 c->cc (c->cc_cls, &event);
468 if (GNUNET_NO == exop_check (event.op))
472 LOG_DEBUG ("Not calling callback\n");
473 if (NULL != op_comp_cb)
474 op_comp_cb (op_comp_cb_cls, event.op, NULL);
475 /* You could have marked the operation as done by now */
476 GNUNET_break (GNUNET_NO == exop_check (event.op));
482 * Handler for GNUNET_MESSAGE_TYPE_TESTBED_PEERCREATESUCCESS message from
483 * controller (testbed service)
485 * @param c the controller handle
486 * @param msg message received
487 * @return GNUNET_YES if we can continue receiving from service; GNUNET_NO if
491 handle_peer_create_success (struct GNUNET_TESTBED_Controller *c,
493 GNUNET_TESTBED_PeerCreateSuccessEventMessage *msg)
495 struct OperationContext *opc;
496 struct PeerCreateData *data;
497 struct GNUNET_TESTBED_Peer *peer;
498 struct GNUNET_TESTBED_Operation *op;
499 GNUNET_TESTBED_PeerCreateCallback cb;
503 GNUNET_assert (sizeof (struct GNUNET_TESTBED_PeerCreateSuccessEventMessage) ==
504 ntohs (msg->header.size));
505 op_id = GNUNET_ntohll (msg->operation_id);
506 if (NULL == (opc = find_opc (c, op_id)))
508 LOG_DEBUG ("Operation context for PeerCreateSuccessEvent not found\n");
511 if (OP_FORWARDED == opc->type)
513 handle_forwarded_operation_msg (c, opc,
514 (const struct GNUNET_MessageHeader *) msg);
517 GNUNET_assert (OP_PEER_CREATE == opc->type);
518 GNUNET_assert (NULL != opc->data);
520 GNUNET_assert (NULL != data->peer);
522 GNUNET_assert (peer->unique_id == ntohl (msg->peer_id));
523 peer->state = PS_CREATED;
524 GNUNET_TESTBED_peer_register_ (peer);
528 GNUNET_free (opc->data);
529 GNUNET_TESTBED_remove_opc_ (opc->c, opc);
530 opc->state = OPC_STATE_FINISHED;
533 cb (cls, peer, NULL);
534 /* You could have marked the operation as done by now */
535 GNUNET_break (GNUNET_NO == exop_check (op));
541 * Handler for GNUNET_MESSAGE_TYPE_TESTBED_PEEREVENT message from
542 * controller (testbed service)
544 * @param c the controller handler
545 * @param msg message received
546 * @return GNUNET_YES if we can continue receiving from service; GNUNET_NO if
550 handle_peer_event (struct GNUNET_TESTBED_Controller *c,
551 const struct GNUNET_TESTBED_PeerEventMessage *msg)
553 struct OperationContext *opc;
554 struct GNUNET_TESTBED_Peer *peer;
555 struct PeerEventData *data;
556 GNUNET_TESTBED_PeerChurnCallback pcc;
558 struct GNUNET_TESTBED_EventInformation event;
561 GNUNET_assert (sizeof (struct GNUNET_TESTBED_PeerEventMessage) ==
562 ntohs (msg->header.size));
563 op_id = GNUNET_ntohll (msg->operation_id);
564 if (NULL == (opc = find_opc (c, op_id)))
566 LOG_DEBUG ("Operation not found\n");
569 if (OP_FORWARDED == opc->type)
571 handle_forwarded_operation_msg (c, opc,
572 (const struct GNUNET_MessageHeader *) msg);
575 GNUNET_assert ((OP_PEER_START == opc->type) || (OP_PEER_STOP == opc->type));
577 GNUNET_assert (NULL != data);
579 GNUNET_assert (NULL != peer);
580 event.type = (enum GNUNET_TESTBED_EventType) ntohl (msg->event_type);
582 event.op_cls = opc->op_cls;
585 case GNUNET_TESTBED_ET_PEER_START:
586 peer->state = PS_STARTED;
587 event.details.peer_start.host = peer->host;
588 event.details.peer_start.peer = peer;
590 case GNUNET_TESTBED_ET_PEER_STOP:
591 peer->state = PS_STOPPED;
592 event.details.peer_stop.peer = peer;
595 GNUNET_assert (0); /* We should never reach this state */
598 pcc_cls = data->pcc_cls;
600 GNUNET_TESTBED_remove_opc_ (opc->c, opc);
601 opc->state = OPC_STATE_FINISHED;
602 exop_insert (event.op);
604 ((GNUNET_TESTBED_ET_PEER_START | GNUNET_TESTBED_ET_PEER_STOP) &
608 c->cc (c->cc_cls, &event);
609 if (GNUNET_NO == exop_check (event.op))
614 /* You could have marked the operation as done by now */
615 GNUNET_break (GNUNET_NO == exop_check (event.op));
621 * Handler for GNUNET_MESSAGE_TYPE_TESTBED_PEERCONEVENT message from
622 * controller (testbed service)
624 * @param c the controller handler
625 * @param msg message received
626 * @return GNUNET_YES if we can continue receiving from service; GNUNET_NO if
630 handle_peer_conevent (struct GNUNET_TESTBED_Controller *c,
631 const struct GNUNET_TESTBED_ConnectionEventMessage *msg)
633 struct OperationContext *opc;
634 struct OverlayConnectData *data;
635 GNUNET_TESTBED_OperationCompletionCallback cb;
637 struct GNUNET_TESTBED_EventInformation event;
640 op_id = GNUNET_ntohll (msg->operation_id);
641 if (NULL == (opc = find_opc (c, op_id)))
643 LOG_DEBUG ("Operation not found\n");
646 if (OP_FORWARDED == opc->type)
648 handle_forwarded_operation_msg (c, opc,
649 (const struct GNUNET_MessageHeader *) msg);
652 GNUNET_assert (OP_OVERLAY_CONNECT == opc->type);
653 GNUNET_assert (NULL != (data = opc->data));
654 GNUNET_assert ((ntohl (msg->peer1) == data->p1->unique_id) &&
655 (ntohl (msg->peer2) == data->p2->unique_id));
656 event.type = (enum GNUNET_TESTBED_EventType) ntohl (msg->event_type);
658 event.op_cls = opc->op_cls;
661 case GNUNET_TESTBED_ET_CONNECT:
662 event.details.peer_connect.peer1 = data->p1;
663 event.details.peer_connect.peer2 = data->p2;
665 case GNUNET_TESTBED_ET_DISCONNECT:
666 GNUNET_assert (0); /* FIXME: implement */
669 GNUNET_assert (0); /* Should never reach here */
673 cb_cls = data->cb_cls;
674 GNUNET_TESTBED_remove_opc_ (opc->c, opc);
675 opc->state = OPC_STATE_FINISHED;
676 exop_insert (event.op);
678 ((GNUNET_TESTBED_ET_CONNECT | GNUNET_TESTBED_ET_DISCONNECT) &
682 c->cc (c->cc_cls, &event);
683 if (GNUNET_NO == exop_check (event.op))
687 cb (cb_cls, opc->op, NULL);
688 /* You could have marked the operation as done by now */
689 GNUNET_break (GNUNET_NO == exop_check (event.op));
695 * Handler for GNUNET_MESSAGE_TYPE_TESTBED_PEERCONFIG message from
696 * controller (testbed service)
698 * @param c the controller handler
699 * @param msg message received
700 * @return GNUNET_YES if we can continue receiving from service; GNUNET_NO if
704 handle_peer_config (struct GNUNET_TESTBED_Controller *c,
706 GNUNET_TESTBED_PeerConfigurationInformationMessage *msg)
708 struct OperationContext *opc;
709 struct GNUNET_TESTBED_Peer *peer;
710 struct PeerInfoData *data;
711 struct GNUNET_TESTBED_PeerInformation *pinfo;
712 GNUNET_TESTBED_PeerInfoCallback cb;
716 op_id = GNUNET_ntohll (msg->operation_id);
717 if (NULL == (opc = find_opc (c, op_id)))
719 LOG_DEBUG ("Operation not found\n");
722 if (OP_FORWARDED == opc->type)
724 handle_forwarded_operation_msg (c, opc,
725 (const struct GNUNET_MessageHeader *) msg);
729 GNUNET_assert (NULL != data);
731 GNUNET_assert (NULL != peer);
732 GNUNET_assert (ntohl (msg->peer_id) == peer->unique_id);
733 pinfo = GNUNET_malloc (sizeof (struct GNUNET_TESTBED_PeerInformation));
734 pinfo->pit = data->pit;
736 cb_cls = data->cb_cls;
737 GNUNET_assert (NULL != cb);
742 case GNUNET_TESTBED_PIT_IDENTITY:
743 pinfo->result.id = GNUNET_malloc (sizeof (struct GNUNET_PeerIdentity));
744 (void) memcpy (pinfo->result.id, &msg->peer_identity,
745 sizeof (struct GNUNET_PeerIdentity));
747 case GNUNET_TESTBED_PIT_CONFIGURATION:
748 pinfo->result.cfg = /* Freed in oprelease_peer_getinfo */
749 GNUNET_TESTBED_extract_config_ (&msg->header);
751 case GNUNET_TESTBED_PIT_GENERIC:
752 GNUNET_assert (0); /* never reach here */
756 GNUNET_TESTBED_remove_opc_ (opc->c, opc);
757 opc->state = OPC_STATE_FINISHED;
758 cb (cb_cls, opc->op, pinfo, NULL);
759 /* We dont check whether the operation is marked as done here as the
760 operation contains data (cfg/identify) which will be freed at a later point
767 * Handler for GNUNET_MESSAGE_TYPE_TESTBED_OPERATIONFAILEVENT message from
768 * controller (testbed service)
770 * @param c the controller handler
771 * @param msg message received
772 * @return GNUNET_YES if we can continue receiving from service; GNUNET_NO if
776 handle_op_fail_event (struct GNUNET_TESTBED_Controller *c,
777 const struct GNUNET_TESTBED_OperationFailureEventMessage
780 struct OperationContext *opc;
783 struct GNUNET_TESTBED_EventInformation event;
785 op_id = GNUNET_ntohll (msg->operation_id);
786 if (NULL == (opc = find_opc (c, op_id)))
788 LOG_DEBUG ("Operation not found\n");
791 if (OP_FORWARDED == opc->type)
793 handle_forwarded_operation_msg (c, opc,
794 (const struct GNUNET_MessageHeader *) msg);
797 GNUNET_TESTBED_remove_opc_ (opc->c, opc);
798 opc->state = OPC_STATE_FINISHED;
799 emsg = GNUNET_TESTBED_parse_error_string_ (msg);
801 emsg = "Unknown error";
802 if (OP_PEER_INFO == opc->type)
804 struct PeerInfoData *data;
807 if (NULL != data->cb)
808 data->cb (data->cb_cls, opc->op, NULL, emsg);
810 return GNUNET_YES; /* We do not call controller callback for peer info */
812 event.type = GNUNET_TESTBED_ET_OPERATION_FINISHED;
814 event.op_cls = opc->op_cls;
815 event.details.operation_finished.emsg = emsg;
816 event.details.operation_finished.generic = NULL;
817 if ((0 != (GNUNET_TESTBED_ET_OPERATION_FINISHED & c->event_mask)) &&
820 exop_insert (event.op);
821 c->cc (c->cc_cls, &event);
822 if (GNUNET_NO == exop_check (event.op))
829 struct PeerCreateData *data;
832 GNUNET_free (data->peer);
833 if (NULL != data->cb)
834 data->cb (data->cls, NULL, emsg);
841 struct PeerEventData *data;
844 if (NULL != data->pcc)
845 data->pcc (data->pcc_cls, emsg);
849 case OP_PEER_DESTROY:
853 case OP_OVERLAY_CONNECT:
855 struct OverlayConnectData *data;
858 data->failed = GNUNET_YES;
859 if (NULL != data->cb)
860 data->cb (data->cb_cls, opc->op, emsg);
865 case OP_LINK_CONTROLLERS: /* No secondary callback */
867 case OP_SHUTDOWN_PEERS:
869 struct ShutdownPeersData *data;
872 GNUNET_free (data); /* FIXME: Decide whether we call data->op_cb */
876 case OP_MANAGE_SERVICE:
878 struct ManageServiceData *data = opc->data;
879 GNUNET_TESTBED_OperationCompletionCallback cb;
882 GNUNET_assert (NULL != data);
884 cb_cls = data->cb_cls;
887 exop_insert (event.op);
889 cb (cb_cls, opc->op, emsg);
890 /* You could have marked the operation as done by now */
891 GNUNET_break (GNUNET_NO == exop_check (event.op));
902 * Function to build GET_SLAVE_CONFIG message
904 * @param op_id the id this message should contain in its operation id field
905 * @param slave_id the id this message should contain in its slave id field
906 * @return newly allocated SlaveGetConfigurationMessage
908 static struct GNUNET_TESTBED_SlaveGetConfigurationMessage *
909 GNUNET_TESTBED_generate_slavegetconfig_msg_ (uint64_t op_id, uint32_t slave_id)
911 struct GNUNET_TESTBED_SlaveGetConfigurationMessage *msg;
914 msize = sizeof (struct GNUNET_TESTBED_SlaveGetConfigurationMessage);
915 msg = GNUNET_malloc (msize);
916 msg->header.size = htons (msize);
918 htons (GNUNET_MESSAGE_TYPE_TESTBED_GET_SLAVE_CONFIGURATION);
919 msg->operation_id = GNUNET_htonll (op_id);
920 msg->slave_id = htonl (slave_id);
926 * Handler for GNUNET_MESSAGE_TYPE_TESTBED_SLAVECONFIG message from controller
929 * @param c the controller handler
930 * @param msg message received
931 * @return GNUNET_YES if we can continue receiving from service; GNUNET_NO if
935 handle_slave_config (struct GNUNET_TESTBED_Controller *c,
936 const struct GNUNET_TESTBED_SlaveConfiguration *msg)
938 struct OperationContext *opc;
940 struct GNUNET_TESTBED_EventInformation event;
942 op_id = GNUNET_ntohll (msg->operation_id);
943 if (NULL == (opc = find_opc (c, op_id)))
945 LOG_DEBUG ("Operation not found\n");
948 if (OP_GET_SLAVE_CONFIG != opc->type)
953 opc->state = OPC_STATE_FINISHED;
954 GNUNET_TESTBED_remove_opc_ (opc->c, opc);
955 if ((0 != (GNUNET_TESTBED_ET_OPERATION_FINISHED & c->event_mask)) &&
958 opc->data = GNUNET_TESTBED_extract_config_ (&msg->header);
959 event.type = GNUNET_TESTBED_ET_OPERATION_FINISHED;
961 event.op_cls = opc->op_cls;
962 event.details.operation_finished.generic = opc->data;
963 event.details.operation_finished.emsg = NULL;
964 c->cc (c->cc_cls, &event);
971 * Handler for GNUNET_MESSAGE_TYPE_TESTBED_SLAVECONFIG message from controller
974 * @param c the controller handler
975 * @param msg message received
976 * @return GNUNET_YES if we can continue receiving from service; GNUNET_NO if
980 handle_link_controllers_result (struct GNUNET_TESTBED_Controller *c,
982 GNUNET_TESTBED_ControllerLinkResponse *msg)
984 struct OperationContext *opc;
985 struct ControllerLinkData *data;
986 struct GNUNET_CONFIGURATION_Handle *cfg;
987 struct GNUNET_TESTBED_Host *host;
990 struct GNUNET_TESTBED_EventInformation event;
992 op_id = GNUNET_ntohll (msg->operation_id);
993 if (NULL == (opc = find_opc (c, op_id)))
995 LOG_DEBUG ("Operation not found\n");
998 if (OP_FORWARDED == opc->type)
1000 handle_forwarded_operation_msg (c, opc,
1001 (const struct GNUNET_MessageHeader *) msg);
1004 if (OP_LINK_CONTROLLERS != opc->type)
1009 GNUNET_assert (NULL != (data = opc->data));
1010 host = GNUNET_TESTBED_host_lookup_by_id_ (data->host_id);
1011 GNUNET_assert (NULL != host);
1014 opc->state = OPC_STATE_FINISHED;
1015 GNUNET_TESTBED_remove_opc_ (opc->c, opc);
1016 event.type = GNUNET_TESTBED_ET_OPERATION_FINISHED;
1018 event.op_cls = opc->op_cls;
1019 event.details.operation_finished.emsg = NULL;
1020 event.details.operation_finished.generic = NULL;
1023 if (GNUNET_NO == ntohs (msg->success))
1025 emsg = GNUNET_malloc (ntohs (msg->header.size)
1027 GNUNET_TESTBED_ControllerLinkResponse) + 1);
1028 memcpy (emsg, &msg[1], ntohs (msg->header.size)
1030 GNUNET_TESTBED_ControllerLinkResponse));
1031 event.details.operation_finished.emsg = emsg;
1035 if (0 != ntohs (msg->config_size))
1037 cfg = GNUNET_TESTBED_extract_config_ ((const struct GNUNET_MessageHeader *) msg);
1038 GNUNET_assert (NULL != cfg);
1039 GNUNET_TESTBED_host_replace_cfg_ (host, cfg);
1042 if (0 != (c->event_mask & (1L << GNUNET_TESTBED_ET_OPERATION_FINISHED)))
1045 c->cc (c->cc_cls, &event);
1048 LOG_DEBUG ("Not calling callback\n");
1050 GNUNET_CONFIGURATION_destroy (cfg);
1051 GNUNET_free_non_null (emsg);
1057 * Handler for messages from controller (testbed service)
1059 * @param cls the controller handler
1060 * @param msg message received, NULL on timeout or fatal error
1063 message_handler (void *cls, const struct GNUNET_MessageHeader *msg)
1065 struct GNUNET_TESTBED_Controller *c = cls;
1069 c->in_receive = GNUNET_NO;
1070 /* FIXME: Add checks for message integrity */
1073 LOG_DEBUG ("Receive timed out or connection to service dropped\n");
1077 msize = ntohs (msg->size);
1078 switch (ntohs (msg->type))
1080 case GNUNET_MESSAGE_TYPE_TESTBED_ADD_HOST_SUCCESS:
1081 GNUNET_assert (msize >=
1082 sizeof (struct GNUNET_TESTBED_HostConfirmedMessage));
1084 GNUNET_TESTBED_host_handle_addhostconfirm_
1085 (c, (const struct GNUNET_TESTBED_HostConfirmedMessage*) msg);
1087 case GNUNET_MESSAGE_TYPE_TESTBED_GENERIC_OPERATION_SUCCESS:
1088 GNUNET_assert (msize ==
1090 GNUNET_TESTBED_GenericOperationSuccessEventMessage));
1092 handle_opsuccess (c,
1094 GNUNET_TESTBED_GenericOperationSuccessEventMessage *)
1097 case GNUNET_MESSAGE_TYPE_TESTBED_OPERATION_FAIL_EVENT:
1098 GNUNET_assert (msize >=
1099 sizeof (struct GNUNET_TESTBED_OperationFailureEventMessage));
1101 handle_op_fail_event (c,
1103 GNUNET_TESTBED_OperationFailureEventMessage *)
1106 case GNUNET_MESSAGE_TYPE_TESTBED_CREATE_PEER_SUCCESS:
1107 GNUNET_assert (msize ==
1109 GNUNET_TESTBED_PeerCreateSuccessEventMessage));
1111 handle_peer_create_success (c,
1113 GNUNET_TESTBED_PeerCreateSuccessEventMessage
1116 case GNUNET_MESSAGE_TYPE_TESTBED_PEER_EVENT:
1117 GNUNET_assert (msize == sizeof (struct GNUNET_TESTBED_PeerEventMessage));
1119 handle_peer_event (c,
1120 (const struct GNUNET_TESTBED_PeerEventMessage *)
1124 case GNUNET_MESSAGE_TYPE_TESTBED_PEER_CONFIGURATION:
1125 GNUNET_assert (msize >=
1127 GNUNET_TESTBED_PeerConfigurationInformationMessage));
1129 handle_peer_config (c,
1131 GNUNET_TESTBED_PeerConfigurationInformationMessage
1134 case GNUNET_MESSAGE_TYPE_TESTBED_PEER_CONNECT_EVENT:
1135 GNUNET_assert (msize ==
1136 sizeof (struct GNUNET_TESTBED_ConnectionEventMessage));
1138 handle_peer_conevent (c,
1140 GNUNET_TESTBED_ConnectionEventMessage *) msg);
1142 case GNUNET_MESSAGE_TYPE_TESTBED_SLAVE_CONFIGURATION:
1143 GNUNET_assert (msize > sizeof (struct GNUNET_TESTBED_SlaveConfiguration));
1145 handle_slave_config (c,
1146 (const struct GNUNET_TESTBED_SlaveConfiguration *)
1149 case GNUNET_MESSAGE_TYPE_TESTBED_LINK_CONTROLLERS_RESULT:
1151 handle_link_controllers_result (c,
1153 GNUNET_TESTBED_ControllerLinkResponse
1159 if ((GNUNET_OK == status) && (GNUNET_NO == c->in_receive))
1161 c->in_receive = GNUNET_YES;
1162 GNUNET_CLIENT_receive (c->client, &message_handler, c,
1163 GNUNET_TIME_UNIT_FOREVER_REL);
1169 * Function called to notify a client about the connection begin ready to queue
1170 * more data. "buf" will be NULL and "size" zero if the connection was closed
1171 * for writing in the meantime.
1173 * @param cls closure
1174 * @param size number of bytes available in buf
1175 * @param buf where the callee should write the message
1176 * @return number of bytes written to buf
1179 transmit_ready_notify (void *cls, size_t size, void *buf)
1181 struct GNUNET_TESTBED_Controller *c = cls;
1182 struct MessageQueue *mq_entry;
1185 mq_entry = c->mq_head;
1186 GNUNET_assert (NULL != mq_entry);
1187 if ((0 == size) && (NULL == buf)) /* Timeout */
1189 LOG_DEBUG ("Message sending timed out -- retrying\n");
1191 GNUNET_CLIENT_notify_transmit_ready (c->client,
1192 ntohs (mq_entry->msg->size),
1193 TIMEOUT_REL, GNUNET_YES,
1194 &transmit_ready_notify, c);
1197 GNUNET_assert (ntohs (mq_entry->msg->size) <= size);
1198 size = ntohs (mq_entry->msg->size);
1199 memcpy (buf, mq_entry->msg, size);
1200 LOG_DEBUG ("Message of type: %u and size: %u sent\n",
1201 ntohs (mq_entry->msg->type), size);
1202 GNUNET_free (mq_entry->msg);
1203 GNUNET_CONTAINER_DLL_remove (c->mq_head, c->mq_tail, mq_entry);
1204 GNUNET_free (mq_entry);
1205 mq_entry = c->mq_head;
1206 if (NULL != mq_entry)
1208 GNUNET_CLIENT_notify_transmit_ready (c->client,
1209 ntohs (mq_entry->msg->size),
1210 TIMEOUT_REL, GNUNET_YES,
1211 &transmit_ready_notify, c);
1212 if (GNUNET_NO == c->in_receive)
1214 c->in_receive = GNUNET_YES;
1215 GNUNET_CLIENT_receive (c->client, &message_handler, c,
1216 GNUNET_TIME_UNIT_FOREVER_REL);
1223 * Queues a message in send queue for sending to the service
1225 * @param controller the handle to the controller
1226 * @param msg the message to queue
1229 GNUNET_TESTBED_queue_message_ (struct GNUNET_TESTBED_Controller *controller,
1230 struct GNUNET_MessageHeader *msg)
1232 struct MessageQueue *mq_entry;
1236 type = ntohs (msg->type);
1237 size = ntohs (msg->size);
1238 GNUNET_assert ((GNUNET_MESSAGE_TYPE_TESTBED_INIT <= type) &&
1239 (GNUNET_MESSAGE_TYPE_TESTBED_MAX > type));
1240 mq_entry = GNUNET_malloc (sizeof (struct MessageQueue));
1241 mq_entry->msg = msg;
1242 LOG (GNUNET_ERROR_TYPE_DEBUG,
1243 "Queueing message of type %u, size %u for sending\n", type,
1245 GNUNET_CONTAINER_DLL_insert_tail (controller->mq_head, controller->mq_tail,
1247 if (NULL == controller->th)
1249 GNUNET_CLIENT_notify_transmit_ready (controller->client, size,
1250 TIMEOUT_REL, GNUNET_YES,
1251 &transmit_ready_notify,
1257 * Sends the given message as an operation. The given callback is called when a
1258 * reply for the operation is available. Call
1259 * GNUNET_TESTBED_forward_operation_msg_cancel_() to cleanup the returned
1260 * operation context if the cc hasn't been called
1262 * @param controller the controller to which the message has to be sent
1263 * @param operation_id the operation id of the message
1264 * @param msg the message to send
1265 * @param cc the callback to call when reply is available
1266 * @param cc_cls the closure for the above callback
1267 * @return the operation context which can be used to cancel the forwarded
1270 struct OperationContext *
1271 GNUNET_TESTBED_forward_operation_msg_ (struct GNUNET_TESTBED_Controller
1272 *controller, uint64_t operation_id,
1273 const struct GNUNET_MessageHeader *msg,
1274 GNUNET_CLIENT_MessageHandler cc,
1277 struct OperationContext *opc;
1278 struct ForwardedOperationData *data;
1279 struct GNUNET_MessageHeader *dup_msg;
1282 data = GNUNET_malloc (sizeof (struct ForwardedOperationData));
1284 data->cc_cls = cc_cls;
1285 opc = GNUNET_malloc (sizeof (struct OperationContext));
1286 opc->c = controller;
1287 opc->type = OP_FORWARDED;
1289 opc->id = operation_id;
1290 msize = ntohs (msg->size);
1291 dup_msg = GNUNET_malloc (msize);
1292 (void) memcpy (dup_msg, msg, msize);
1293 GNUNET_TESTBED_queue_message_ (opc->c, dup_msg);
1294 GNUNET_TESTBED_insert_opc_ (controller, opc);
1300 * Function to cancel an operation created by simply forwarding an operation
1303 * @param opc the operation context from GNUNET_TESTBED_forward_operation_msg_()
1306 GNUNET_TESTBED_forward_operation_msg_cancel_ (struct OperationContext *opc)
1308 GNUNET_TESTBED_remove_opc_ (opc->c, opc);
1309 GNUNET_free (opc->data);
1315 * Function to call to start a link-controllers type operation once all queues
1316 * the operation is part of declare that the operation can be activated.
1318 * @param cls the closure from GNUNET_TESTBED_operation_create_()
1321 opstart_link_controllers (void *cls)
1323 struct OperationContext *opc = cls;
1324 struct ControllerLinkData *data;
1325 struct GNUNET_TESTBED_ControllerLinkRequest *msg;
1327 GNUNET_assert (NULL != opc->data);
1331 opc->state = OPC_STATE_STARTED;
1332 GNUNET_TESTBED_insert_opc_ (opc->c, opc);
1333 GNUNET_TESTBED_queue_message_ (opc->c, &msg->header);
1338 * Callback which will be called when link-controllers type operation is released
1340 * @param cls the closure from GNUNET_TESTBED_operation_create_()
1343 oprelease_link_controllers (void *cls)
1345 struct OperationContext *opc = cls;
1346 struct ControllerLinkData *data;
1351 case OPC_STATE_INIT:
1352 GNUNET_free (data->msg);
1354 case OPC_STATE_STARTED:
1355 GNUNET_TESTBED_remove_opc_ (opc->c, opc);
1357 case OPC_STATE_FINISHED:
1360 GNUNET_free_non_null (data);
1366 * Function to be called when get slave config operation is ready
1368 * @param cls the OperationContext of type OP_GET_SLAVE_CONFIG
1371 opstart_get_slave_config (void *cls)
1373 struct OperationContext *opc = cls;
1374 struct GetSlaveConfigData *data = opc->data;
1375 struct GNUNET_TESTBED_SlaveGetConfigurationMessage *msg;
1377 GNUNET_assert (NULL != data);
1378 msg = GNUNET_TESTBED_generate_slavegetconfig_msg_ (opc->id, data->slave_id);
1379 GNUNET_free (opc->data);
1382 GNUNET_TESTBED_insert_opc_ (opc->c, opc);
1383 GNUNET_TESTBED_queue_message_ (opc->c, &msg->header);
1384 opc->state = OPC_STATE_STARTED;
1389 * Function to be called when get slave config operation is cancelled or finished
1391 * @param cls the OperationContext of type OP_GET_SLAVE_CONFIG
1394 oprelease_get_slave_config (void *cls)
1396 struct OperationContext *opc = cls;
1400 case OPC_STATE_INIT:
1401 GNUNET_free (opc->data);
1403 case OPC_STATE_STARTED:
1404 GNUNET_TESTBED_remove_opc_ (opc->c, opc);
1406 case OPC_STATE_FINISHED:
1407 if (NULL != opc->data)
1408 GNUNET_CONFIGURATION_destroy (opc->data);
1416 * Start a controller process using the given configuration at the
1419 * @param host host to run the controller on; This should be the same host if
1420 * the controller was previously started with
1421 * GNUNET_TESTBED_controller_start()
1422 * @param event_mask bit mask with set of events to call 'cc' for;
1423 * or-ed values of "1LL" shifted by the
1424 * respective 'enum GNUNET_TESTBED_EventType'
1425 * (i.e. "(1LL << GNUNET_TESTBED_ET_CONNECT) | ...")
1426 * @param cc controller callback to invoke on events
1427 * @param cc_cls closure for cc
1428 * @return handle to the controller
1430 struct GNUNET_TESTBED_Controller *
1431 GNUNET_TESTBED_controller_connect (struct GNUNET_TESTBED_Host *host,
1432 uint64_t event_mask,
1433 GNUNET_TESTBED_ControllerCallback cc,
1436 struct GNUNET_TESTBED_Controller *controller;
1437 struct GNUNET_TESTBED_InitMessage *msg;
1438 const struct GNUNET_CONFIGURATION_Handle *cfg;
1439 const char *controller_hostname;
1440 unsigned long long max_parallel_operations;
1441 unsigned long long max_parallel_service_connections;
1442 unsigned long long max_parallel_topology_config_operations;
1444 GNUNET_assert (NULL != (cfg = GNUNET_TESTBED_host_get_cfg_ (host)));
1446 GNUNET_CONFIGURATION_get_value_number (cfg, "testbed",
1447 "MAX_PARALLEL_OPERATIONS",
1448 &max_parallel_operations))
1454 GNUNET_CONFIGURATION_get_value_number (cfg, "testbed",
1455 "MAX_PARALLEL_SERVICE_CONNECTIONS",
1456 &max_parallel_service_connections))
1462 GNUNET_CONFIGURATION_get_value_number (cfg, "testbed",
1463 "MAX_PARALLEL_TOPOLOGY_CONFIG_OPERATIONS",
1464 &max_parallel_topology_config_operations))
1469 controller = GNUNET_malloc (sizeof (struct GNUNET_TESTBED_Controller));
1470 controller->cc = cc;
1471 controller->cc_cls = cc_cls;
1472 controller->event_mask = event_mask;
1473 controller->cfg = GNUNET_CONFIGURATION_dup (cfg);
1474 controller->client = GNUNET_CLIENT_connect ("testbed", controller->cfg);
1475 if (NULL == controller->client)
1477 GNUNET_TESTBED_controller_disconnect (controller);
1480 GNUNET_TESTBED_mark_host_registered_at_ (host, controller);
1481 controller->host = host;
1482 controller->opq_parallel_operations =
1483 GNUNET_TESTBED_operation_queue_create_ ((unsigned int)
1484 max_parallel_operations);
1485 controller->opq_parallel_service_connections =
1486 GNUNET_TESTBED_operation_queue_create_ ((unsigned int)
1487 max_parallel_service_connections);
1488 controller->opq_parallel_topology_config_operations =
1489 GNUNET_TESTBED_operation_queue_create_ ((unsigned int)
1490 max_parallel_topology_config_operations);
1491 controller_hostname = GNUNET_TESTBED_host_get_hostname (host);
1492 if (NULL == controller_hostname)
1493 controller_hostname = "127.0.0.1";
1495 GNUNET_malloc (sizeof (struct GNUNET_TESTBED_InitMessage) +
1496 strlen (controller_hostname) + 1);
1497 msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_INIT);
1499 htons (sizeof (struct GNUNET_TESTBED_InitMessage) +
1500 strlen (controller_hostname) + 1);
1501 msg->host_id = htonl (GNUNET_TESTBED_host_get_id_ (host));
1502 msg->event_mask = GNUNET_htonll (controller->event_mask);
1503 strcpy ((char *) &msg[1], controller_hostname);
1504 GNUNET_TESTBED_queue_message_ (controller,
1505 (struct GNUNET_MessageHeader *) msg);
1511 * Configure shared services at a controller. Using this function,
1512 * you can specify that certain services (such as "resolver")
1513 * should not be run for each peer but instead be shared
1514 * across N peers on the specified host. This function
1515 * must be called before any peers are created at the host.
1517 * @param controller controller to configure
1518 * @param service_name name of the service to share
1519 * @param num_peers number of peers that should share one instance
1520 * of the specified service (1 for no sharing is the default),
1521 * use 0 to disable the service
1524 GNUNET_TESTBED_controller_configure_sharing (struct GNUNET_TESTBED_Controller
1526 const char *service_name,
1529 struct GNUNET_TESTBED_ConfigureSharedServiceMessage *msg;
1530 uint16_t service_name_size;
1533 service_name_size = strlen (service_name) + 1;
1535 sizeof (struct GNUNET_TESTBED_ConfigureSharedServiceMessage) +
1537 msg = GNUNET_malloc (msg_size);
1538 msg->header.size = htons (msg_size);
1539 msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_SHARE_SERVICE);
1540 msg->host_id = htonl (GNUNET_TESTBED_host_get_id_ (controller->host));
1541 msg->num_peers = htonl (num_peers);
1542 memcpy (&msg[1], service_name, service_name_size);
1543 GNUNET_TESTBED_queue_message_ (controller,
1544 (struct GNUNET_MessageHeader *) msg);
1545 GNUNET_break (0); /* This function is not yet implemented on the
1546 * testbed service */
1551 * Iterator to free opc map entries
1553 * @param cls closure
1554 * @param key current key code
1555 * @param value value in the hash map
1556 * @return GNUNET_YES if we should continue to
1561 opc_free_iterator (void *cls, uint32_t key, void *value)
1563 struct GNUNET_CONTAINER_MultiHashMap32 *map = cls;
1564 struct OperationContext *opc = value;
1566 GNUNET_assert (NULL != opc);
1569 GNUNET_assert (GNUNET_YES ==
1570 GNUNET_CONTAINER_multihashmap32_remove (map, key, value));
1576 * Stop the given controller (also will terminate all peers and
1577 * controllers dependent on this controller). This function
1578 * blocks until the testbed has been fully terminated (!).
1580 * @param c handle to controller to stop
1583 GNUNET_TESTBED_controller_disconnect (struct GNUNET_TESTBED_Controller
1586 struct MessageQueue *mq_entry;
1589 GNUNET_CLIENT_notify_transmit_ready_cancel (c->th);
1590 /* Clear the message queue */
1591 while (NULL != (mq_entry = c->mq_head))
1593 GNUNET_CONTAINER_DLL_remove (c->mq_head, c->mq_tail,
1595 GNUNET_free (mq_entry->msg);
1596 GNUNET_free (mq_entry);
1598 if (NULL != c->client)
1599 GNUNET_CLIENT_disconnect (c->client);
1600 if (NULL != c->host)
1601 GNUNET_TESTBED_deregister_host_at_ (c->host, c);
1602 GNUNET_CONFIGURATION_destroy (c->cfg);
1603 GNUNET_TESTBED_operation_queue_destroy_ (c->opq_parallel_operations);
1604 GNUNET_TESTBED_operation_queue_destroy_
1605 (c->opq_parallel_service_connections);
1606 GNUNET_TESTBED_operation_queue_destroy_
1607 (c->opq_parallel_topology_config_operations);
1608 if (NULL != c->opc_map)
1610 GNUNET_assert (GNUNET_SYSERR !=
1611 GNUNET_CONTAINER_multihashmap32_iterate (c->opc_map,
1614 GNUNET_assert (0 == GNUNET_CONTAINER_multihashmap32_size (c->opc_map));
1615 GNUNET_CONTAINER_multihashmap32_destroy (c->opc_map);
1622 * Compresses given configuration using zlib compress
1624 * @param config the serialized configuration
1625 * @param size the size of config
1626 * @param xconfig will be set to the compressed configuration (memory is fresly
1628 * @return the size of the xconfig
1631 GNUNET_TESTBED_compress_config_ (const char *config, size_t size,
1636 xsize = compressBound ((uLong) size);
1637 *xconfig = GNUNET_malloc (xsize);
1638 GNUNET_assert (Z_OK ==
1639 compress2 ((Bytef *) * xconfig, (uLongf *) & xsize,
1640 (const Bytef *) config, (uLongf) size,
1647 * Function to serialize and compress using zlib a configuration through a
1648 * configuration handle
1650 * @param cfg the configuration
1651 * @param size the size of configuration when serialize. Will be set on success.
1652 * @param xsize the sizeo of the compressed configuration. Will be set on success.
1653 * @return the serialized and compressed configuration
1656 GNUNET_TESTBED_compress_cfg_ (const struct GNUNET_CONFIGURATION_Handle *cfg,
1657 size_t *size, size_t *xsize)
1664 config = GNUNET_CONFIGURATION_serialize (cfg, &size_);
1665 xsize_ = GNUNET_TESTBED_compress_config_ (config, size_, &xconfig);
1666 GNUNET_free (config);
1674 * Create a link from slave controller to delegated controller. Whenever the
1675 * master controller is asked to start a peer at the delegated controller the
1676 * request will be routed towards slave controller (if a route exists). The
1677 * slave controller will then route it to the delegated controller. The
1678 * configuration of the delegated controller is given and is used to either
1679 * create the delegated controller or to connect to an existing controller. Note
1680 * that while starting the delegated controller the configuration will be
1681 * modified to accommodate available free ports. the 'is_subordinate' specifies
1682 * if the given delegated controller should be started and managed by the slave
1683 * controller, or if the delegated controller already has a master and the slave
1684 * controller connects to it as a non master controller. The success or failure
1685 * of this operation will be signalled through the
1686 * GNUNET_TESTBED_ControllerCallback() with an event of type
1687 * GNUNET_TESTBED_ET_OPERATION_FINISHED
1689 * @param op_cls the operation closure for the event which is generated to
1690 * signal success or failure of this operation
1691 * @param master handle to the master controller who creates the association
1692 * @param delegated_host requests to which host should be delegated; cannot be NULL
1693 * @param slave_host which host is used to run the slave controller; use NULL to
1694 * make the master controller connect to the delegated host
1695 * @param slave_cfg configuration to use for the slave controller
1696 * @param is_subordinate GNUNET_YES if the controller at delegated_host should
1697 * be started by the slave controller; GNUNET_NO if the slave
1698 * controller has to connect to the already started delegated
1699 * controller via TCP/IP
1700 * @return the operation handle
1702 struct GNUNET_TESTBED_Operation *
1703 GNUNET_TESTBED_controller_link (void *op_cls,
1704 struct GNUNET_TESTBED_Controller *master,
1705 struct GNUNET_TESTBED_Host *delegated_host,
1706 struct GNUNET_TESTBED_Host *slave_host,
1707 const struct GNUNET_CONFIGURATION_Handle
1708 *slave_cfg, int is_subordinate)
1710 struct OperationContext *opc;
1711 struct GNUNET_TESTBED_ControllerLinkRequest *msg;
1712 struct ControllerLinkData *data;
1713 uint32_t slave_host_id;
1714 uint32_t delegated_host_id;
1717 GNUNET_assert (GNUNET_YES ==
1718 GNUNET_TESTBED_is_host_registered_ (delegated_host, master));
1720 GNUNET_TESTBED_host_get_id_ ((NULL !=
1721 slave_host) ? slave_host : master->host);
1722 delegated_host_id = GNUNET_TESTBED_host_get_id_ (delegated_host);
1723 if ((NULL != slave_host) && (0 != slave_host_id))
1724 GNUNET_assert (GNUNET_YES ==
1725 GNUNET_TESTBED_is_host_registered_ (slave_host, master));
1726 msg_size = sizeof (struct GNUNET_TESTBED_ControllerLinkRequest);
1727 msg = GNUNET_malloc (msg_size);
1728 msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_LINK_CONTROLLERS);
1729 msg->header.size = htons (msg_size);
1730 msg->delegated_host_id = htonl (delegated_host_id);
1731 msg->slave_host_id = htonl (slave_host_id);
1732 msg->is_subordinate = (GNUNET_YES == is_subordinate) ? 1 : 0;data = GNUNET_malloc (sizeof (struct ControllerLinkData));
1734 data->host_id = delegated_host_id;
1735 opc = GNUNET_malloc (sizeof (struct OperationContext));
1738 opc->type = OP_LINK_CONTROLLERS;
1739 opc->id = GNUNET_TESTBED_get_next_op_id (opc->c);
1740 opc->state = OPC_STATE_INIT;
1741 opc->op_cls = op_cls;
1742 msg->operation_id = GNUNET_htonll (opc->id);
1744 GNUNET_TESTBED_operation_create_ (opc, &opstart_link_controllers,
1745 &oprelease_link_controllers);
1746 GNUNET_TESTBED_operation_queue_insert_ (master->opq_parallel_operations,
1748 GNUNET_TESTBED_operation_begin_wait_ (opc->op);
1754 * Like GNUNET_TESTBED_get_slave_config(), however without the host registration
1755 * check. Another difference is that this function takes the id of the slave
1758 * @param op_cls the closure for the operation
1759 * @param master the handle to master controller
1760 * @param slave_host_id id of the host where the slave controller is running to
1761 * the slave_host should remain valid until this operation is cancelled
1762 * or marked as finished
1763 * @return the operation handle;
1765 struct GNUNET_TESTBED_Operation *
1766 GNUNET_TESTBED_get_slave_config_ (void *op_cls,
1767 struct GNUNET_TESTBED_Controller *master,
1768 uint32_t slave_host_id)
1770 struct OperationContext *opc;
1771 struct GetSlaveConfigData *data;
1773 data = GNUNET_malloc (sizeof (struct GetSlaveConfigData));
1774 data->slave_id = slave_host_id;
1775 opc = GNUNET_malloc (sizeof (struct OperationContext));
1776 opc->state = OPC_STATE_INIT;
1778 opc->id = GNUNET_TESTBED_get_next_op_id (master);
1779 opc->type = OP_GET_SLAVE_CONFIG;
1781 opc->op_cls = op_cls;
1783 GNUNET_TESTBED_operation_create_ (opc, &opstart_get_slave_config,
1784 &oprelease_get_slave_config);
1785 GNUNET_TESTBED_operation_queue_insert_ (master->opq_parallel_operations,
1787 GNUNET_TESTBED_operation_begin_wait_ (opc->op);
1793 * Function to acquire the configuration of a running slave controller. The
1794 * completion of the operation is signalled through the controller_cb from
1795 * GNUNET_TESTBED_controller_connect(). If the operation is successful the
1796 * handle to the configuration is available in the generic pointer of
1797 * operation_finished field of struct GNUNET_TESTBED_EventInformation.
1799 * @param op_cls the closure for the operation
1800 * @param master the handle to master controller
1801 * @param slave_host the host where the slave controller is running; the handle
1802 * to the slave_host should remain valid until this operation is
1803 * cancelled or marked as finished
1804 * @return the operation handle; NULL if the slave_host is not registered at
1807 struct GNUNET_TESTBED_Operation *
1808 GNUNET_TESTBED_get_slave_config (void *op_cls,
1809 struct GNUNET_TESTBED_Controller *master,
1810 struct GNUNET_TESTBED_Host *slave_host)
1812 if (GNUNET_NO == GNUNET_TESTBED_is_host_registered_ (slave_host, master))
1814 return GNUNET_TESTBED_get_slave_config_ (op_cls, master,
1815 GNUNET_TESTBED_host_get_id_
1821 * Ask the testbed controller to write the current overlay topology to
1822 * a file. Naturally, the file will only contain a snapshot as the
1823 * topology may evolve all the time.
1825 * @param controller overlay controller to inspect
1826 * @param filename name of the file the topology should
1830 GNUNET_TESTBED_overlay_write_topology_to_file (struct GNUNET_TESTBED_Controller
1832 const char *filename)
1839 * Creates a helper initialization message. This function is here because we
1840 * want to use this in testing
1842 * @param trusted_ip the ip address of the controller which will be set as TRUSTED
1843 * HOST(all connections form this ip are permitted by the testbed) when
1844 * starting testbed controller at host. This can either be a single ip
1845 * address or a network address in CIDR notation.
1846 * @param hostname the hostname of the destination this message is intended for
1847 * @param cfg the configuration that has to used to start the testbed service
1849 * @return the initialization message
1851 struct GNUNET_TESTBED_HelperInit *
1852 GNUNET_TESTBED_create_helper_init_msg_ (const char *trusted_ip,
1853 const char *hostname,
1854 const struct GNUNET_CONFIGURATION_Handle
1857 struct GNUNET_TESTBED_HelperInit *msg;
1861 size_t xconfig_size;
1862 uint16_t trusted_ip_len;
1863 uint16_t hostname_len;
1866 config = GNUNET_CONFIGURATION_serialize (cfg, &config_size);
1867 GNUNET_assert (NULL != config);
1869 GNUNET_TESTBED_compress_config_ (config, config_size, &xconfig);
1870 GNUNET_free (config);
1871 trusted_ip_len = strlen (trusted_ip);
1872 hostname_len = (NULL == hostname) ? 0 : strlen (hostname);
1874 xconfig_size + trusted_ip_len + 1 +
1875 sizeof (struct GNUNET_TESTBED_HelperInit);
1876 msg_size += hostname_len;
1877 msg = GNUNET_realloc (xconfig, msg_size);
1878 (void) memmove (((void *) &msg[1]) + trusted_ip_len + 1 + hostname_len, msg,
1880 msg->header.size = htons (msg_size);
1881 msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_HELPER_INIT);
1882 msg->trusted_ip_size = htons (trusted_ip_len);
1883 msg->hostname_size = htons (hostname_len);
1884 msg->config_size = htons (config_size);
1885 (void) strcpy ((char *) &msg[1], trusted_ip);
1886 if (0 != hostname_len)
1887 (void) strncpy (((char *) &msg[1]) + trusted_ip_len + 1, hostname,
1894 * Signal that the information from an operation has been fully
1895 * processed. This function MUST be called for each event
1896 * of type 'operation_finished' to fully remove the operation
1897 * from the operation queue. After calling this function, the
1898 * 'op_result' becomes invalid (!).
1900 * @param operation operation to signal completion for
1903 GNUNET_TESTBED_operation_done (struct GNUNET_TESTBED_Operation *operation)
1905 (void) exop_check (operation);
1906 GNUNET_TESTBED_operation_release_ (operation);
1911 * Generates configuration by uncompressing configuration in given message. The
1912 * given message should be of the following types:
1913 * GNUNET_MESSAGE_TYPE_TESTBED_PEER_CONFIGURATION,
1914 * GNUNET_MESSAGE_TYPE_TESTBED_SLAVE_CONFIGURATION,
1915 * GNUNET_MESSAGE_TYPE_TESTBED_ADD_HOST,
1916 * GNUNET_MESSAGE_TYPE_TESTBED_LINK_CONTROLLERS,
1917 * GNUNET_MESSAGE_TYPE_TESTBED_LINK_CONTROLLERS_RESULT,
1919 * @param msg the message containing compressed configuration
1920 * @return handle to the parsed configuration; NULL upon error while parsing the message
1922 struct GNUNET_CONFIGURATION_Handle *
1923 GNUNET_TESTBED_extract_config_ (const struct GNUNET_MessageHeader *msg)
1925 struct GNUNET_CONFIGURATION_Handle *cfg;
1932 switch (ntohs (msg->type))
1934 case GNUNET_MESSAGE_TYPE_TESTBED_PEER_CONFIGURATION:
1936 const struct GNUNET_TESTBED_PeerConfigurationInformationMessage *imsg;
1939 (const struct GNUNET_TESTBED_PeerConfigurationInformationMessage *) msg;
1940 data_len = (uLong) ntohs (imsg->config_size);
1942 ntohs (imsg->header.size) -
1943 sizeof (struct GNUNET_TESTBED_PeerConfigurationInformationMessage);
1944 xdata = (const Bytef *) &imsg[1];
1947 case GNUNET_MESSAGE_TYPE_TESTBED_SLAVE_CONFIGURATION:
1949 const struct GNUNET_TESTBED_SlaveConfiguration *imsg;
1951 imsg = (const struct GNUNET_TESTBED_SlaveConfiguration *) msg;
1952 data_len = (uLong) ntohs (imsg->config_size);
1954 ntohs (imsg->header.size) -
1955 sizeof (struct GNUNET_TESTBED_SlaveConfiguration);
1956 xdata = (const Bytef *) &imsg[1];
1959 case GNUNET_MESSAGE_TYPE_TESTBED_ADD_HOST:
1961 const struct GNUNET_TESTBED_AddHostMessage *imsg;
1964 imsg = (const struct GNUNET_TESTBED_AddHostMessage *) msg;
1965 data_len = (uLong) ntohs (imsg->config_size);
1966 osize = sizeof (struct GNUNET_TESTBED_AddHostMessage) +
1967 ntohs (imsg->username_length) + ntohs (imsg->hostname_length);
1968 xdata_len = ntohs (imsg->header.size) - osize;
1969 xdata = (const Bytef *) ((const void *) imsg + osize);
1972 case GNUNET_MESSAGE_TYPE_TESTBED_LINK_CONTROLLERS_RESULT:
1974 const struct GNUNET_TESTBED_ControllerLinkResponse *imsg;
1976 imsg = (const struct GNUNET_TESTBED_ControllerLinkResponse *) msg;
1977 data_len = ntohs (imsg->config_size);
1978 xdata_len = ntohs (imsg->header.size) -
1979 sizeof (const struct GNUNET_TESTBED_ControllerLinkResponse);
1980 xdata = (const Bytef *) &imsg[1];
1986 data = GNUNET_malloc (data_len);
1987 if (Z_OK != (ret = uncompress (data, &data_len, xdata, xdata_len)))
1990 GNUNET_break_op (0);
1993 cfg = GNUNET_CONFIGURATION_create ();
1995 GNUNET_CONFIGURATION_deserialize (cfg, (const char *) data,
2000 GNUNET_break_op (0);
2009 * Checks the integrity of the OperationFailureEventMessage and if good returns
2010 * the error message it contains.
2012 * @param msg the OperationFailureEventMessage
2013 * @return the error message
2016 GNUNET_TESTBED_parse_error_string_ (const struct
2017 GNUNET_TESTBED_OperationFailureEventMessage
2023 msize = ntohs (msg->header.size);
2024 if (sizeof (struct GNUNET_TESTBED_OperationFailureEventMessage) >= msize)
2026 msize -= sizeof (struct GNUNET_TESTBED_OperationFailureEventMessage);
2027 emsg = (const char *) &msg[1];
2028 if ('\0' != emsg[msize - 1])
2038 * Function to return the operation id for a controller. The operation id is
2039 * created from the controllers host id and its internal operation counter.
2041 * @param controller the handle to the controller whose operation id has to be incremented
2042 * @return the incremented operation id.
2045 GNUNET_TESTBED_get_next_op_id (struct GNUNET_TESTBED_Controller * controller)
2049 op_id = (uint64_t) GNUNET_TESTBED_host_get_id_ (controller->host);
2050 op_id = op_id << 32;
2051 op_id |= (uint64_t) controller->operation_counter++;
2057 * Function called when a shutdown peers operation is ready
2059 * @param cls the closure from GNUNET_TESTBED_operation_create_()
2062 opstart_shutdown_peers (void *cls)
2064 struct OperationContext *opc = cls;
2065 struct GNUNET_TESTBED_ShutdownPeersMessage *msg;
2067 opc->state = OPC_STATE_STARTED;
2068 msg = GNUNET_malloc (sizeof (struct GNUNET_TESTBED_ShutdownPeersMessage));
2070 htons (sizeof (struct GNUNET_TESTBED_ShutdownPeersMessage));
2071 msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_SHUTDOWN_PEERS);
2072 msg->operation_id = GNUNET_htonll (opc->id);
2073 GNUNET_TESTBED_insert_opc_ (opc->c, opc);
2074 GNUNET_TESTBED_queue_message_ (opc->c, &msg->header);
2079 * Callback which will be called when shutdown peers operation is released
2081 * @param cls the closure from GNUNET_TESTBED_operation_create_()
2084 oprelease_shutdown_peers (void *cls)
2086 struct OperationContext *opc = cls;
2090 case OPC_STATE_STARTED:
2091 GNUNET_TESTBED_remove_opc_ (opc->c, opc);
2092 /* no break; continue */
2093 case OPC_STATE_INIT:
2094 GNUNET_free (opc->data);
2096 case OPC_STATE_FINISHED:
2104 * Stops and destroys all peers. Is equivalent of calling
2105 * GNUNET_TESTBED_peer_stop() and GNUNET_TESTBED_peer_destroy() on all peers,
2106 * except that the peer stop event and operation finished event corresponding to
2107 * the respective functions are not generated. This function should be called
2108 * when there are no other pending operations. If there are pending operations,
2109 * it will return NULL
2111 * @param c the controller to send this message to
2112 * @param op_cls closure for the operation
2113 * @param cb the callback to call when all peers are stopped and destroyed
2114 * @param cb_cls the closure for the callback
2115 * @return operation handle on success; NULL if any pending operations are
2118 struct GNUNET_TESTBED_Operation *
2119 GNUNET_TESTBED_shutdown_peers (struct GNUNET_TESTBED_Controller *c,
2121 GNUNET_TESTBED_OperationCompletionCallback cb,
2124 struct OperationContext *opc;
2125 struct ShutdownPeersData *data;
2127 if (0 != GNUNET_CONTAINER_multihashmap32_size (c->opc_map))
2129 data = GNUNET_malloc (sizeof (struct ShutdownPeersData));
2131 data->cb_cls = cb_cls;
2132 opc = GNUNET_malloc (sizeof (struct OperationContext));
2134 opc->op_cls = op_cls;
2136 opc->id = GNUNET_TESTBED_get_next_op_id (c);
2137 opc->type = OP_SHUTDOWN_PEERS;
2138 opc->state = OPC_STATE_INIT;
2139 opc->op = GNUNET_TESTBED_operation_create_ (opc, &opstart_shutdown_peers,
2140 &oprelease_shutdown_peers);
2141 GNUNET_TESTBED_operation_queue_insert_ (opc->c->opq_parallel_operations,
2143 GNUNET_TESTBED_operation_begin_wait_ (opc->op);
2148 /* end of testbed_api.c */