aboutsummaryrefslogtreecommitdiff
path: root/src/testbed/gnunet-service-testbed.h
diff options
context:
space:
mode:
Diffstat (limited to 'src/testbed/gnunet-service-testbed.h')
-rw-r--r--src/testbed/gnunet-service-testbed.h900
1 files changed, 0 insertions, 900 deletions
diff --git a/src/testbed/gnunet-service-testbed.h b/src/testbed/gnunet-service-testbed.h
deleted file mode 100644
index 1c6aadb59..000000000
--- a/src/testbed/gnunet-service-testbed.h
+++ /dev/null
@@ -1,900 +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/gnunet-service-testbed.h
23 * @brief data structures shared amongst components of TESTBED service
24 * @author Sree Harsha Totakura
25 */
26
27#include "platform.h"
28#include "gnunet_util_lib.h"
29#include "gnunet_testbed_service.h"
30#include "gnunet_transport_service.h"
31#include "gnunet_core_service.h"
32
33#include "testbed.h"
34#include "testbed_api.h"
35#include "testbed_api_operations.h"
36#include "testbed_api_hosts.h"
37#include "gnunet_testing_lib.h"
38#include "gnunet-service-testbed_links.h"
39
40
41/**
42 * Generic logging
43 */
44#define LOG(kind, ...) \
45 GNUNET_log (kind, __VA_ARGS__)
46
47/**
48 * Debug logging
49 */
50#define LOG_DEBUG(...) \
51 LOG (GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__)
52
53/**
54 * By how much should the arrays lists grow
55 */
56#define LIST_GROW_STEP 10
57
58
59/**
60 * A routing entry
61 */
62struct Route
63{
64 /**
65 * destination host
66 */
67 uint32_t dest;
68
69 /**
70 * The destination host is reachable thru
71 */
72 uint32_t thru;
73};
74
75
76/**
77 * Context information for operations forwarded to subcontrollers
78 */
79struct ForwardedOperationContext
80{
81 /**
82 * The next pointer for DLL
83 */
84 struct ForwardedOperationContext *next;
85
86 /**
87 * The prev pointer for DLL
88 */
89 struct ForwardedOperationContext *prev;
90
91 /**
92 * The generated operation context
93 */
94 struct OperationContext *opc;
95
96 /**
97 * The client to which we have to reply
98 */
99 struct GNUNET_SERVICE_Client *client;
100
101 /**
102 * Closure pointer
103 */
104 void *cls;
105
106 /**
107 * Task ID for the timeout task
108 */
109 struct GNUNET_SCHEDULER_Task *timeout_task;
110
111 /**
112 * The id of the operation that has been forwarded
113 */
114 uint64_t operation_id;
115
116 /**
117 * The type of the operation which is forwarded
118 */
119 enum OperationType type;
120};
121
122
123/**
124 * A DLL of host registrations to be made
125 */
126struct HostRegistration
127{
128 /**
129 * next registration in the DLL
130 */
131 struct HostRegistration *next;
132
133 /**
134 * previous registration in the DLL
135 */
136 struct HostRegistration *prev;
137
138 /**
139 * The callback to call after this registration's status is available
140 */
141 GNUNET_TESTBED_HostRegistrationCompletion cb;
142
143 /**
144 * The closure for the above callback
145 */
146 void *cb_cls;
147
148 /**
149 * The host that has to be registered
150 */
151 struct GNUNET_TESTBED_Host *host;
152};
153
154
155/**
156 * Context information used while linking controllers
157 */
158struct LinkControllersContext
159{
160 /**
161 * The client which initiated the link controller operation
162 */
163 struct GNUNET_SERVICE_Client *client;
164
165 /**
166 * The ID of the operation
167 */
168 uint64_t operation_id;
169};
170
171
172/**
173 * A peer
174 */
175struct Peer
176{
177 union
178 {
179 struct
180 {
181 /**
182 * The peer handle from testing API
183 */
184 struct GNUNET_TESTING_Peer *peer;
185
186 /**
187 * The modified (by GNUNET_TESTING_peer_configure) configuration this
188 * peer is configured with
189 */
190 struct GNUNET_CONFIGURATION_Handle *cfg;
191
192 /**
193 * Is the peer running
194 */
195 int is_running;
196 } local;
197
198 struct
199 {
200 /**
201 * The slave this peer is started through
202 */
203 struct Slave *slave;
204
205 /**
206 * The id of the remote host this peer is running on
207 */
208 uint32_t remote_host_id;
209 } remote;
210 } details;
211
212 /**
213 * Is this peer locally created?
214 */
215 int is_remote;
216
217 /**
218 * Our local reference id for this peer
219 */
220 uint32_t id;
221
222 /**
223 * References to peers are using in forwarded overlay contexts and remote
224 * overlay connect contexts. A peer can only be destroyed after all such
225 * contexts are destroyed. For this, we maintain a reference counter. When we
226 * use a peer in any such context, we increment this counter. We decrement it
227 * when we are destroying these contexts
228 */
229 uint32_t reference_cnt;
230
231 /**
232 * While destroying a peer, due to the fact that there could be references to
233 * this peer, we delay the peer destroy to a further time. We do this by using
234 * this flag to destroy the peer while destroying a context in which this peer
235 * has been used. When the flag is set to 1 and reference_cnt = 0 we destroy
236 * the peer
237 */
238 uint32_t destroy_flag;
239};
240
241
242/**
243 * The main context information associated with the client which started us
244 */
245struct Context
246{
247 /**
248 * The client handle associated with this context
249 */
250 struct GNUNET_SERVICE_Client *client;
251
252 /**
253 * The network address of the master controller
254 */
255 char *master_ip;
256
257 /**
258 * The TESTING system handle for starting peers locally
259 */
260 struct GNUNET_TESTING_System *system;
261
262 /**
263 * Our host id according to this context
264 */
265 uint32_t host_id;
266};
267
268
269/**
270 * The structure for identifying a shared service
271 */
272struct SharedService
273{
274 /**
275 * The name of the shared service
276 */
277 char *name;
278
279 /**
280 * Number of shared peers per instance of the shared service
281 */
282 uint32_t num_shared;
283
284 /**
285 * Number of peers currently sharing the service
286 */
287 uint32_t num_sharing;
288};
289
290
291struct RegisteredHostContext;
292
293
294/**
295 * Context information to used during operations which forward the overlay
296 * connect message
297 */
298struct ForwardedOverlayConnectContext
299{
300 /**
301 * next ForwardedOverlayConnectContext in the DLL
302 */
303 struct ForwardedOverlayConnectContext *next;
304
305 /**
306 * previous ForwardedOverlayConnectContext in the DLL
307 */
308 struct ForwardedOverlayConnectContext *prev;
309
310 /**
311 * Which host does this FOCC belong to?
312 */
313 struct RegisteredHostContext *rhc;
314
315 /**
316 * A copy of the original overlay connect message
317 */
318 struct GNUNET_MessageHeader *orig_msg;
319
320 /**
321 * The client handle
322 */
323 struct GNUNET_SERVICE_Client *client;
324
325 /**
326 * The id of the operation which created this context information
327 */
328 uint64_t operation_id;
329
330 /**
331 * the id of peer 1
332 */
333 uint32_t peer1;
334
335 /**
336 * The id of peer 2
337 */
338 uint32_t peer2;
339
340 /**
341 * Id of the host where peer2 is running
342 */
343 uint32_t peer2_host_id;
344};
345
346
347/**
348 * This context information will be created for each host that is registered at
349 * slave controllers during overlay connects.
350 */
351struct RegisteredHostContext
352{
353 /**
354 * The host which is being registered
355 */
356 struct GNUNET_TESTBED_Host *reg_host;
357
358 /**
359 * The host of the controller which has to connect to the above rhost
360 */
361 struct GNUNET_TESTBED_Host *host;
362
363 /**
364 * Head of the ForwardedOverlayConnectContext DLL
365 */
366 struct ForwardedOverlayConnectContext *focc_dll_head;
367
368 /**
369 * Tail of the ForwardedOverlayConnectContext DLL
370 */
371 struct ForwardedOverlayConnectContext *focc_dll_tail;
372
373 /**
374 * Enumeration of states for this context
375 */
376 enum RHCState
377 {
378 /**
379 * The initial state
380 */
381 RHC_INIT = 0,
382
383 /**
384 * State where we attempt to do the overlay connection again
385 */
386 RHC_DONE
387 } state;
388};
389
390
391/**
392 * Context data for #GNUNET_MESSAGE_TYPE_TESTBED_SHUTDOWN_PEERS handler
393 */
394struct HandlerContext_ShutdownPeers
395{
396 /**
397 * The number of slave we expect to hear from since we forwarded the
398 * #GNUNET_MESSAGE_TYPE_TESTBED_SHUTDOWN_PEERS message to them
399 */
400 unsigned int nslaves;
401
402 /**
403 * Did we observe a timeout with respect to this operation at any of the
404 * slaves
405 */
406 int timeout;
407};
408
409
410/**
411 * Our configuration
412 */
413extern struct GNUNET_CONFIGURATION_Handle *GST_config;
414
415/**
416 * The master context; generated with the first INIT message
417 */
418extern struct Context *GST_context;
419
420/**
421 * DLL head for forwarded operation contexts
422 */
423extern struct ForwardedOperationContext *fopcq_head;
424
425/**
426 * DLL tail for forwarded operation contexts
427 */
428extern struct ForwardedOperationContext *fopcq_tail;
429
430/**
431 * A list of peers we know about
432 */
433extern struct Peer **GST_peer_list;
434
435/**
436 * Array of hosts
437 */
438extern struct GNUNET_TESTBED_Host **GST_host_list;
439
440/**
441 * Operation queue for open file descriptors
442 */
443extern struct OperationQueue *GST_opq_openfds;
444
445/**
446 * Timeout for operations which may take some time
447 */
448extern struct GNUNET_TIME_Relative GST_timeout;
449
450/**
451 * The size of the peer list
452 */
453extern unsigned int GST_peer_list_size;
454
455/**
456 * The current number of peers running locally under this controller
457 */
458extern unsigned int GST_num_local_peers;
459
460/**
461 * The size of the host list
462 */
463extern unsigned int GST_host_list_size;
464
465/**
466 * The directory where to store load statistics data
467 */
468extern char *GST_stats_dir;
469
470/**
471 * Condition to check if host id is valid
472 */
473#define VALID_HOST_ID(id) \
474 (((id) < GST_host_list_size) && (NULL != GST_host_list[id]))
475
476/**
477 * Condition to check if peer id is valid
478 */
479#define VALID_PEER_ID(id) \
480 (((id) < GST_peer_list_size) && (NULL != GST_peer_list[id]))
481
482
483/**
484 * Similar to GNUNET_array_grow(); however instead of calling GNUNET_array_grow()
485 * several times we call it only once. The array is also made to grow in steps
486 * of LIST_GROW_STEP.
487 *
488 * @param ptr the array pointer to grow
489 * @param size the size of array
490 * @param accommodate_size the size which the array has to accommdate; after
491 * this call the array will be big enough to accommdate sizes up to
492 * accommodate_size
493 */
494#define GST_array_grow_large_enough(ptr, size, accommodate_size) \
495 do \
496 { \
497 unsigned int growth_size; \
498 GNUNET_assert (size <= accommodate_size); \
499 growth_size = size; \
500 while (growth_size <= accommodate_size) \
501 growth_size += LIST_GROW_STEP; \
502 GNUNET_array_grow (ptr, size, growth_size); \
503 GNUNET_assert (size > accommodate_size); \
504 } while (0)
505
506
507/**
508 * Function to destroy a peer
509 *
510 * @param peer the peer structure to destroy
511 */
512void
513GST_destroy_peer (struct Peer *peer);
514
515
516/**
517 * Stops and destroys all peers
518 */
519void
520GST_destroy_peers (void);
521
522
523/**
524 * Finds the route with directly connected host as destination through which
525 * the destination host can be reached
526 *
527 * @param host_id the id of the destination host
528 * @return the route with directly connected destination host; NULL if no route
529 * is found
530 */
531struct Route *
532GST_find_dest_route (uint32_t host_id);
533
534
535/**
536 * Handler for #GNUNET_MESSAGE_TYPE_TESTBED_OVERLAY_CONNECT messages
537 *
538 * @param cls identification of the client
539 * @param msg the actual message
540 */
541void
542handle_overlay_connect (void *cls,
543 const struct GNUNET_TESTBED_OverlayConnectMessage *msg);
544
545
546/**
547 * Adds a host registration's request to a slave's registration queue
548 *
549 * @param slave the slave controller at which the given host has to be
550 * registered
551 * @param cb the host registration completion callback
552 * @param cb_cls the closure for the host registration completion callback
553 * @param host the host which has to be registered
554 */
555void
556GST_queue_host_registration (struct Slave *slave,
557 GNUNET_TESTBED_HostRegistrationCompletion cb,
558 void *cb_cls, struct GNUNET_TESTBED_Host *host);
559
560
561/**
562 * Callback to relay the reply msg of a forwarded operation back to the client
563 *
564 * @param cls ForwardedOperationContext
565 * @param msg the message to relay
566 */
567void
568GST_forwarded_operation_reply_relay (void *cls,
569 const struct GNUNET_MessageHeader *msg);
570
571
572/**
573 * Task to free resources when forwarded operation has been timedout
574 *
575 * @param cls the ForwardedOperationContext
576 * @param tc the task context from scheduler
577 */
578void
579GST_forwarded_operation_timeout (void *cls);
580
581
582/**
583 * Clears the forwarded operations queue
584 */
585void
586GST_clear_fopcq (void);
587
588
589/**
590 * Send operation failure message to client
591 *
592 * @param client the client to which the failure message has to be sent to
593 * @param operation_id the id of the failed operation
594 * @param emsg the error message; can be NULL
595 */
596void
597GST_send_operation_fail_msg (struct GNUNET_SERVICE_Client *client,
598 uint64_t operation_id,
599 const char *emsg);
600
601
602/**
603 * Notify OC subsystem that @a client disconnected.
604 *
605 * @param client the client that disconnected
606 */
607void
608GST_notify_client_disconnect_oc (struct GNUNET_SERVICE_Client *client);
609
610
611/**
612 * Notify peers subsystem that @a client disconnected.
613 *
614 * @param client the client that disconnected
615 */
616void
617GST_notify_client_disconnect_peers (struct GNUNET_SERVICE_Client *client);
618
619
620/**
621 * Function to send generic operation success message to given client
622 *
623 * @param client the client to send the message to
624 * @param operation_id the id of the operation which was successful
625 */
626void
627GST_send_operation_success_msg (struct GNUNET_SERVICE_Client *client,
628 uint64_t operation_id);
629
630
631/**
632 * Check #GNUNET_MESSAGE_TYPE_TESTBED_REMOTE_OVERLAY_CONNECT messages
633 *
634 * @param cls identification of the client
635 * @param msg the actual message
636 * @return #GNUNET_OK if @a msg is well-formed
637 */
638int
639check_remote_overlay_connect (void *cls,
640 const struct
641 GNUNET_TESTBED_RemoteOverlayConnectMessage *msg);
642
643
644/**
645 * Handler for #GNUNET_MESSAGE_TYPE_TESTBED_REMOTE_OVERLAY_CONNECT messages
646 *
647 * @param cls identification of the client
648 * @param msg the actual message
649 */
650void
651handle_remote_overlay_connect (void *cls,
652 const struct
653 GNUNET_TESTBED_RemoteOverlayConnectMessage *msg);
654
655
656/**
657 * Check #GNUNET_MESSAGE_TYPE_TESTBED_CREATEPEER messages
658 *
659 * @param cls identification of the client
660 * @param msg the actual message
661 * @return #GNUNET_OK if @a msg is well-formed
662 */
663int
664check_peer_create (void *cls,
665 const struct GNUNET_TESTBED_PeerCreateMessage *msg);
666
667
668/**
669 * Handler for #GNUNET_MESSAGE_TYPE_TESTBED_CREATEPEER messages
670 *
671 * @param cls identification of the client
672 * @param message the actual message
673 */
674void
675handle_peer_create (void *cls,
676 const struct GNUNET_TESTBED_PeerCreateMessage *msg);
677
678
679/**
680 * Message handler for #GNUNET_MESSAGE_TYPE_TESTBED_DESTROYPEER messages
681 *
682 * @param cls identification of the client
683 * @param msg the actual message
684 */
685void
686handle_peer_destroy (void *cls,
687 const struct GNUNET_TESTBED_PeerDestroyMessage *msg);
688
689
690/**
691 * Message handler for #GNUNET_MESSAGE_TYPE_TESTBED_DESTROYPEER messages
692 *
693 * @param cls identification of the client
694 * @param msg the actual message
695 */
696void
697handle_peer_start (void *cls,
698 const struct GNUNET_TESTBED_PeerStartMessage *msg);
699
700
701/**
702 * Message handler for #GNUNET_MESSAGE_TYPE_TESTBED_DESTROYPEER messages
703 *
704 * @param cls identification of the client
705 * @param message the actual message
706 */
707void
708handle_peer_stop (void *cls,
709 const struct GNUNET_TESTBED_PeerStopMessage *msg);
710
711
712/**
713 * Handler for #GNUNET_MESSAGE_TYPE_TESTBED_GETPEERCONFIG messages
714 *
715 * @param cls identification of the client
716 * @param msg the actual message
717 */
718void
719handle_peer_get_config (void *cls,
720 const struct
721 GNUNET_TESTBED_PeerGetConfigurationMessage *msg);
722
723
724/**
725 * Handler for #GNUNET_MESSAGE_TYPE_TESTBED_SHUTDOWN_PEERS messages
726 *
727 * @param cls identification of the client
728 * @param msg the actual message
729 */
730void
731handle_shutdown_peers (void *cls,
732 const struct GNUNET_TESTBED_ShutdownPeersMessage *msg);
733
734
735/**
736 * Check #GNUNET_MESSAGE_TYPE_TESTBED_MANAGE_PEER_SERVICE message
737 *
738 * @param cls identification of client
739 * @param msg the actual message
740 * @return #GNUNET_OK if @a msg is well-formed
741 */
742int
743check_manage_peer_service (void *cls,
744 const struct
745 GNUNET_TESTBED_ManagePeerServiceMessage *msg);
746
747
748/**
749 * Handler for #GNUNET_MESSAGE_TYPE_TESTBED_MANAGE_PEER_SERVICE message
750 *
751 * @param cls identification of client
752 * @param msg the actual message
753 */
754void
755handle_manage_peer_service (void *cls,
756 const struct
757 GNUNET_TESTBED_ManagePeerServiceMessage *msg);
758
759
760/**
761 * Check #GNUNET_MESSAGE_TYPDE_TESTBED_RECONFIGURE_PEER type messages.
762 *
763 * @param cls identification of the client
764 * @param msg the actual message
765 * @return #GNUNET_OK if @a msg is well-formed
766 */
767int
768check_peer_reconfigure (void *cls,
769 const struct
770 GNUNET_TESTBED_PeerReconfigureMessage *msg);
771
772
773/**
774 * Handler for #GNUNET_MESSAGE_TYPDE_TESTBED_RECONFIGURE_PEER type messages.
775 * Should stop the peer asynchronously, destroy it and create it again with the
776 * new configuration.
777 *
778 * @param cls identification of the client
779 * @param msg the actual message
780 */
781void
782handle_peer_reconfigure (void *cls,
783 const struct
784 GNUNET_TESTBED_PeerReconfigureMessage *msg);
785
786
787/**
788 * Frees the ManageServiceContext queue
789 */
790void
791GST_free_mctxq (void);
792
793
794/**
795 * Cleans up the queue used for forwarding link controllers requests
796 */
797void
798GST_free_lcf (void);
799
800
801/**
802 * Cleans up the route list
803 */
804void
805GST_route_list_clear (void);
806
807
808/**
809 * Processes a forwarded overlay connect context in the queue of the given RegisteredHostContext
810 *
811 * @param rhc the RegisteredHostContext
812 */
813void
814GST_process_next_focc (struct RegisteredHostContext *rhc);
815
816
817/**
818 * Cleans up ForwardedOverlayConnectContext
819 *
820 * @param focc the ForwardedOverlayConnectContext to cleanup
821 */
822void
823GST_cleanup_focc (struct ForwardedOverlayConnectContext *focc);
824
825
826/**
827 * Clears all pending overlay connect contexts in queue
828 */
829void
830GST_free_occq (void);
831
832
833/**
834 * Clears all pending remote overlay connect contexts in queue
835 */
836void
837GST_free_roccq (void);
838
839
840/**
841 * Cleans up the Peer reconfigure context list
842 */
843void
844GST_free_prcq (void);
845
846
847/**
848 * Initializes the cache
849 *
850 * @param size the size of the cache
851 */
852void
853GST_cache_init (unsigned int size);
854
855
856/**
857 * Clear cache
858 */
859void
860GST_cache_clear (void);
861
862
863/**
864 * Looks up in the hello cache and returns the HELLO of the given peer
865 *
866 * @param peer_id the index of the peer whose HELLO has to be looked up
867 * @return the HELLO message; NULL if not found
868 */
869const struct GNUNET_MessageHeader *
870GST_cache_lookup_hello (const unsigned int peer_id);
871
872
873/**
874 * Caches the HELLO of the given peer. Updates the HELLO if it was already
875 * cached before
876 *
877 * @param peer_id the peer identity of the peer whose HELLO has to be cached
878 * @param hello the HELLO message
879 */
880void
881GST_cache_add_hello (const unsigned int peer_id,
882 const struct GNUNET_MessageHeader *hello);
883
884
885/**
886 * Initialize logging CPU and IO statisticfs. Checks the configuration for
887 * "STATS_DIR" and logs to a file in that directory. The file is name is
888 * generated from the hostname and the process's PID.
889 */
890void
891GST_stats_init (const struct GNUNET_CONFIGURATION_Handle *cfg);
892
893
894/**
895 * Shutdown the status calls module.
896 */
897void
898GST_stats_destroy (void);
899
900/* End of gnunet-service-testbed.h */