static void
run_more (void *cls, char *const *args, const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
h = GNUNET_STATISTICS_create ("test-statistics-api", cfg);
GNUNET_break (NULL !=
GNUNET_STATISTICS_get (h, NULL, "test-3",
GNUNET_TIME_UNIT_SECONDS, &next_fin,
&check_3, cls));
}
static void
next (void *cls, int success)
{
GNUNET_assert (success == GNUNET_OK);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Issuing GET request\n");
GNUNET_break (NULL !=
GNUNET_STATISTICS_get (h, NULL, "test-2",
GNUNET_TIME_UNIT_SECONDS, &next_fin,
&check_2, cls));
}
/**
* Check the server statistics regularly
*/
static void
check_statistics (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
char *stat;
check_task = NULL;
if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
return;
GNUNET_asprintf (&stat, gettext_noop ("# advertised URI `%s' downloaded"),
current_adv_uri);
if (NULL != learn_peer.stats)
{
if (NULL != download_stats)
GNUNET_STATISTICS_get_cancel (download_stats);
download_stats =
GNUNET_STATISTICS_get (learn_peer.stats, "hostlist", stat,
GNUNET_TIME_UNIT_MINUTES,
&process_downloads_done, &process_downloads,
&learn_peer);
if (NULL != urisrecv_stat)
GNUNET_STATISTICS_get_cancel (urisrecv_stat);
urisrecv_stat =
GNUNET_STATISTICS_get (learn_peer.stats, "hostlist",
gettext_noop ("# advertised hostlist URIs"),
GNUNET_TIME_UNIT_MINUTES,
&process_uris_recv_done, &process_uris_recv,
&learn_peer);
}
GNUNET_free (stat);
if (NULL != adv_peer.stats)
{
if (NULL != advsent_stat)
GNUNET_STATISTICS_get_cancel (advsent_stat);
advsent_stat =
GNUNET_STATISTICS_get (adv_peer.stats, "hostlist",
gettext_noop ("# hostlist advertisements send"),
GNUNET_TIME_UNIT_MINUTES, &process_adv_sent_done,
&process_adv_sent, NULL);
}
check_task =
GNUNET_SCHEDULER_add_delayed (CHECK_INTERVAL, &check_statistics, NULL);
}
static void
run (void *cls,
const struct GNUNET_CONFIGURATION_Handle *cfg,
struct GNUNET_TESTING_Peer *peer)
{
die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL);
stats = GNUNET_STATISTICS_create ("ats", cfg);
GNUNET_STATISTICS_watch (stats, "ats", "# addresses", &stat_cb, NULL);
initial_get = GNUNET_STATISTICS_get (stats, "ats", "# addresses", TIMEOUT,
&got_initial_value, &dummy_stat,
GNUNET_CONFIGURATION_dup (cfg));
}
static void
run (void *cls, char *const *args, const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
h = GNUNET_STATISTICS_create ("test-statistics-api", cfg);
GNUNET_STATISTICS_set (h, "test-1", 1, GNUNET_NO);
GNUNET_STATISTICS_set (h, "test-2", 2, GNUNET_NO);
GNUNET_STATISTICS_set (h, "test-3", 2, GNUNET_NO);
GNUNET_STATISTICS_update (h, "test-3", 1, GNUNET_YES);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Issuing GET request\n");
GNUNET_break (NULL !=
GNUNET_STATISTICS_get (h, NULL, "test-1",
GNUNET_TIME_UNIT_SECONDS, &next,
&check_1, cls));
}
/**
* Called after opening a connection to the statistics service of a peer
*
* @param cls the PeerGetStatsContext
* @param op the operation that has been finished
* @param ca_result the service handle returned from GNUNET_TESTBED_ConnectAdapter()
* @param emsg error message in case the operation has failed; will be NULL if
* operation has executed successfully.
*/
static void
service_connect_comp (void *cls,
struct GNUNET_TESTBED_Operation *op,
void *ca_result,
const char *emsg)
{
struct PeerGetStatsContext *peer_sc = cls;
struct GNUNET_STATISTICS_Handle *h = ca_result;
LOG_DEBUG ("Retrieving statistics of peer %u\n",
peer_sc->peer_index);
peer_sc->get_handle =
GNUNET_STATISTICS_get (h, peer_sc->sc->subsystem,
peer_sc->sc->name,
&iteration_completion_cb,
iterator_cb, peer_sc);
}
/**
* Function that gathers stats from all daemons.
*/
static void
stat_run (void *cls,
struct GNUNET_TESTBED_Operation *op,
void *ca_result,
const char *emsg)
{
struct StatMaster *sm = cls;
sm->stat = ca_result;
GNUNET_assert (NULL != sm->stat);
if (NULL != stats[sm->value].name)
{
GNUNET_STATISTICS_get (sm->stat,
#if 0
NULL, NULL,
#else
stats[sm->value].subsystem, stats[sm->value].name,
#endif
&get_done, &print_stat,
sm);
return;
}
GNUNET_TESTBED_operation_done (sm->op);
sm->value = 0;
sm->daemon++;
if (NUM_DAEMONS == sm->daemon)
{
GNUNET_free (sm);
cleanup ();
return;
}
sm->op =
GNUNET_TESTBED_service_connect (NULL,
daemons[sm->daemon],
"statistics",
&stat_run, sm,
&statistics_connect_adapter,
&statistics_disconnect_adapter,
NULL);
}
static void
run (void *cls,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
unsigned int i;
char name[128];
h = GNUNET_STATISTICS_create ("test-statistics-api-loop", cfg);
for (i = 0; i < ROUNDS; i++)
{
GNUNET_snprintf (name, sizeof (name), "test-%d", i % 32);
GNUNET_STATISTICS_set (h, name, i, GNUNET_NO);
GNUNET_snprintf (name, sizeof (name), "test-%d", i % 16);
GNUNET_STATISTICS_update (h, name, 1, GNUNET_NO);
}
i = 0;
GNUNET_break (NULL !=
GNUNET_STATISTICS_get (h, NULL, "test-0",
&next,
&check_1, cls));
}
static void
measurement_stop (void *cls,
const struct GNUNET_SCHEDULER_TaskContext *tc)
{
unsigned long long delta;
unsigned long long throughput_out;
unsigned long long throughput_in;
unsigned long long max_quota_in;
unsigned long long max_quota_out;
unsigned long long quota_delta;
enum GNUNET_ErrorType kind = GNUNET_ERROR_TYPE_DEBUG;
measure_task = NULL;
FPRINTF (stdout, "%s", "\n");
running = GNUNET_NO;
delta = GNUNET_TIME_absolute_get_duration (start_time).rel_value_us;
throughput_out = total_bytes_sent * 1000000LL / delta; /* convert to bytes/s */
throughput_in = total_bytes_recv * 1000000LL / delta; /* convert to bytes/s */
max_quota_in = GNUNET_MIN (current_quota_p1_in, current_quota_p2_in);
max_quota_out = GNUNET_MIN (current_quota_p1_out, current_quota_p2_out);
if (max_quota_out < max_quota_in)
quota_delta = max_quota_in / 3;
else
quota_delta = max_quota_out / 3;
if ((throughput_out > (max_quota_out + quota_delta)) ||
(throughput_in > (max_quota_in + quota_delta)))
ok = 1; /* fail */
else
ok = 0; /* pass */
GNUNET_STATISTICS_get (p1.stats, "core", "# discarded CORE_SEND requests",
GNUNET_TIME_UNIT_FOREVER_REL, NULL, &print_stat, &p1);
GNUNET_STATISTICS_get (p1.stats, "core",
"# discarded CORE_SEND request bytes",
GNUNET_TIME_UNIT_FOREVER_REL, NULL, &print_stat, &p1);
GNUNET_STATISTICS_get (p1.stats, "core",
"# discarded lower priority CORE_SEND requests",
GNUNET_TIME_UNIT_FOREVER_REL, NULL, &print_stat, NULL);
GNUNET_STATISTICS_get (p1.stats, "core",
"# discarded lower priority CORE_SEND request bytes",
GNUNET_TIME_UNIT_FOREVER_REL, NULL, &print_stat, &p1);
GNUNET_STATISTICS_get (p2.stats, "core", "# discarded CORE_SEND requests",
GNUNET_TIME_UNIT_FOREVER_REL, NULL, &print_stat, &p2);
GNUNET_STATISTICS_get (p2.stats, "core",
"# discarded CORE_SEND request bytes",
GNUNET_TIME_UNIT_FOREVER_REL, NULL, &print_stat, &p2);
GNUNET_STATISTICS_get (p2.stats, "core",
"# discarded lower priority CORE_SEND requests",
GNUNET_TIME_UNIT_FOREVER_REL, NULL, &print_stat, &p2);
GNUNET_STATISTICS_get (p2.stats, "core",
"# discarded lower priority CORE_SEND request bytes",
GNUNET_TIME_UNIT_FOREVER_REL, NULL, &print_stat, &p2);
if (ok != 0)
kind = GNUNET_ERROR_TYPE_ERROR;
switch (test)
{
case SYMMETRIC:
GNUNET_log (kind, "Core quota compliance test with symmetric quotas: %s\n",
(0 == ok) ? "PASSED" : "FAILED");
break;
case ASYMMETRIC_SEND_LIMITED:
GNUNET_log (kind,
"Core quota compliance test with limited sender quota: %s\n",
(0 == ok) ? "PASSED" : "FAILED");
break;
case ASYMMETRIC_RECV_LIMITED:
GNUNET_log (kind,
"Core quota compliance test with limited receiver quota: %s\n",
(0 == ok) ? "PASSED" : "FAILED");
break;
};
GNUNET_log (kind, "Peer 1 send rate: %llu b/s (%llu bytes in %llu ms)\n",
throughput_out, total_bytes_sent, delta);
GNUNET_log (kind, "Peer 1 send quota: %llu b/s\n", current_quota_p1_out);
GNUNET_log (kind, "Peer 2 receive rate: %llu b/s (%llu bytes in %llu ms)\n",
throughput_in, total_bytes_recv, delta);
GNUNET_log (kind, "Peer 2 receive quota: %llu b/s\n", current_quota_p2_in);
/*
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Max. inbound quota allowed: %llu b/s\n",max_quota_in );
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Max. outbound quota allowed: %llu b/s\n",max_quota_out);
*/
GNUNET_SCHEDULER_cancel (err_task);
err_task = GNUNET_SCHEDULER_add_now (&terminate_task, NULL);
}
/**
* Main task that does the actual work.
*
* @param cls closure with our configuration
* @param tc schedueler context
*/
static void
main_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
struct GNUNET_STATISTICS_Handle *h;
if (set_value)
{
if (subsystem == NULL)
{
FPRINTF (stderr, "%s", _("Missing argument: subsystem \n"));
ret = 1;
return;
}
if (name == NULL)
{
FPRINTF (stderr, "%s", _("Missing argument: name\n"));
ret = 1;
return;
}
h = GNUNET_STATISTICS_create (subsystem, cfg);
if (NULL == h)
{
ret = 1;
return;
}
GNUNET_STATISTICS_set (h, name, (uint64_t) set_val, persistent);
GNUNET_STATISTICS_destroy (h, GNUNET_YES);
h = NULL;
return;
}
if (NULL == (h = GNUNET_STATISTICS_create ("gnunet-statistics", cfg)))
{
ret = 1;
return;
}
if (GNUNET_NO == watch)
{
if (NULL ==
GNUNET_STATISTICS_get (h, subsystem, name, GET_TIMEOUT, &cleanup,
&printer, h))
cleanup (h, GNUNET_SYSERR);
}
else
{
if ((NULL == subsystem) || (NULL == name))
{
printf (_("No subsystem or name given\n"));
GNUNET_STATISTICS_destroy (h, GNUNET_NO);
h = NULL;
ret = 1;
return;
}
if (GNUNET_OK != GNUNET_STATISTICS_watch (h, subsystem, name, &printer, h))
{
fprintf (stderr, _("Failed to initialize watch routine\n"));
GNUNET_SCHEDULER_add_now (&shutdown_task, h);
return;
}
}
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
&shutdown_task, h);
}
