aboutsummaryrefslogtreecommitdiff
path: root/src/transport
diff options
context:
space:
mode:
authorChristian Grothoff <christian@grothoff.org>2019-12-25 14:07:10 +0100
committerChristian Grothoff <christian@grothoff.org>2019-12-25 14:07:10 +0100
commit92d278e49fff3d202e827a78b2e58f3ca9e2b6ec (patch)
treef38aeddeb3a235d73c9ddff4bb368498e27311a5 /src/transport
parent6e489113f724f19d683963be0382d61291a5bef9 (diff)
downloadgnunet-92d278e49fff3d202e827a78b2e58f3ca9e2b6ec.tar.gz
gnunet-92d278e49fff3d202e827a78b2e58f3ca9e2b6ec.zip
allow multiple iterations, more code cleanup
Diffstat (limited to 'src/transport')
-rw-r--r--src/transport/test_communicator_basic.c193
-rw-r--r--src/transport/transport-testing2.c59
2 files changed, 150 insertions, 102 deletions
diff --git a/src/transport/test_communicator_basic.c b/src/transport/test_communicator_basic.c
index 0bca5f695..5d69b21b3 100644
--- a/src/transport/test_communicator_basic.c
+++ b/src/transport/test_communicator_basic.c
@@ -43,6 +43,8 @@
43 43
44static struct GNUNET_SCHEDULER_Task *to_task; 44static struct GNUNET_SCHEDULER_Task *to_task;
45 45
46static struct GNUNET_SCHEDULER_Task *active_task;
47
46static int queue_est = GNUNET_NO; 48static int queue_est = GNUNET_NO;
47 49
48static struct GNUNET_PeerIdentity peer_id[NUM_PEERS]; 50static struct GNUNET_PeerIdentity peer_id[NUM_PEERS];
@@ -70,7 +72,11 @@ static struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorQueue *my_tc;
70 72
71#define BURST_PACKETS 5000 73#define BURST_PACKETS 5000
72 74
73#define BURST_RUNS 1 75#define FIXME_DEAD_BURST_RUNS 1
76
77#define TOTAL_ITERATIONS 10
78
79static unsigned int iterations_left = TOTAL_ITERATIONS;
74 80
75#define SHORT_BURST_WINDOW \ 81#define SHORT_BURST_WINDOW \
76 GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,2) 82 GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,2)
@@ -98,6 +104,7 @@ static uint64_t avg_latency = 0;
98 104
99static struct GNUNET_TIME_Relative duration; 105static struct GNUNET_TIME_Relative duration;
100 106
107
101static void 108static void
102communicator_available_cb (void *cls, 109communicator_available_cb (void *cls,
103 struct 110 struct
@@ -172,9 +179,10 @@ queue_create_reply_cb (void *cls,
172static char* 179static char*
173make_payload (size_t payload_size) 180make_payload (size_t payload_size)
174{ 181{
175 char *payload = GNUNET_malloc (payload_size);
176 struct GNUNET_TIME_Absolute ts; 182 struct GNUNET_TIME_Absolute ts;
177 struct GNUNET_TIME_AbsoluteNBO ts_n; 183 struct GNUNET_TIME_AbsoluteNBO ts_n;
184 char *payload = GNUNET_malloc (payload_size);
185
178 GNUNET_assert (payload_size >= 8); // So that out timestamp fits 186 GNUNET_assert (payload_size >= 8); // So that out timestamp fits
179 ts = GNUNET_TIME_absolute_get (); 187 ts = GNUNET_TIME_absolute_get ();
180 ts_n = GNUNET_TIME_absolute_hton (ts); 188 ts_n = GNUNET_TIME_absolute_hton (ts);
@@ -187,11 +195,11 @@ make_payload (size_t payload_size)
187static void 195static void
188latency_timeout (void *cls) 196latency_timeout (void *cls)
189{ 197{
198 to_task = NULL;
190 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 199 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
191 "Latency too high. Test failed. (Phase: %d. Received: %lu\n", 200 "Latency too high. Test failed. (Phase: %d. Received: %lu\n",
192 phase, num_received); 201 phase, num_received);
193 ret = 2; 202 ret = 2;
194 to_task = NULL;
195 GNUNET_SCHEDULER_shutdown (); 203 GNUNET_SCHEDULER_shutdown ();
196} 204}
197 205
@@ -201,23 +209,24 @@ size_test (void *cls)
201{ 209{
202 char *payload; 210 char *payload;
203 211
204 phase = TP_SIZE_CHECK; 212 active_task = NULL;
205 if (ack < 64000) // Leave some room for our protocol. 213 GNUNET_assert (TP_SIZE_CHECK == phase);
206 { 214 if (ack >= 64000)
207 payload = make_payload (ack); 215 return; /* Leave some room for our protocol, so not 2^16 exactly */
208 GNUNET_TRANSPORT_TESTING_transport_communicator_send (my_tc, 216 payload = make_payload (ack);
209 payload, 217 GNUNET_TRANSPORT_TESTING_transport_communicator_send (my_tc,
210 ack); 218 payload,
211 GNUNET_free (payload); 219 ack);
212 ack += 5; 220 GNUNET_free (payload);
213 num_sent++; 221 ack += 5;
214 if (NULL == to_task) 222 num_sent++;
215 to_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, 223 if (NULL == to_task)
216 &latency_timeout, 224 to_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
217 NULL); 225 &latency_timeout,
218 if (ack < 64000) 226 NULL);
219 GNUNET_SCHEDULER_add_now (&size_test, NULL); 227 if (ack < 64000)
220 } 228 active_task = GNUNET_SCHEDULER_add_now (&size_test,
229 NULL);
221} 230}
222 231
223 232
@@ -226,25 +235,21 @@ long_test (void *cls)
226{ 235{
227 char *payload; 236 char *payload;
228 237
229 if (num_sent < BURST_PACKETS) 238 active_task = NULL;
230 { 239 payload = make_payload (LONG_MESSAGE_SIZE);
231 payload = make_payload (LONG_MESSAGE_SIZE); 240 GNUNET_TRANSPORT_TESTING_transport_communicator_send (my_tc,
232 GNUNET_TRANSPORT_TESTING_transport_communicator_send (my_tc, 241 payload,
233 payload, 242 LONG_MESSAGE_SIZE);
234 LONG_MESSAGE_SIZE); 243 num_sent++;
235 num_sent++; 244 GNUNET_free (payload);
236 GNUNET_free (payload); 245 if (NULL == to_task)
237 if (NULL == to_task) 246 to_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
238 to_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, 247 &latency_timeout,
239 &latency_timeout, 248 NULL);
240 NULL); 249 if (num_sent == BURST_PACKETS)
241
242 GNUNET_SCHEDULER_add_now (&long_test, NULL);
243 // if (num_sent == BURST_PACKETS)
244 // GNUNET_SCHEDULER_add_delayed (LONG_BURST_WINDOW,
245 // &long_test, NULL);
246 return; 250 return;
247 } 251 active_task = GNUNET_SCHEDULER_add_now (&long_test,
252 NULL);
248} 253}
249 254
250 255
@@ -252,26 +257,22 @@ static void
252short_test (void *cls) 257short_test (void *cls)
253{ 258{
254 char *payload; 259 char *payload;
255 if (num_sent < BURST_PACKETS) 260
256 { 261 active_task = NULL;
257 payload = make_payload (SHORT_MESSAGE_SIZE); 262 payload = make_payload (SHORT_MESSAGE_SIZE);
258 GNUNET_TRANSPORT_TESTING_transport_communicator_send (my_tc, 263 GNUNET_TRANSPORT_TESTING_transport_communicator_send (my_tc,
259 payload, 264 payload,
260 SHORT_MESSAGE_SIZE); 265 SHORT_MESSAGE_SIZE);
261 num_sent++; 266 num_sent++;
262 GNUNET_free (payload); 267 GNUNET_free (payload);
263 if (NULL == to_task) 268 if (NULL == to_task)
264 to_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, 269 to_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
265 &latency_timeout, 270 &latency_timeout,
266 NULL); 271 NULL);
267 272 if (num_sent >= BURST_PACKETS)
268 GNUNET_SCHEDULER_add_now (&short_test, NULL); 273 return;
269 /*if (num_sent == BURST_PACKETS) 274 active_task = GNUNET_SCHEDULER_add_now (&short_test,
270 { 275 NULL);
271 GNUNET_SCHEDULER_add_delayed (SHORT_BURST_WINDOW,
272 &short_test, NULL);
273 return;
274 }*/}
275} 276}
276 277
277 278
@@ -299,7 +300,9 @@ add_queue_cb (void *cls,
299 start_short = GNUNET_TIME_absolute_get (); 300 start_short = GNUNET_TIME_absolute_get ();
300 my_tc = tc_queue; 301 my_tc = tc_queue;
301 phase = TP_BURST_SHORT; 302 phase = TP_BURST_SHORT;
302 GNUNET_SCHEDULER_add_now (&short_test, tc_queue); 303 GNUNET_assert (NULL == active_task);
304 active_task = GNUNET_SCHEDULER_add_now (&short_test,
305 NULL);
303} 306}
304 307
305 308
@@ -371,10 +374,13 @@ incoming_message_cb (void *cls,
371 num_sent = 0; 374 num_sent = 0;
372 avg_latency = 0; 375 avg_latency = 0;
373 num_received = 0; 376 num_received = 0;
374 GNUNET_SCHEDULER_cancel (to_task); 377 if (NULL != to_task)
375 to_task = NULL; 378 {
376 GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, &long_test, 379 GNUNET_SCHEDULER_cancel (to_task);
377 NULL); 380 to_task = NULL;
381 }
382 active_task = GNUNET_SCHEDULER_add_now (&long_test,
383 NULL);
378 } 384 }
379 break; 385 break;
380 } 386 }
@@ -408,10 +414,13 @@ incoming_message_cb (void *cls,
408 num_received = 0; 414 num_received = 0;
409 num_sent = 0; 415 num_sent = 0;
410 avg_latency = 0; 416 avg_latency = 0;
411 GNUNET_SCHEDULER_cancel (to_task); 417 if (NULL != to_task)
412 to_task = NULL; 418 {
413 GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, &size_test, 419 GNUNET_SCHEDULER_cancel (to_task);
414 NULL); 420 to_task = NULL;
421 }
422 active_task = GNUNET_SCHEDULER_add_now (&size_test,
423 NULL);
415 } 424 }
416 break; 425 break;
417 } 426 }
@@ -428,18 +437,30 @@ incoming_message_cb (void *cls,
428 (unsigned long) num_received, 437 (unsigned long) num_received,
429 (unsigned long) num_sent, 438 (unsigned long) num_sent,
430 (unsigned long long) avg_latency); 439 (unsigned long long) avg_latency);
440 num_received = 0;
441 num_sent = 0;
442 avg_latency = 0;
443 if (NULL != to_task)
444 {
445 GNUNET_SCHEDULER_cancel (to_task);
446 to_task = NULL;
447 }
448 iterations_left--;
449 if (0 != iterations_left)
450 {
451 phase = TP_BURST_SHORT;
452 active_task = GNUNET_SCHEDULER_add_now (&short_test,
453 NULL);
454 break;
455 }
431 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 456 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
432 "Finished\n"); 457 "Finished\n");
433 GNUNET_SCHEDULER_cancel (to_task);
434 to_task = NULL;
435 GNUNET_SCHEDULER_shutdown (); 458 GNUNET_SCHEDULER_shutdown ();
436 // Finished!
437 // }
438 } 459 }
439 break; 460 break;
440 } 461 }
441 } 462 }
442 // Reset timeout 463 /* Reset timeout */
443 if (NULL != to_task) 464 if (NULL != to_task)
444 { 465 {
445 GNUNET_SCHEDULER_cancel (to_task); 466 GNUNET_SCHEDULER_cancel (to_task);
@@ -450,6 +471,22 @@ incoming_message_cb (void *cls,
450} 471}
451 472
452 473
474static void
475do_shutdown (void *cls)
476{
477 if (NULL != to_task)
478 {
479 GNUNET_SCHEDULER_cancel (to_task);
480 to_task = NULL;
481 }
482 if (NULL != active_task)
483 {
484 GNUNET_SCHEDULER_cancel (active_task);
485 active_task = NULL;
486 }
487}
488
489
453/** 490/**
454 * @brief Main function called by the scheduler 491 * @brief Main function called by the scheduler
455 * 492 *
@@ -474,6 +511,8 @@ run (void *cls)
474 &incoming_message_cb, 511 &incoming_message_cb,
475 cfg_peers_name[i]); /* cls */ 512 cfg_peers_name[i]); /* cls */
476 } 513 }
514 GNUNET_SCHEDULER_add_shutdown (&do_shutdown,
515 NULL);
477} 516}
478 517
479 518
@@ -487,11 +526,13 @@ main (int argc,
487 526
488 ret = 1; 527 ret = 1;
489 communicator_name = GNUNET_TESTING_get_testname_from_underscore (argv[0]); 528 communicator_name = GNUNET_TESTING_get_testname_from_underscore (argv[0]);
490 GNUNET_asprintf (&communicator_binary, "gnunet-communicator-%s", 529 GNUNET_asprintf (&communicator_binary,
530 "gnunet-communicator-%s",
491 communicator_name); 531 communicator_name);
492 if (GNUNET_OK != GNUNET_log_setup ("test_communicator_basic", 532 if (GNUNET_OK !=
493 "DEBUG", 533 GNUNET_log_setup ("test_communicator_basic",
494 "test_communicator_basic.log")) 534 "DEBUG",
535 NULL))
495 { 536 {
496 fprintf (stderr, "Unable to setup log\n"); 537 fprintf (stderr, "Unable to setup log\n");
497 GNUNET_break (0); 538 GNUNET_break (0);
diff --git a/src/transport/transport-testing2.c b/src/transport/transport-testing2.c
index 558bf007f..22a767fce 100644
--- a/src/transport/transport-testing2.c
+++ b/src/transport/transport-testing2.c
@@ -370,9 +370,9 @@ handle_incoming_msg (void *cls,
370{ 370{
371 struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h = cls; 371 struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h = cls;
372 struct GNUNET_MessageHeader *msg; 372 struct GNUNET_MessageHeader *msg;
373 msg = (struct GNUNET_MessageHeader *)&inc_msg[1]; 373 msg = (struct GNUNET_MessageHeader *) &inc_msg[1];
374 size_t payload_len = ntohs (msg->size) - sizeof (struct 374 size_t payload_len = ntohs (msg->size) - sizeof (struct
375 GNUNET_MessageHeader); 375 GNUNET_MessageHeader);
376 376
377 if (NULL != tc_h->incoming_msg_cb) 377 if (NULL != tc_h->incoming_msg_cb)
378 { 378 {
@@ -536,7 +536,6 @@ connect_cb (void *cls,
536 struct GNUNET_MQ_Handle *mq) 536 struct GNUNET_MQ_Handle *mq)
537{ 537{
538 struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h = cls; 538 struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h = cls;
539 struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorQueue *tc_queue_iter;
540 539
541 LOG (GNUNET_ERROR_TYPE_DEBUG, "Client connected.\n"); 540 LOG (GNUNET_ERROR_TYPE_DEBUG, "Client connected.\n");
542 tc_h->client = client; 541 tc_h->client = client;
@@ -545,13 +544,18 @@ connect_cb (void *cls,
545 if (NULL == tc_h->queue_head) 544 if (NULL == tc_h->queue_head)
546 return tc_h; 545 return tc_h;
547 /* Iterate over queues. They are yet to be opened. Request opening. */ 546 /* Iterate over queues. They are yet to be opened. Request opening. */
548 while (NULL != (tc_queue_iter = tc_h->queue_head)) 547 for (struct
548 GNUNET_TRANSPORT_TESTING_TransportCommunicatorQueue *tc_queue_iter =
549 tc_h->queue_head;
550 NULL != tc_queue_iter;
551 tc_queue_iter = tc_queue_iter->next)
549 { 552 {
550 if (NULL == tc_queue_iter->open_queue_env) 553 if (NULL == tc_queue_iter->open_queue_env)
551 continue; 554 continue;
552 /* Send the previously created mq envelope to request the creation of the 555 /* Send the previously created mq envelope to request the creation of the
553 * queue. */ 556 * queue. */
554 GNUNET_MQ_send (tc_h->c_mq, tc_queue_iter->open_queue_env); 557 GNUNET_MQ_send (tc_h->c_mq,
558 tc_queue_iter->open_queue_env);
555 tc_queue_iter->open_queue_env = NULL; 559 tc_queue_iter->open_queue_env = NULL;
556 } 560 }
557 return tc_h; 561 return tc_h;
@@ -576,6 +580,7 @@ disconnect_cb (void *cls,
576 tc_h->client = NULL; 580 tc_h->client = NULL;
577} 581}
578 582
583
579/** 584/**
580 * Message was transmitted. Process the request. 585 * Message was transmitted. Process the request.
581 * 586 *
@@ -588,11 +593,10 @@ handle_send_message_ack (void *cls,
588{ 593{
589 struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h = cls; 594 struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h = cls;
590 GNUNET_SERVICE_client_continue (tc_h->client); 595 GNUNET_SERVICE_client_continue (tc_h->client);
591 //NOP 596 // NOP
592} 597}
593 598
594 599
595
596/** 600/**
597 * @brief Start the communicator part of the transport service 601 * @brief Start the communicator part of the transport service
598 * 602 *
@@ -650,11 +654,11 @@ transport_communicator_start (
650 654
651 655
652 tc_h->sh = GNUNET_SERVICE_start ("transport", 656 tc_h->sh = GNUNET_SERVICE_start ("transport",
653 tc_h->cfg, 657 tc_h->cfg,
654 &connect_cb, 658 &connect_cb,
655 &disconnect_cb, 659 &disconnect_cb,
656 tc_h, 660 tc_h,
657 mh); 661 mh);
658 GNUNET_assert (NULL != tc_h->sh); 662 GNUNET_assert (NULL != tc_h->sh);
659} 663}
660 664
@@ -680,11 +684,12 @@ shutdown_process (struct GNUNET_OS_Process *proc)
680 GNUNET_OS_process_destroy (proc); 684 GNUNET_OS_process_destroy (proc);
681} 685}
682 686
687
683static void 688static void
684shutdown_communicator (void *cls) 689shutdown_communicator (void *cls)
685{ 690{
686 struct GNUNET_OS_Process *proc = cls; 691 struct GNUNET_OS_Process *proc = cls;
687 shutdown_process(proc); 692 shutdown_process (proc);
688} 693}
689 694
690 695
@@ -721,6 +726,7 @@ communicator_start (
721 GNUNET_free (binary); 726 GNUNET_free (binary);
722} 727}
723 728
729
724/** 730/**
725 * @brief Task run at shutdown to kill communicator and clean up 731 * @brief Task run at shutdown to kill communicator and clean up
726 * 732 *
@@ -747,15 +753,15 @@ nat_start (
747 LOG (GNUNET_ERROR_TYPE_DEBUG, "nat_start\n"); 753 LOG (GNUNET_ERROR_TYPE_DEBUG, "nat_start\n");
748 binary = GNUNET_OS_get_libexec_binary_path ("gnunet-service-nat"); 754 binary = GNUNET_OS_get_libexec_binary_path ("gnunet-service-nat");
749 tc_h->nat_proc = GNUNET_OS_start_process (GNUNET_YES, 755 tc_h->nat_proc = GNUNET_OS_start_process (GNUNET_YES,
750 GNUNET_OS_INHERIT_STD_OUT_AND_ERR, 756 GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
751 NULL, 757 NULL,
752 NULL, 758 NULL,
753 NULL, 759 NULL,
754 binary, 760 binary,
755 "gnunet-service-nat", 761 "gnunet-service-nat",
756 "-c", 762 "-c",
757 tc_h->cfg_filename, 763 tc_h->cfg_filename,
758 NULL); 764 NULL);
759 if (NULL == tc_h->nat_proc) 765 if (NULL == tc_h->nat_proc)
760 { 766 {
761 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to start NAT!"); 767 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to start NAT!");
@@ -766,14 +772,13 @@ nat_start (
766} 772}
767 773
768 774
769
770static void 775static void
771do_shutdown (void *cls) 776do_shutdown (void *cls)
772{ 777{
773 struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h = cls; 778 struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h = cls;
774 shutdown_communicator(tc_h->c_proc); 779 shutdown_communicator (tc_h->c_proc);
775 shutdown_service(tc_h->sh); 780 shutdown_service (tc_h->sh);
776 shutdown_nat(tc_h->nat_proc); 781 shutdown_nat (tc_h->nat_proc);
777} 782}
778 783
779 784
@@ -836,6 +841,7 @@ GNUNET_TRANSPORT_TESTING_transport_communicator_service_start (
836 return tc_h; 841 return tc_h;
837} 842}
838 843
844
839/** 845/**
840 * @brief Instruct communicator to open a queue 846 * @brief Instruct communicator to open a queue
841 * 847 *
@@ -924,5 +930,6 @@ GNUNET_TRANSPORT_TESTING_transport_communicator_send
924 memcpy (&msg[1], mh, inbox_size); 930 memcpy (&msg[1], mh, inbox_size);
925 GNUNET_free (mh); 931 GNUNET_free (mh);
926 GNUNET_MQ_send (tc_queue->tc_h->c_mq, env); 932 GNUNET_MQ_send (tc_queue->tc_h->c_mq, env);
933 // GNUNET_assert (0); // FIXME: not iplemented!
927 return tc_t; 934 return tc_t;
928} 935}