aboutsummaryrefslogtreecommitdiff
path: root/src/testbed/test_testbed_api_controllerlink.c
diff options
context:
space:
mode:
authorMartin Schanzenbach <schanzen@gnunet.org>2023-10-13 18:19:48 +0200
committerMartin Schanzenbach <schanzen@gnunet.org>2023-10-13 18:19:48 +0200
commit21c4b14e7e9a5f113b2c190b0223ca95074125b1 (patch)
treecb3105228f1ba52bea81c74caa642b26bc6c297e /src/testbed/test_testbed_api_controllerlink.c
parentf5c99c11e752667d6c07d16568ae16a782b48e4c (diff)
downloadgnunet-21c4b14e7e9a5f113b2c190b0223ca95074125b1.tar.gz
gnunet-21c4b14e7e9a5f113b2c190b0223ca95074125b1.zip
Delete more subsystems not required after tng
Diffstat (limited to 'src/testbed/test_testbed_api_controllerlink.c')
-rw-r--r--src/testbed/test_testbed_api_controllerlink.c881
1 files changed, 0 insertions, 881 deletions
diff --git a/src/testbed/test_testbed_api_controllerlink.c b/src/testbed/test_testbed_api_controllerlink.c
deleted file mode 100644
index 0ec9d63e1..000000000
--- a/src/testbed/test_testbed_api_controllerlink.c
+++ /dev/null
@@ -1,881 +0,0 @@
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
21/**
22 * @file testbed/test_testbed_api_controllerlink.c
23 * @brief testcase for testing controller to subcontroller linking
24 * @author Sree Harsha Totakura <sreeharsha@totakura.in>
25 */
26
27
28/**
29 * The controller architecture we try to achieve in this test case:
30 *
31 * Master Controller
32 * // \\
33 * // \\
34 * Slave Controller 1---------Slave Controller 3
35 * ||
36 * ||
37 * Slave Controller 2
38 */
39
40#include "platform.h"
41#include "gnunet_util_lib.h"
42#include "gnunet_testing_lib.h"
43#include "gnunet_testbed_service.h"
44
45/**
46 * Generic logging shortcut
47 */
48#define LOG(kind, ...) GNUNET_log (kind, __VA_ARGS__)
49
50/**
51 * Debug logging shorthand
52 */
53#define LOG_DEBUG(...) LOG (GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__)
54
55/**
56 * Different stages in testing
57 */
58enum Stage
59{
60 /**
61 * Initial stage
62 */
63 INIT,
64
65 /**
66 * Master controller has started
67 */
68 MASTER_STARTED,
69
70 /**
71 * A peer has been created on master
72 */
73 MASTER_PEER_CREATE_SUCCESS,
74
75 /**
76 * Peer on master controller has been started successfully.
77 */
78 MASTER_PEER_START_SUCCESS,
79
80 /**
81 * The first slave has been registered at master controller
82 */
83 SLAVE1_REGISTERED,
84
85 /**
86 * The second slave has been registered at the master controller
87 */
88 SLAVE2_REGISTERED,
89
90 /**
91 * Link from master to slave 1 has been successfully created
92 */
93 SLAVE1_LINK_SUCCESS,
94
95 /**
96 * Peer create on slave 1 successful
97 */
98 SLAVE1_PEER_CREATE_SUCCESS,
99
100 /**
101 * Peer startup on slave 1 successful
102 */
103 SLAVE1_PEER_START_SUCCESS,
104
105 /**
106 * Link from slave 1 to slave 2 has been successfully created.
107 */
108 SLAVE2_LINK_SUCCESS,
109
110 /**
111 * Peer create on slave 2 successful
112 */
113 SLAVE2_PEER_CREATE_SUCCESS,
114
115 /**
116 * Peer on slave 1 successfully stopped
117 */
118 SLAVE1_PEER_STOP_SUCCESS,
119
120 /**
121 * Peer startup on slave 2 successful
122 */
123 SLAVE2_PEER_START_SUCCESS,
124
125 /**
126 * Try to connect peers on master and slave 2.
127 */
128 MASTER_SLAVE2_PEERS_CONNECTED,
129
130 /**
131 * Slave 3 has successfully registered
132 */
133 SLAVE3_REGISTERED,
134
135 /**
136 * Slave 3 has successfully started
137 */
138 SLAVE3_STARTED,
139
140 /**
141 * Peer created on slave 3
142 */
143 SLAVE3_PEER_CREATE_SUCCESS,
144
145 /**
146 * Peer started at slave 3
147 */
148 SLAVE3_PEER_START_SUCCESS,
149
150 /**
151 * Try to connect peers on slave2 and slave3
152 */
153 SLAVE2_SLAVE3_PEERS_CONNECTED,
154
155 /**
156 * Peer on slave 2 successfully stopped
157 */
158 SLAVE2_PEER_STOP_SUCCESS,
159
160 /**
161 * Peer destroy on slave 1 successful
162 */
163 SLAVE1_PEER_DESTROY_SUCCESS,
164
165 /**
166 * Peer destroy on slave 2 successful
167 */
168 SLAVE2_PEER_DESTROY_SUCCESS,
169
170 /**
171 * The configuration of slave 3 is acquired
172 */
173 SLAVE3_GET_CONFIG_SUCCESS,
174
175 /**
176 * Slave 1 has linked to slave 3;
177 */
178 SLAVE3_LINK_SUCCESS,
179
180 /**
181 * Master peer destroyed. Destroy slave 3 peer
182 */
183 MASTER_PEER_DESTROY_SUCCESS,
184
185 /**
186 * Slave 3 peer destroyed. Mark test as success
187 */
188 SUCCESS,
189
190 /**
191 * Marks test as skipped
192 */
193 SKIP
194};
195
196/**
197 * Host for running master controller
198 */
199static struct GNUNET_TESTBED_Host *host;
200
201/**
202 * The master controller process
203 */
204static struct GNUNET_TESTBED_ControllerProc *cp;
205
206/**
207 * Handle to master controller
208 */
209static struct GNUNET_TESTBED_Controller *mc;
210
211/**
212 * Slave host for running slave controller
213 */
214static struct GNUNET_TESTBED_Host *slave;
215
216/**
217 * Another slave host for running another slave controller
218 */
219static struct GNUNET_TESTBED_Host *slave2;
220
221/**
222 * Host for slave 3
223 */
224static struct GNUNET_TESTBED_Host *slave3;
225
226/**
227 * Slave host registration handle
228 */
229static struct GNUNET_TESTBED_HostRegistrationHandle *rh;
230
231/**
232 * Handle to global configuration
233 */
234static struct GNUNET_CONFIGURATION_Handle *cfg;
235
236/**
237 * Configuration of slave 3 controller
238 */
239static struct GNUNET_CONFIGURATION_Handle *cfg3;
240
241/**
242 * Abort task
243 */
244static struct GNUNET_SCHEDULER_Task *abort_task;
245
246/**
247 * Operation handle for linking controllers
248 */
249static struct GNUNET_TESTBED_Operation *op;
250
251/**
252 * Handle to peer started at slave 1
253 */
254static struct GNUNET_TESTBED_Peer *slave1_peer;
255
256/**
257 * Handle to peer started at slave 2
258 */
259static struct GNUNET_TESTBED_Peer *slave2_peer;
260
261/**
262 * Handle to peer started at slave 2
263 */
264static struct GNUNET_TESTBED_Peer *slave3_peer;
265
266/**
267 * Handle to a peer started at master controller
268 */
269static struct GNUNET_TESTBED_Peer *master_peer;
270
271/**
272 * The handle for whether a host is habitable or not
273 */
274static struct GNUNET_TESTBED_HostHabitableCheckHandle *hc_handle;
275
276/**
277 * The task handle for the delay task
278 */
279static struct GNUNET_SCHEDULER_Task *delay_task_id;
280
281/**
282 * Event mask
283 */
284static uint64_t event_mask;
285
286/**
287 * Global testing status
288 */
289static enum Stage result;
290
291/**
292 * shortcut to exit during failure
293 */
294#define FAIL_TEST(cond) \
295 do \
296 { \
297 if (! (cond)) \
298 { \
299 GNUNET_break (0); \
300 if (NULL != abort_task) \
301 GNUNET_SCHEDULER_cancel (abort_task); \
302 abort_task = NULL; \
303 GNUNET_SCHEDULER_shutdown (); \
304 return; \
305 } \
306 } while (0)
307
308
309/**
310 * Shutdown nicely
311 *
312 * @param cls NULL
313 */
314static void
315do_shutdown (void *cls)
316{
317 if (NULL != abort_task)
318 GNUNET_SCHEDULER_cancel (abort_task);
319 if (NULL != delay_task_id)
320 {
321 GNUNET_SCHEDULER_cancel (delay_task_id);
322 delay_task_id = NULL;
323 }
324 if (NULL != hc_handle)
325 GNUNET_TESTBED_is_host_habitable_cancel (hc_handle);
326 if (NULL != op)
327 {
328 GNUNET_TESTBED_operation_done (op);
329 op = NULL;
330 }
331 if (NULL != mc)
332 GNUNET_TESTBED_controller_disconnect (mc);
333 if (NULL != cp)
334 GNUNET_TESTBED_controller_stop (cp);
335 if (NULL != slave3)
336 GNUNET_TESTBED_host_destroy (slave3);
337 if (NULL != slave2)
338 GNUNET_TESTBED_host_destroy (slave2);
339 if (NULL != slave)
340 GNUNET_TESTBED_host_destroy (slave);
341 if (NULL != host)
342 GNUNET_TESTBED_host_destroy (host);
343 if (NULL != cfg)
344 GNUNET_CONFIGURATION_destroy (cfg);
345 if (NULL != cfg3)
346 GNUNET_CONFIGURATION_destroy (cfg3);
347 if (NULL != rh)
348 GNUNET_TESTBED_cancel_registration (rh);
349}
350
351
352/**
353 * abort task to run on test timed out
354 *
355 * @param cls NULL
356 */
357static void
358do_abort (void *cls)
359{
360 LOG (GNUNET_ERROR_TYPE_WARNING, "Aborting in stage %d\n", result);
361 abort_task = NULL;
362 GNUNET_SCHEDULER_shutdown ();
363}
364
365
366/**
367 * Calls abort now
368 *
369 * @param
370 * @return
371 */
372static void
373do_abort_now (void *cls)
374{
375 if (NULL != abort_task)
376 GNUNET_SCHEDULER_cancel (abort_task);
377 abort_task = GNUNET_SCHEDULER_add_now (&do_abort, NULL);
378}
379
380
381/**
382 * Callback which will be called to after a host registration succeeded or failed
383 *
384 * @param cls the host which has been registered
385 * @param emsg the error message; NULL if host registration is successful
386 */
387static void
388registration_cont (void *cls, const char *emsg);
389
390
391/**
392 * Task for inserting delay between tests
393 *
394 * @param
395 * @return
396 */
397static void
398delay_task (void *cls)
399{
400 delay_task_id = NULL;
401 switch (result)
402 {
403 case SLAVE2_PEER_CREATE_SUCCESS:
404 op = GNUNET_TESTBED_peer_stop (NULL, slave1_peer, NULL, NULL);
405 FAIL_TEST (NULL != op);
406 break;
407
408 case MASTER_SLAVE2_PEERS_CONNECTED:
409 slave3 = GNUNET_TESTBED_host_create_with_id (3, "127.0.0.1", NULL, cfg, 0);
410 rh = GNUNET_TESTBED_register_host (mc, slave3, &registration_cont, NULL);
411 break;
412
413 case SLAVE2_SLAVE3_PEERS_CONNECTED:
414 op = GNUNET_TESTBED_peer_stop (NULL, slave2_peer, NULL, NULL);
415 FAIL_TEST (NULL != op);
416 break;
417
418 default:
419 FAIL_TEST (0);
420 }
421}
422
423
424/**
425 * Functions of this signature are called when a peer has been successfully
426 * created
427 *
428 * @param cls the closure from GNUNET_TESTBED_peer_create()
429 * @param peer the handle for the created peer; NULL on any error during
430 * creation
431 * @param emsg NULL if peer is not NULL; else MAY contain the error description
432 */
433static void
434peer_create_cb (void *cls, struct GNUNET_TESTBED_Peer *peer, const char *emsg)
435{
436 FAIL_TEST (NULL != peer);
437 FAIL_TEST (NULL == emsg);
438 switch (result)
439 {
440 case MASTER_STARTED:
441 result = MASTER_PEER_CREATE_SUCCESS;
442 master_peer = peer;
443 GNUNET_TESTBED_operation_done (op);
444 op = GNUNET_TESTBED_peer_start (NULL, master_peer, NULL, NULL);
445 break;
446
447 case SLAVE1_LINK_SUCCESS:
448 result = SLAVE1_PEER_CREATE_SUCCESS;
449 slave1_peer = peer;
450 GNUNET_TESTBED_operation_done (op);
451 op = GNUNET_TESTBED_peer_start (NULL, slave1_peer, NULL, NULL);
452 break;
453
454 case SLAVE2_LINK_SUCCESS:
455 result = SLAVE2_PEER_CREATE_SUCCESS;
456 slave2_peer = peer;
457 GNUNET_TESTBED_operation_done (op);
458 op = NULL;
459 delay_task_id = GNUNET_SCHEDULER_add_delayed (
460 GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1),
461 &delay_task,
462 NULL);
463 return;
464
465 case SLAVE3_STARTED:
466 result = SLAVE3_PEER_CREATE_SUCCESS;
467 slave3_peer = peer;
468 GNUNET_TESTBED_operation_done (op);
469 op = GNUNET_TESTBED_peer_start (NULL, slave3_peer, NULL, NULL);
470 break;
471
472 default:
473 FAIL_TEST (0);
474 }
475 FAIL_TEST (NULL != op);
476}
477
478
479/**
480 * Checks the event if it is an operation finished event and if indicates a
481 * successful completion of operation
482 *
483 * @param event the event information to check
484 */
485static void
486check_operation_success (const struct GNUNET_TESTBED_EventInformation *event)
487{
488 FAIL_TEST (NULL != event);
489 FAIL_TEST (GNUNET_TESTBED_ET_OPERATION_FINISHED == event->type);
490 FAIL_TEST (event->op == op);
491 FAIL_TEST (NULL == event->op_cls);
492 FAIL_TEST (NULL == event->details.operation_finished.emsg);
493 FAIL_TEST (NULL == event->details.operation_finished.generic);
494}
495
496
497/**
498 * Signature of the event handler function called by the
499 * respective event controller.
500 *
501 * @param cls closure
502 * @param event information about the event
503 */
504static void
505controller_cb (void *cls, const struct GNUNET_TESTBED_EventInformation *event)
506{
507 switch (result)
508 {
509 case SLAVE2_REGISTERED:
510 check_operation_success (event);
511 GNUNET_TESTBED_operation_done (op);
512 op = NULL;
513 result = SLAVE1_LINK_SUCCESS;
514 FAIL_TEST (NULL != slave2);
515 FAIL_TEST (NULL != slave);
516 op = GNUNET_TESTBED_peer_create (mc, slave, cfg, peer_create_cb, NULL);
517 FAIL_TEST (NULL != op);
518 break;
519
520 case SLAVE1_PEER_START_SUCCESS:
521 check_operation_success (event);
522 GNUNET_TESTBED_operation_done (op);
523 result = SLAVE2_LINK_SUCCESS;
524 op = GNUNET_TESTBED_peer_create (mc, slave2, cfg, peer_create_cb, NULL);
525 FAIL_TEST (NULL != op);
526 break;
527
528 case MASTER_PEER_CREATE_SUCCESS:
529 FAIL_TEST (GNUNET_TESTBED_ET_PEER_START == event->type);
530 FAIL_TEST (event->details.peer_start.host == host);
531 FAIL_TEST (event->details.peer_start.peer == master_peer);
532 GNUNET_TESTBED_operation_done (op);
533 op = NULL;
534 result = MASTER_PEER_START_SUCCESS;
535 slave = GNUNET_TESTBED_host_create_with_id (1, "127.0.0.1", NULL, cfg, 0);
536 FAIL_TEST (NULL != slave);
537 rh = GNUNET_TESTBED_register_host (mc, slave, &registration_cont, NULL);
538 FAIL_TEST (NULL != rh);
539 break;
540
541 case SLAVE1_PEER_CREATE_SUCCESS:
542 FAIL_TEST (GNUNET_TESTBED_ET_PEER_START == event->type);
543 FAIL_TEST (event->details.peer_start.host == slave);
544 FAIL_TEST (event->details.peer_start.peer == slave1_peer);
545 GNUNET_TESTBED_operation_done (op);
546 result = SLAVE1_PEER_START_SUCCESS;
547 op = GNUNET_TESTBED_controller_link (NULL, mc, slave2, slave, GNUNET_YES);
548 break;
549
550 case SLAVE2_PEER_CREATE_SUCCESS:
551 FAIL_TEST (GNUNET_TESTBED_ET_PEER_STOP == event->type);
552 FAIL_TEST (event->details.peer_stop.peer == slave1_peer);
553 GNUNET_TESTBED_operation_done (op);
554 result = SLAVE1_PEER_STOP_SUCCESS;
555 op = GNUNET_TESTBED_peer_start (NULL, slave2_peer, NULL, NULL);
556 FAIL_TEST (NULL != op);
557 break;
558
559 case SLAVE3_PEER_CREATE_SUCCESS:
560 FAIL_TEST (GNUNET_TESTBED_ET_PEER_START == event->type);
561 FAIL_TEST (event->details.peer_start.host == slave3);
562 FAIL_TEST (event->details.peer_start.peer == slave3_peer);
563 GNUNET_TESTBED_operation_done (op);
564 result = SLAVE3_PEER_START_SUCCESS;
565 sleep (1);
566 LOG_DEBUG ("**************************************\n");
567 op =
568 GNUNET_TESTBED_overlay_connect (mc, NULL, NULL, slave2_peer, slave3_peer);
569 FAIL_TEST (NULL != op);
570 break;
571
572 case SLAVE3_PEER_START_SUCCESS:
573 FAIL_TEST (NULL != event);
574 FAIL_TEST (GNUNET_TESTBED_ET_CONNECT == event->type);
575 FAIL_TEST (event->details.peer_connect.peer1 == slave2_peer);
576 FAIL_TEST (event->details.peer_connect.peer2 == slave3_peer);
577 result = SLAVE2_SLAVE3_PEERS_CONNECTED;
578 GNUNET_TESTBED_operation_done (op);
579 op = NULL;
580 delay_task_id = GNUNET_SCHEDULER_add_delayed (
581 GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1),
582 &delay_task,
583 NULL);
584 break;
585
586 case SLAVE1_PEER_STOP_SUCCESS:
587 FAIL_TEST (GNUNET_TESTBED_ET_PEER_START == event->type);
588 FAIL_TEST (event->details.peer_start.host == slave2);
589 FAIL_TEST (event->details.peer_start.peer == slave2_peer);
590 GNUNET_TESTBED_operation_done (op);
591 result = SLAVE2_PEER_START_SUCCESS;
592 op =
593 GNUNET_TESTBED_overlay_connect (mc, NULL, NULL, master_peer, slave2_peer);
594 break;
595
596 case SLAVE2_PEER_START_SUCCESS:
597 FAIL_TEST (NULL != event);
598 FAIL_TEST (GNUNET_TESTBED_ET_CONNECT == event->type);
599 FAIL_TEST (event->details.peer_connect.peer1 == master_peer);
600 FAIL_TEST (event->details.peer_connect.peer2 == slave2_peer);
601 result = MASTER_SLAVE2_PEERS_CONNECTED;
602 GNUNET_TESTBED_operation_done (op);
603 op = NULL;
604 delay_task_id = GNUNET_SCHEDULER_add_delayed (
605 GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1),
606 &delay_task,
607 NULL);
608 break;
609
610 case SLAVE2_SLAVE3_PEERS_CONNECTED:
611 FAIL_TEST (GNUNET_TESTBED_ET_PEER_STOP == event->type);
612 FAIL_TEST (event->details.peer_stop.peer == slave2_peer);
613 GNUNET_TESTBED_operation_done (op);
614 result = SLAVE2_PEER_STOP_SUCCESS;
615 op = GNUNET_TESTBED_peer_destroy (slave1_peer);
616 FAIL_TEST (NULL != op);
617 break;
618
619 case SLAVE2_PEER_STOP_SUCCESS:
620 check_operation_success (event);
621 GNUNET_TESTBED_operation_done (op);
622 result = SLAVE1_PEER_DESTROY_SUCCESS;
623 op = GNUNET_TESTBED_peer_destroy (slave2_peer);
624 FAIL_TEST (NULL != op);
625 break;
626
627 case SLAVE1_PEER_DESTROY_SUCCESS:
628 check_operation_success (event);
629 GNUNET_TESTBED_operation_done (op);
630 op = NULL;
631 result = SLAVE2_PEER_DESTROY_SUCCESS;
632 op = GNUNET_TESTBED_get_slave_config (NULL, mc, slave3);
633 FAIL_TEST (NULL != op);
634 break;
635
636 case SLAVE2_PEER_DESTROY_SUCCESS:
637 FAIL_TEST (NULL != event);
638 FAIL_TEST (GNUNET_TESTBED_ET_OPERATION_FINISHED == event->type);
639 FAIL_TEST (event->op == op);
640 FAIL_TEST (NULL == event->op_cls);
641 FAIL_TEST (NULL == event->details.operation_finished.emsg);
642 cfg3 = GNUNET_CONFIGURATION_dup (event->details.operation_finished.generic);
643 GNUNET_TESTBED_operation_done (op);
644 result = SLAVE3_GET_CONFIG_SUCCESS;
645 op = GNUNET_TESTBED_controller_link (NULL, mc, slave3, slave, GNUNET_NO);
646 break;
647
648 case SLAVE3_REGISTERED:
649 check_operation_success (event);
650 GNUNET_TESTBED_operation_done (op);
651 result = SLAVE3_STARTED;
652 op = GNUNET_TESTBED_peer_create (mc, slave3, cfg, peer_create_cb, NULL);
653 FAIL_TEST (NULL != op);
654 break;
655
656 case SLAVE3_GET_CONFIG_SUCCESS:
657 result = SLAVE3_LINK_SUCCESS;
658 GNUNET_TESTBED_operation_done (op);
659 op = GNUNET_TESTBED_peer_destroy (master_peer);
660 break;
661
662 case SLAVE3_LINK_SUCCESS:
663 check_operation_success (event);
664 result = MASTER_PEER_DESTROY_SUCCESS;
665 GNUNET_TESTBED_operation_done (op);
666 op = GNUNET_TESTBED_peer_destroy (slave3_peer);
667 break;
668
669 case MASTER_PEER_DESTROY_SUCCESS:
670 result = SUCCESS;
671 GNUNET_TESTBED_operation_done (op);
672 op = NULL;
673 GNUNET_SCHEDULER_shutdown ();
674 break;
675
676 default:
677 FAIL_TEST (0);
678 }
679}
680
681
682/**
683 * Callback which will be called to after a host registration succeeded or failed
684 *
685 * @param cls the host which has been registered
686 * @param emsg the error message; NULL if host registration is successful
687 */
688static void
689registration_cont (void *cls, const char *emsg)
690{
691 rh = NULL;
692 switch (result)
693 {
694 case MASTER_PEER_START_SUCCESS:
695 FAIL_TEST (NULL == emsg);
696 FAIL_TEST (NULL != mc);
697 result = SLAVE1_REGISTERED;
698 slave2 = GNUNET_TESTBED_host_create_with_id (2, "127.0.0.1", NULL, cfg, 0);
699 FAIL_TEST (NULL != slave2);
700 rh = GNUNET_TESTBED_register_host (mc, slave2, &registration_cont, NULL);
701 FAIL_TEST (NULL != rh);
702 break;
703
704 case SLAVE1_REGISTERED:
705 FAIL_TEST (NULL == emsg);
706 FAIL_TEST (NULL != mc);
707 result = SLAVE2_REGISTERED;
708 FAIL_TEST (NULL != cfg);
709 op = GNUNET_TESTBED_controller_link (NULL, mc, slave, NULL, GNUNET_YES);
710 FAIL_TEST (NULL != op);
711 break;
712
713 case MASTER_SLAVE2_PEERS_CONNECTED:
714 FAIL_TEST (NULL == emsg);
715 FAIL_TEST (NULL != mc);
716 FAIL_TEST (NULL == op);
717 result = SLAVE3_REGISTERED;
718 op = GNUNET_TESTBED_controller_link (NULL, mc, slave3, NULL, GNUNET_YES);
719 FAIL_TEST (NULL != op);
720 break;
721
722 default:
723 GNUNET_break (0);
724 do_abort_now (NULL);
725 }
726}
727
728
729/**
730 * Callback to signal successful startup of the controller process
731 *
732 * @param cls the closure from GNUNET_TESTBED_controller_start()
733 * @param cfg the configuration with which the controller has been started;
734 * NULL if status is not GNUNET_OK
735 * @param status GNUNET_OK if the startup is successful; GNUNET_SYSERR if not,
736 * GNUNET_TESTBED_controller_stop() shouldn't be called in this case
737 */
738static void
739status_cb (void *cls,
740 const struct GNUNET_CONFIGURATION_Handle *config,
741 int status)
742{
743 switch (result)
744 {
745 case INIT:
746 FAIL_TEST (GNUNET_OK == status);
747 event_mask = 0;
748 event_mask |= (1L << GNUNET_TESTBED_ET_PEER_START);
749 event_mask |= (1L << GNUNET_TESTBED_ET_PEER_STOP);
750 event_mask |= (1L << GNUNET_TESTBED_ET_CONNECT);
751 event_mask |= (1L << GNUNET_TESTBED_ET_OPERATION_FINISHED);
752 mc = GNUNET_TESTBED_controller_connect (host,
753 event_mask,
754 &controller_cb,
755 NULL);
756 FAIL_TEST (NULL != mc);
757 result = MASTER_STARTED;
758 op = GNUNET_TESTBED_peer_create (mc, host, cfg, peer_create_cb, NULL);
759 FAIL_TEST (NULL != op);
760 break;
761
762 default:
763 GNUNET_break (0);
764 cp = NULL;
765 do_abort_now (NULL);
766 }
767}
768
769
770/**
771 * Callbacks of this type are called by #GNUNET_TESTBED_is_host_habitable to
772 * inform whether the given host is habitable or not. The Handle returned by
773 * GNUNET_TESTBED_is_host_habitable() is invalid after this callback is called
774 *
775 * @param cls NULL
776 * @param host the host whose status is being reported; will be NULL if the host
777 * given to GNUNET_TESTBED_is_host_habitable() is NULL
778 * @param status #GNUNET_YES if it is habitable; #GNUNET_NO if not
779 */
780static void
781host_habitable_cb (void *cls,
782 const struct GNUNET_TESTBED_Host *_host,
783 int status)
784{
785 hc_handle = NULL;
786 if (GNUNET_NO == status)
787 {
788 (void) printf ("%s",
789 "Unable to run the test as this system is not configured "
790 "to use password less SSH logins to localhost.\n"
791 "Skipping test\n");
792 GNUNET_SCHEDULER_cancel (abort_task);
793 abort_task = NULL;
794 GNUNET_SCHEDULER_shutdown ();
795 result = SKIP;
796 return;
797 }
798 cp = GNUNET_TESTBED_controller_start ("127.0.0.1", host, status_cb, NULL);
799}
800
801
802/**
803 * Main run function.
804 *
805 * @param cls NULL
806 * @param args arguments passed to #GNUNET_PROGRAM_run()
807 * @param cfgfile the path to configuration file
808 * @param cfg the configuration file handle
809 */
810static void
811run (void *cls,
812 char *const *args,
813 const char *cfgfile,
814 const struct GNUNET_CONFIGURATION_Handle *config)
815{
816 cfg = GNUNET_CONFIGURATION_dup (config);
817 host = GNUNET_TESTBED_host_create (NULL, NULL, cfg, 0);
818 FAIL_TEST (NULL != host);
819 if (NULL == (hc_handle = GNUNET_TESTBED_is_host_habitable (host,
820 config,
821 &host_habitable_cb,
822 NULL)))
823 {
824 GNUNET_TESTBED_host_destroy (host);
825 GNUNET_CONFIGURATION_destroy (cfg);
826 cfg = NULL;
827 host = NULL;
828 (void) printf ("%s",
829 "Unable to run the test as this system is not configured "
830 "to use password less SSH logins to localhost.\n"
831 "Marking test as successful\n");
832 result = SKIP;
833 return;
834 }
835 abort_task = GNUNET_SCHEDULER_add_delayed (
836 GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5),
837 &do_abort,
838 NULL);
839 GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL);
840}
841
842
843/**
844 * Main function
845 */
846int
847main (int argc, char **argv)
848{
849 char *const argv2[] = { "test_testbed_api_controllerlink",
850 "-c",
851 "test_testbed_api.conf",
852 NULL };
853 struct GNUNET_GETOPT_CommandLineOption options[] =
854 { GNUNET_GETOPT_OPTION_END };
855 int ret;
856
857 result = INIT;
858 ret = GNUNET_PROGRAM_run ((sizeof(argv2) / sizeof(char *)) - 1,
859 argv2,
860 "test_testbed_api_controllerlink",
861 "nohelp",
862 options,
863 &run,
864 NULL);
865 if (GNUNET_OK != ret)
866 return 1;
867 switch (result)
868 {
869 case SUCCESS:
870 return 0;
871
872 case SKIP:
873 return 77; /* Mark test as skipped */
874
875 default:
876 return 1;
877 }
878}
879
880
881/* end of test_testbed_api_controllerlink.c */
generated by cgit v1.2.3 (git 2.39.1) at 2024-04-27 09:25:06 +0000