GNUnet  0.19.3
testbed_api_peers.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet
3  Copyright (C) 2008--2013 GNUnet e.V.
4 
5  GNUnet is free software: you can redistribute it and/or modify it
6  under the terms of the GNU Affero General Public License as published
7  by the Free Software Foundation, either version 3 of the License,
8  or (at your option) any later version.
9 
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  Affero General Public License for more details.
14 
15  You should have received a copy of the GNU Affero General Public License
16  along with this program. If not, see <http://www.gnu.org/licenses/>.
17 
18  SPDX-License-Identifier: AGPL3.0-or-later
19  */
20 
29 #include "platform.h"
30 #include "testbed_api_peers.h"
31 #include "testbed_api.h"
32 #include "testbed.h"
33 #include "testbed_api_hosts.h"
34 #include "testbed_api_operations.h"
35 
36 
41 
46 
47 
53 void
55 {
57 }
58 
59 
65 void
67 {
69 }
70 
71 
75 void
77 {
78  struct GNUNET_TESTBED_Peer *peer;
79 
80  while (NULL != (peer = peer_list_head))
81  {
83  GNUNET_free (peer);
84  }
85 }
86 
87 
95 static void
97 {
98  struct OperationContext *opc = cls;
99  struct PeerCreateData *data = opc->data;
101  struct GNUNET_MQ_Envelope *env;
102  char *config;
103  char *xconfig;
104  size_t c_size;
105  size_t xc_size;
106 
108  GNUNET_assert (NULL != data);
109  GNUNET_assert (NULL != data->peer);
110  opc->state = OPC_STATE_STARTED;
112  &c_size);
114  c_size,
115  &xconfig);
118  xc_size,
120  msg->operation_id = GNUNET_htonll (opc->id);
121  msg->host_id = htonl (GNUNET_TESTBED_host_get_id_ (data->peer->host));
122  msg->peer_id = htonl (data->peer->unique_id);
123  msg->config_size = htons ((uint16_t) c_size);
124  GNUNET_memcpy (&msg[1],
125  xconfig,
126  xc_size);
127  GNUNET_MQ_send (opc->c->mq,
128  env);
129  GNUNET_free (xconfig);
130  GNUNET_TESTBED_insert_opc_ (opc->c, opc);
131 }
132 
133 
139 static void
141 {
142  struct OperationContext *opc = cls;
143 
144  switch (opc->state)
145  {
146  case OPC_STATE_STARTED:
147  GNUNET_TESTBED_remove_opc_ (opc->c, opc);
148 
149  /* No break we continue flow */
150  case OPC_STATE_INIT:
151  GNUNET_free (((struct PeerCreateData *) opc->data)->peer);
152  GNUNET_free (opc->data);
153  break;
154 
155  case OPC_STATE_FINISHED:
156  break;
157  }
158  GNUNET_free (opc);
159 }
160 
161 
167 static void
169 {
170  struct OperationContext *opc = cls;
171  struct GNUNET_TESTBED_Peer *peer = opc->data;
173  struct GNUNET_MQ_Envelope *env;
174 
176  GNUNET_assert (NULL != peer);
177  opc->state = OPC_STATE_STARTED;
178  env = GNUNET_MQ_msg (msg,
180  msg->peer_id = htonl (peer->unique_id);
181  msg->operation_id = GNUNET_htonll (opc->id);
182  GNUNET_TESTBED_insert_opc_ (opc->c, opc);
184  env);
185 }
186 
187 
193 static void
195 {
196  struct OperationContext *opc = cls;
197 
198  switch (opc->state)
199  {
200  case OPC_STATE_STARTED:
201  GNUNET_TESTBED_remove_opc_ (opc->c, opc);
202 
203  /* no break; continue */
204  case OPC_STATE_INIT:
205  break;
206 
207  case OPC_STATE_FINISHED:
208  break;
209  }
210  GNUNET_free (opc);
211 }
212 
213 
219 static void
221 {
222  struct OperationContext *opc = cls;
224  struct GNUNET_MQ_Envelope *env;
225  struct PeerEventData *data;
226  struct GNUNET_TESTBED_Peer *peer;
227 
228  GNUNET_assert (OP_PEER_START == opc->type);
229  GNUNET_assert (NULL != (data = opc->data));
230  GNUNET_assert (NULL != (peer = data->peer));
232  peer->state));
233  opc->state = OPC_STATE_STARTED;
234  env = GNUNET_MQ_msg (msg,
236  msg->peer_id = htonl (peer->unique_id);
237  msg->operation_id = GNUNET_htonll (opc->id);
238  GNUNET_TESTBED_insert_opc_ (opc->c, opc);
240  env);
241 }
242 
243 
249 static void
251 {
252  struct OperationContext *opc = cls;
253 
254  switch (opc->state)
255  {
256  case OPC_STATE_STARTED:
257  GNUNET_TESTBED_remove_opc_ (opc->c, opc);
258 
259  /* no break; continue */
260  case OPC_STATE_INIT:
261  GNUNET_free (opc->data);
262  break;
263 
264  case OPC_STATE_FINISHED:
265  break;
266  }
267  GNUNET_free (opc);
268 }
269 
270 
276 static void
277 opstart_peer_stop (void *cls)
278 {
279  struct OperationContext *opc = cls;
281  struct PeerEventData *data;
282  struct GNUNET_TESTBED_Peer *peer;
283  struct GNUNET_MQ_Envelope *env;
284 
285  GNUNET_assert (NULL != (data = opc->data));
286  GNUNET_assert (NULL != (peer = data->peer));
288  opc->state = OPC_STATE_STARTED;
289  env = GNUNET_MQ_msg (msg,
291  msg->peer_id = htonl (peer->unique_id);
292  msg->operation_id = GNUNET_htonll (opc->id);
293  GNUNET_TESTBED_insert_opc_ (opc->c, opc);
295  env);
296 }
297 
298 
304 static void
306 {
307  struct OperationContext *opc = cls;
308 
309  switch (opc->state)
310  {
311  case OPC_STATE_STARTED:
312  GNUNET_TESTBED_remove_opc_ (opc->c, opc);
313 
314  /* no break; continue */
315  case OPC_STATE_INIT:
316  GNUNET_free (opc->data);
317  break;
318 
319  case OPC_STATE_FINISHED:
320  break;
321  }
322  GNUNET_free (opc);
323 }
324 
325 
336  uint64_t operation_id)
337 {
339 
340  msg =
341  GNUNET_malloc (sizeof
343  msg->header.size =
344  htons (sizeof(struct GNUNET_TESTBED_PeerGetConfigurationMessage));
346  msg->peer_id = htonl (peer_id);
347  msg->operation_id = GNUNET_htonll (operation_id);
348  return msg;
349 }
350 
351 
357 static void
359 {
360  struct OperationContext *opc = cls;
361  struct PeerInfoData *data = opc->data;
363 
364  GNUNET_assert (NULL != data);
365  opc->state = OPC_STATE_STARTED;
366  msg =
368  opc->id);
369  GNUNET_TESTBED_insert_opc_ (opc->c, opc);
370  GNUNET_TESTBED_queue_message_ (opc->c, &msg->header);
371 }
372 
373 
379 static void
381 {
382  struct OperationContext *opc = cls;
384 
385  switch (opc->state)
386  {
387  case OPC_STATE_STARTED:
388  GNUNET_TESTBED_remove_opc_ (opc->c, opc);
389 
390  /* no break; continue */
391  case OPC_STATE_INIT:
392  GNUNET_free (opc->data);
393  break;
394 
395  case OPC_STATE_FINISHED:
396  data = opc->data;
397  GNUNET_assert (NULL != data);
398  switch (data->pit)
399  {
401  if (NULL != data->result.cfg)
402  GNUNET_CONFIGURATION_destroy (data->result.cfg);
403  break;
404 
406  GNUNET_free (data->result.id);
407  break;
408 
409  default:
410  GNUNET_assert (0); /* We should never reach here */
411  }
412  GNUNET_free (data);
413  break;
414  }
415  GNUNET_free (opc);
416 }
417 
418 
424 static void
426 {
427  struct OperationContext *opc = cls;
428  struct GNUNET_MQ_Envelope *env;
430  struct OverlayConnectData *data;
431 
432  opc->state = OPC_STATE_STARTED;
433  data = opc->data;
434  GNUNET_assert (NULL != data);
435  env = GNUNET_MQ_msg (msg,
437  msg->peer1 = htonl (data->p1->unique_id);
438  msg->peer2 = htonl (data->p2->unique_id);
439  msg->operation_id = GNUNET_htonll (opc->id);
440  msg->peer2_host_id = htonl (GNUNET_TESTBED_host_get_id_ (data->p2->host));
442  opc);
443  GNUNET_MQ_send (opc->c->mq,
444  env);
445 }
446 
447 
453 static void
455 {
456  struct OperationContext *opc = cls;
457  struct OverlayConnectData *data;
458 
459  data = opc->data;
460  switch (opc->state)
461  {
462  case OPC_STATE_INIT:
463  break;
464 
465  case OPC_STATE_STARTED:
466  GNUNET_TESTBED_remove_opc_ (opc->c, opc);
467  break;
468 
469  case OPC_STATE_FINISHED:
470  break;
471  }
472  GNUNET_free (data);
473  GNUNET_free (opc);
474 }
475 
476 
482 static void
484 {
485  struct OperationContext *opc = cls;
486  struct PeerReconfigureData *data = opc->data;
487  struct GNUNET_MQ_Envelope *env;
489  char *xconfig;
490  size_t xc_size;
491 
492  opc->state = OPC_STATE_STARTED;
493  GNUNET_assert (NULL != data);
494  xc_size = GNUNET_TESTBED_compress_config_ (data->config,
495  data->cfg_size,
496  &xconfig);
497  GNUNET_free (data->config);
498  data->config = NULL;
499  GNUNET_assert (xc_size < UINT16_MAX - sizeof(*msg));
501  xc_size,
503  msg->peer_id = htonl (data->peer->unique_id);
504  msg->operation_id = GNUNET_htonll (opc->id);
505  msg->config_size = htons (data->cfg_size);
506  GNUNET_memcpy (&msg[1],
507  xconfig,
508  xc_size);
509  GNUNET_free (xconfig);
510  GNUNET_free (data);
511  opc->data = NULL;
512  GNUNET_TESTBED_insert_opc_ (opc->c, opc);
513  GNUNET_MQ_send (opc->c->mq,
514  env);
515 }
516 
517 
523 static void
525 {
526  struct OperationContext *opc = cls;
527  struct PeerReconfigureData *data = opc->data;
528 
529  switch (opc->state)
530  {
531  case OPC_STATE_INIT:
532  GNUNET_free (data->config);
533  GNUNET_free (data);
534  break;
535 
536  case OPC_STATE_STARTED:
537  GNUNET_TESTBED_remove_opc_ (opc->c, opc);
538  break;
539 
540  case OPC_STATE_FINISHED:
541  break;
542  }
543  GNUNET_free (opc);
544 }
545 
546 
553 struct GNUNET_TESTBED_Peer *
555 {
556  GNUNET_break (0);
557  return NULL;
558 }
559 
560 
592  struct GNUNET_TESTBED_Host *host,
593  const struct GNUNET_CONFIGURATION_Handle *cfg,
594  GNUNET_TESTBED_PeerCreateCallback cb, void *cls)
595 {
596  struct GNUNET_TESTBED_Peer *peer;
597  struct PeerCreateData *data;
598  struct OperationContext *opc;
599  static uint32_t id_gen;
600 
602  peer->controller = controller;
603  peer->host = host;
604  peer->unique_id = id_gen++;
606  data = GNUNET_new (struct PeerCreateData);
607  data->host = host;
608  data->cfg = cfg;
609  data->cb = cb;
610  data->cls = cls;
611  data->peer = peer;
612  opc = GNUNET_new (struct OperationContext);
613  opc->c = controller;
614  opc->data = data;
615  opc->id = GNUNET_TESTBED_get_next_op_id (controller);
616  opc->type = OP_PEER_CREATE;
617  opc->op =
621  opc->op);
623  return opc->op;
624 }
625 
626 
639  GNUNET_TESTBED_PeerChurnCallback pcc, void *pcc_cls)
640 {
641  struct OperationContext *opc;
642  struct PeerEventData *data;
643 
644  data = GNUNET_new (struct PeerEventData);
645  data->peer = peer;
646  data->pcc = pcc;
647  data->pcc_cls = pcc_cls;
648  opc = GNUNET_new (struct OperationContext);
649  opc->c = peer->controller;
650  opc->data = data;
651  opc->op_cls = op_cls;
652  opc->id = GNUNET_TESTBED_get_next_op_id (opc->c);
653  opc->type = OP_PEER_START;
654  opc->op =
658  opc->op);
660  return opc->op;
661 }
662 
663 
666  struct GNUNET_TESTBED_Peer *peer,
667  GNUNET_TESTBED_PeerChurnCallback pcc, void *pcc_cls)
668 {
669  struct OperationContext *opc;
670  struct PeerEventData *data;
671 
672  data = GNUNET_new (struct PeerEventData);
673  data->peer = peer;
674  data->pcc = pcc;
675  data->pcc_cls = pcc_cls;
676  opc = GNUNET_new (struct OperationContext);
677  opc->c = peer->controller;
678  opc->data = data;
679  opc->op_cls = op_cls;
680  opc->id = GNUNET_TESTBED_get_next_op_id (opc->c);
681  opc->type = OP_PEER_STOP;
682  opc->op =
686  opc->op);
688  return opc->op;
689 }
690 
691 
696  void *cb_cls)
697 {
698  struct OperationContext *opc;
699  struct PeerInfoData *data;
700 
702  GNUNET_assert (NULL != cb);
703  data = GNUNET_new (struct PeerInfoData);
704  data->peer = peer;
705  data->pit = pit;
706  data->cb = cb;
707  data->cb_cls = cb_cls;
708  opc = GNUNET_new (struct OperationContext);
709  opc->c = peer->controller;
710  opc->data = data;
711  opc->type = OP_PEER_INFO;
712  opc->id = GNUNET_TESTBED_get_next_op_id (opc->c);
713  opc->op =
717  opc->op);
719  return opc->op;
720 }
721 
722 
735  const struct
737 {
738  struct OperationContext *opc;
739  struct PeerReconfigureData *data;
740  size_t csize;
741 
743  data->peer = peer;
745  if (NULL == data->config)
746  {
747  GNUNET_free (data);
748  return NULL;
749  }
750  if (csize > UINT16_MAX)
751  {
752  GNUNET_break (0);
753  GNUNET_free (data->config);
754  GNUNET_free (data);
755  return NULL;
756  }
757  data->cfg_size = (uint16_t) csize;
758  opc = GNUNET_new (struct OperationContext);
759  opc->c = peer->controller;
760  opc->data = data;
761  opc->type = OP_PEER_RECONFIGURE;
762  opc->id = GNUNET_TESTBED_get_next_op_id (opc->c);
763  opc->op =
767  opc->op);
769  return opc->op;
770 }
771 
772 
782 {
783  struct OperationContext *opc;
784 
785  opc = GNUNET_new (struct OperationContext);
786  opc->data = peer;
787  opc->c = peer->controller;
789  opc->type = OP_PEER_DESTROY;
790  opc->op =
794  opc->op);
796  return opc->op;
797 }
798 
799 
814  struct GNUNET_TESTBED_Peer *p1,
815  struct GNUNET_TESTBED_Peer *p2,
817  ...)
818 {
819  GNUNET_break (0);
820  return NULL;
821 }
822 
823 
827  void *cb_cls, struct GNUNET_TESTBED_Peer *p1,
828  struct GNUNET_TESTBED_Peer *p2)
829 {
830  struct OperationContext *opc;
831  struct OverlayConnectData *data;
832 
834  p2->state));
836  data->p1 = p1;
837  data->p2 = p2;
838  data->cb = cb;
839  data->cb_cls = cb_cls;
840  opc = GNUNET_new (struct OperationContext);
841  opc->data = data;
842  opc->c = p1->controller;
843  opc->id = GNUNET_TESTBED_get_next_op_id (opc->c);
844  opc->type = OP_OVERLAY_CONNECT;
845  opc->op_cls = op_cls;
846  opc->op =
851  return opc->op;
852 }
853 
854 
860 static void
862 {
863  struct OperationContext *opc = cls;
864  struct ManageServiceData *data = opc->data;
865  struct GNUNET_MQ_Envelope *env;
867  size_t xlen;
868 
869  GNUNET_assert (NULL != data);
870  xlen = data->msize - sizeof(struct GNUNET_TESTBED_ManagePeerServiceMessage);
872  xlen,
874  msg->peer_id = htonl (data->peer->unique_id);
875  msg->operation_id = GNUNET_htonll (opc->id);
876  msg->start = (uint8_t) data->start;
877  GNUNET_memcpy (&msg[1],
878  data->service_name,
879  xlen);
880  GNUNET_free (data->service_name);
881  data->service_name = NULL;
882  opc->state = OPC_STATE_STARTED;
883  GNUNET_TESTBED_insert_opc_ (opc->c, opc);
884  GNUNET_MQ_send (opc->c->mq,
885  env);
886 }
887 
888 
894 static void
896 {
897  struct OperationContext *opc = cls;
898  struct ManageServiceData *data;
899 
900  data = opc->data;
901  switch (opc->state)
902  {
903  case OPC_STATE_STARTED:
904  GNUNET_TESTBED_remove_opc_ (opc->c, opc);
905  break;
906 
907  case OPC_STATE_INIT:
908  GNUNET_assert (NULL != data);
909  GNUNET_free (data->service_name);
910  break;
911 
912  case OPC_STATE_FINISHED:
913  break;
914  }
915  GNUNET_free (data);
916  GNUNET_free (opc);
917 }
918 
919 
922  struct GNUNET_TESTBED_Peer *peer,
923  const char *service_name,
925  cb,
926  void *cb_cls,
927  unsigned int start)
928 {
929  struct ManageServiceData *data;
930  struct OperationContext *opc;
931  size_t msize;
932 
933  GNUNET_assert (TESTBED_PS_STARTED == peer->state); /* peer is not running? */
934  msize = strlen (service_name) + 1;
935  msize += sizeof(struct GNUNET_TESTBED_ManagePeerServiceMessage);
936  if (GNUNET_MAX_MESSAGE_SIZE < msize)
937  return NULL;
938  data = GNUNET_new (struct ManageServiceData);
939  data->cb = cb;
940  data->cb_cls = cb_cls;
941  data->peer = peer;
942  data->service_name = GNUNET_strdup (service_name);
943  data->start = start;
944  data->msize = (uint16_t) msize;
945  opc = GNUNET_new (struct OperationContext);
946  opc->data = data;
947  opc->c = peer->controller;
948  opc->id = GNUNET_TESTBED_get_next_op_id (opc->c);
949  opc->type = OP_MANAGE_SERVICE;
950  opc->op_cls = op_cls;
951  opc->op =
955  opc->op);
957  return opc->op;
958 }
959 
960 
961 /* end of testbed_api_peers.c */
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
static int start
Set if we are to start default services (including ARM).
Definition: gnunet-arm.c:39
static char * peer_id
Option –peer.
Definition: gnunet-cadet.c:42
uint32_t data
The data value.
static unsigned int csize
static const struct GNUNET_CONFIGURATION_Handle * config
static char * service_name
Option -s: service name (hash to get service descriptor)
Definition: gnunet-vpn.c:50
#define GNUNET_MAX_MESSAGE_SIZE
Largest supported message (to be precise, one byte more than the largest possible message,...
char * GNUNET_CONFIGURATION_serialize(const struct GNUNET_CONFIGURATION_Handle *cfg, size_t *size)
Serializes the given configuration.
void GNUNET_CONFIGURATION_destroy(struct GNUNET_CONFIGURATION_Handle *cfg)
Destroy configuration object.
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element)
Insert an element at the tail of a DLL.
uint64_t GNUNET_htonll(uint64_t n)
Convert unsigned 64-bit integer to network byte order.
Definition: common_endian.c:37
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:304
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct.
Definition: gnunet_mq_lib.h:62
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:77
#define GNUNET_MESSAGE_TYPE_TESTBED_START_PEER
Message to start a peer at a host.
#define GNUNET_MESSAGE_TYPE_TESTBED_MANAGE_PEER_SERVICE
Message to start/stop a service of a peer.
#define GNUNET_MESSAGE_TYPE_TESTBED_OVERLAY_CONNECT
Message to connect peers in a overlay.
#define GNUNET_MESSAGE_TYPE_TESTBED_GET_PEER_INFORMATION
Message to get a peer's information.
#define GNUNET_MESSAGE_TYPE_TESTBED_RECONFIGURE_PEER
Message to reconfigure a peer.
#define GNUNET_MESSAGE_TYPE_TESTBED_STOP_PEER
Message to stop a peer at a host.
#define GNUNET_MESSAGE_TYPE_TESTBED_DESTROY_PEER
Message to destroy a peer.
#define GNUNET_MESSAGE_TYPE_TESTBED_CREATE_PEER
Message to create a peer at a host.
struct GNUNET_TESTBED_Operation * GNUNET_TESTBED_peer_stop(void *op_cls, struct GNUNET_TESTBED_Peer *peer, GNUNET_TESTBED_PeerChurnCallback pcc, void *pcc_cls)
Stop the given peer.
struct GNUNET_TESTBED_Operation * GNUNET_TESTBED_peer_update_configuration(struct GNUNET_TESTBED_Peer *peer, const struct GNUNET_CONFIGURATION_Handle *cfg)
Change peer configuration.
struct GNUNET_TESTBED_Operation * GNUNET_TESTBED_peer_get_information(struct GNUNET_TESTBED_Peer *peer, enum GNUNET_TESTBED_PeerInformationType pit, GNUNET_TESTBED_PeerInfoCallback cb, void *cb_cls)
Request information about a peer.
struct GNUNET_TESTBED_Operation * GNUNET_TESTBED_peer_create(struct GNUNET_TESTBED_Controller *controller, struct GNUNET_TESTBED_Host *host, const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_TESTBED_PeerCreateCallback cb, void *cls)
Create the given peer at the specified host using the given controller.
void(* GNUNET_TESTBED_PeerChurnCallback)(void *cls, const char *emsg)
Functions of this signature are called when a peer has been successfully started or stopped.
struct GNUNET_TESTBED_Operation * GNUNET_TESTBED_peer_manage_service(void *op_cls, struct GNUNET_TESTBED_Peer *peer, const char *service_name, GNUNET_TESTBED_OperationCompletionCallback cb, void *cb_cls, unsigned int start)
Start or stop given service at a peer.
GNUNET_TESTBED_PeerInformationType
Types of information that can be requested about a peer.
struct GNUNET_TESTBED_Operation * GNUNET_TESTBED_overlay_connect(void *op_cls, GNUNET_TESTBED_OperationCompletionCallback cb, void *cb_cls, struct GNUNET_TESTBED_Peer *p1, struct GNUNET_TESTBED_Peer *p2)
Both peers must have been started before calling this function.
void(* GNUNET_TESTBED_OperationCompletionCallback)(void *cls, struct GNUNET_TESTBED_Operation *op, const char *emsg)
Callback to be called when an operation is completed.
void(* GNUNET_TESTBED_PeerCreateCallback)(void *cls, struct GNUNET_TESTBED_Peer *peer, const char *emsg)
Functions of this signature are called when a peer has been successfully created.
GNUNET_TESTBED_ConnectOption
Options for peer connections.
struct GNUNET_TESTBED_Operation * GNUNET_TESTBED_underlay_configure_link(void *op_cls, struct GNUNET_TESTBED_Peer *p1, struct GNUNET_TESTBED_Peer *p2, enum GNUNET_TESTBED_ConnectOption co,...)
Manipulate the P2P underlay topology by configuring a link between two peers.
void(* GNUNET_TESTBED_PeerInfoCallback)(void *cb_cls, struct GNUNET_TESTBED_Operation *op, const struct GNUNET_TESTBED_PeerInformation *pinfo, const char *emsg)
Callback to be called when the requested peer information is available The peer information in the ca...
struct GNUNET_TESTBED_Operation * GNUNET_TESTBED_peer_start(void *op_cls, struct GNUNET_TESTBED_Peer *peer, GNUNET_TESTBED_PeerChurnCallback pcc, void *pcc_cls)
Start the given peer.
struct GNUNET_TESTBED_Operation * GNUNET_TESTBED_peer_destroy(struct GNUNET_TESTBED_Peer *peer)
Destroy the given peer; the peer should have been stopped first (if it was started).
@ GNUNET_TESTBED_PIT_CONFIGURATION
What configuration is the peer using? Returns a 'const struct GNUNET_CONFIGURATION_Handle *'.
@ GNUNET_TESTBED_PIT_IDENTITY
What is the identity of the peer? Returns a 'const struct GNUNET_PeerIdentity *'.
@ GNUNET_TESTBED_PIT_GENERIC
Special value (not valid for requesting information) that is used in the event struct if a 'generic' ...
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
Handle to interact with a GNUnet testbed controller.
Definition: testbed_api.h:194
struct GNUNET_MQ_Handle * mq
The message queue to the controller service.
Definition: testbed_api.h:218
struct OperationQueue * opq_parallel_operations
Operation queue for simultaneous operations.
Definition: testbed_api.h:244
Opaque handle to a host running experiments managed by the testing framework.
Message to start/stop services of a peer.
Definition: testbed.h:706
Opaque handle to an abstract operation to be executed by the testing framework.
void * cb_cls
Closure for callbacks.
Message sent from client to testing service to connect two peers.
Definition: testbed.h:376
Message sent from client to testing service to create (configure, but not start) a peer.
Definition: testbed.h:205
Message sent from client to testing service to destroy a (stopped) peer.
Definition: testbed.h:318
Message sent from client to testing service to obtain the configuration of a peer.
Definition: testbed.h:582
uint64_t operation_id
Operation ID that is used to identify this operation.
Definition: testbed.h:596
Data returned from GNUNET_TESTBED_peer_get_information.
Message sent from client to testing service to reconfigure a (stopped) a peer.
Definition: testbed.h:241
Message sent from client to testing service to start a peer.
Definition: testbed.h:272
Message sent from client to testing service to stop a peer.
Definition: testbed.h:295
A peer controlled by the testing framework.
enum PeerState state
Peer's state.
struct GNUNET_TESTBED_Controller * controller
Our controller context (not necessarily the controller that is responsible for starting/running the p...
uint32_t unique_id
Globally unique ID of the peer.
struct GNUNET_TESTBED_Host * host
Which host does this peer run on?
Context information for GNUNET_TESTBED_Operation.
Definition: testbed_api.h:137
void * op_cls
The operation closure.
Definition: testbed_api.h:151
enum OperationContextState state
The state of the operation.
Definition: testbed_api.h:171
enum OperationType type
The type of operation.
Definition: testbed_api.h:166
uint64_t id
The id of the operation.
Definition: testbed_api.h:161
struct GNUNET_TESTBED_Operation * op
The operation.
Definition: testbed_api.h:146
struct GNUNET_TESTBED_Controller * c
The controller to which this operation context belongs to.
Definition: testbed_api.h:141
void * data
Data relevant to the operation.
Definition: testbed_api.h:156
Data structure for OperationType OP_OVERLAY_CONNECT.
void * cb_cls
The closure for the above callback.
struct GNUNET_TESTBED_Peer * p2
Peer B.
GNUNET_TESTBED_OperationCompletionCallback cb
The operation completion callback to call once this operation is done.
struct GNUNET_TESTBED_Peer * p1
Peer A to connect to peer B.
Data for the OperationType OP_PEER_CREATE.
Data for OperationType OP_PEER_START and OP_PEER_STOP.
GNUNET_TESTBED_PeerChurnCallback pcc
The Peer churn callback to call when this operation is completed.
void * pcc_cls
Closure for the above callback.
Data for the OperationType OP_PEER_INFO.
GNUNET_TESTBED_PeerInfoCallback cb
The Peer info callback to call when this operation has completed.
void * cb_cls
The closure for peer info callback.
enum GNUNET_TESTBED_PeerInformationType pit
The type of peer information requested.
Data for the operations of type OP_PEER_RECONFIGURE.
IPC messages between testing API and service ("controller")
void GNUNET_TESTBED_queue_message_(struct GNUNET_TESTBED_Controller *controller, struct GNUNET_MessageHeader *msg)
Queues a message in send queue for sending to the service.
Definition: testbed_api.c:1336
void GNUNET_TESTBED_remove_opc_(const struct GNUNET_TESTBED_Controller *c, struct OperationContext *opc)
Removes the given operation context from the operation context map of the given controller.
Definition: testbed_api.c:319
uint64_t GNUNET_TESTBED_get_next_op_id(struct GNUNET_TESTBED_Controller *controller)
Function to return the operation id for a controller.
Definition: testbed_api.c:2178
void GNUNET_TESTBED_insert_opc_(struct GNUNET_TESTBED_Controller *c, struct OperationContext *opc)
Inserts the given operation context into the operation context map of the given controller.
Definition: testbed_api.c:298
size_t GNUNET_TESTBED_compress_config_(const char *config, size_t size, char **xconfig)
Compresses given configuration using zlib compress.
Definition: testbed_api.c:1758
Interface for functions internally exported from testbed_api.c.
@ OP_PEER_RECONFIGURE
Reconfigure a peer.
Definition: testbed_api.h:74
@ OP_PEER_START
Peer start operation.
Definition: testbed_api.h:54
@ OP_PEER_INFO
Get peer information operation.
Definition: testbed_api.h:69
@ OP_MANAGE_SERVICE
Start/stop service at a peer.
Definition: testbed_api.h:104
@ OP_PEER_DESTROY
Peer destroy operation.
Definition: testbed_api.h:64
@ OP_OVERLAY_CONNECT
Overlay connection operation.
Definition: testbed_api.h:79
@ OP_PEER_STOP
Peer stop operation.
Definition: testbed_api.h:59
@ OP_PEER_CREATE
Peer create operation.
Definition: testbed_api.h:49
@ OPC_STATE_INIT
The initial state where the associated operation has just been created and is waiting in the operatio...
Definition: testbed_api.h:117
@ OPC_STATE_STARTED
The operation has been started.
Definition: testbed_api.h:123
@ OPC_STATE_FINISHED
The operation has finished.
Definition: testbed_api.h:129
void GNUNET_TESTBED_host_queue_oc_(struct GNUNET_TESTBED_Host *h, struct GNUNET_TESTBED_Operation *op)
Queues the given operation in the queue for parallel overlay connects of the given host.
uint32_t GNUNET_TESTBED_host_get_id_(const struct GNUNET_TESTBED_Host *host)
Obtain a host's unique global ID.
internal API to access the 'hosts' subsystem
struct GNUNET_TESTBED_Operation * GNUNET_TESTBED_operation_create_(void *cls, OperationStart start, OperationRelease release)
Create an 'operation' to be performed.
void GNUNET_TESTBED_operation_queue_insert_(struct OperationQueue *queue, struct GNUNET_TESTBED_Operation *op)
Add an operation to a queue.
void GNUNET_TESTBED_operation_begin_wait_(struct GNUNET_TESTBED_Operation *op)
Marks the given operation as waiting on the queues.
internal API to access the 'operations' subsystem
static void oprelease_peer_getinfo(void *cls)
Callback which will be called when peer stop type operation is released.
static void opstart_overlay_connect(void *cls)
Function called when a overlay connect operation is ready.
static struct GNUNET_TESTBED_Peer * peer_list_tail
Peer list DLL tail.
void GNUNET_TESTBED_peer_deregister_(struct GNUNET_TESTBED_Peer *peer)
Removes a peer from the peer list.
static void opstart_peer_destroy(void *cls)
Function called when a peer destroy operation is ready.
void GNUNET_TESTBED_cleanup_peers_(void)
Frees all peers.
struct GNUNET_TESTBED_Peer * GNUNET_TESTBED_peer_lookup_by_id_(uint32_t id)
Lookup a peer by ID.
static void oprelease_peer_destroy(void *cls)
Callback which will be called when peer_create type operation is released.
struct GNUNET_TESTBED_PeerGetConfigurationMessage * GNUNET_TESTBED_generate_peergetconfig_msg_(uint32_t peer_id, uint64_t operation_id)
Generate PeerGetConfigurationMessage.
static void oprelease_peer_create(void *cls)
Callback which will be called when peer_create type operation is released.
static void opstart_peer_reconfigure(void *cls)
Function called when a peer reconfigure operation is ready.
static void opstart_peer_create(void *cls)
Function to call to start a peer_create type operation once all queues the operation is part of decla...
static void oprelease_manage_service(void *cls)
Callback which will be called when peer manage server operation is released.
static void oprelease_peer_start(void *cls)
Callback which will be called when peer start type operation is released.
static void opstart_peer_stop(void *cls)
Function called when a peer stop operation is ready.
static void opstart_peer_getinfo(void *cls)
Function called when a peer get information operation is ready.
static void opstart_manage_service(void *cls)
Function called when a peer manage service operation is ready.
static struct GNUNET_TESTBED_Peer * peer_list_head
Peer list DLL head.
static void oprelease_peer_reconfigure(void *cls)
Callback which will be called when a peer reconfigure operation is released.
static void opstart_peer_start(void *cls)
Function called when a peer start operation is ready.
static void oprelease_peer_stop(void *cls)
Callback which will be called when peer stop type operation is released.
static void oprelease_overlay_connect(void *cls)
Callback which will be called when overlay connect operation is released.
void GNUNET_TESTBED_peer_register_(struct GNUNET_TESTBED_Peer *peer)
Adds a peer to the peer list.
internal API to access the 'peers' subsystem
@ TESTBED_PS_INVALID
State to signify that this peer is invalid.
@ TESTBED_PS_STOPPED
The peer is stopped.
@ TESTBED_PS_CREATED
The peer has been created.
@ TESTBED_PS_STARTED
The peer is running.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.