-/*
+/**
This file is part of GNUnet.
(C) 2011, 2012 Christian Grothoff (and other contributing authors)
* @brief Regex profiler for testing distributed regex use.
* @author Bart Polot
* @author Max Szengel
+ *
*/
#include <string.h>
*/
STATE_PEERS_LINKING,
+ /**
+ * Announcing regexes
+ */
+ STATE_ANNOUNCE_REGEX,
+
+ /**
+ * Matching strings against announced regexes
+ */
+ STATE_SEARCH_REGEX,
+
/**
* Destroying peers; we can do this as the controller takes care of stopping a
* peer if it is running
/**
* Peer handles.
*/
-struct Peer
+struct RegexPeer
{
+ /**
+ * Peer id.
+ */
+ unsigned int id;
+
/**
* The actual testbed peer handle.
*/
struct GNUNET_TESTBED_Peer *peer_handle;
+ /**
+ * Host on which the peer is running.
+ */
+ struct GNUNET_TESTBED_Host *host_handle;
+
+ /**
+ * Filename of the peer's policy file.
+ */
+ char *policy_file;
+
+ /**
+ * Peers search string.
+ */
+ const char *search_str;
+
+ /**
+ * Set to GNUNET_YES if the peer successfully matched the above
+ * search string. GNUNET_NO if the string could not be matched
+ * during the profiler run. GNUNET_SYSERR if the string matching
+ * timed out. Undefined if search_str is NULL
+ */
+ int search_str_matched;
+
/**
* Peer's mesh handle.
*/
struct GNUNET_MESH_Tunnel *mesh_tunnel_handle;
/**
- * Host on which the peer is running.
+ * Testbed operation handle for the mesh service.
*/
- struct GNUNET_TESTBED_Host *host_handle;
+ struct GNUNET_TESTBED_Operation *mesh_op_handle;
/**
- * Testbed operation handle.
+ * Peers's statistics handle.
*/
- struct GNUNET_TESTBED_Operation *op_handle;
+ struct GNUNET_STATISTICS_Handle *stats_handle;
/**
- * Filename of the peer's policy file.
+ * Testbed operation handle for the statistics service.
*/
- char *policy_file;
+ struct GNUNET_TESTBED_Operation *stats_op_handle;
+
+ /**
+ * The starting time of a profiling step.
+ */
+ struct GNUNET_TIME_Absolute prof_start_time;
};
/**
/**
* The array of peers; we fill this as the peers are given to us by the testbed
*/
-static struct Peer *peers;
+static struct RegexPeer *peers;
/**
* Host registration handle
static unsigned int num_hosts;
/**
- * Number of random links to be established between peers
+ * Factor of number of links. num_links = num_peers * linking_factor.
*/
-static unsigned int num_links;
+static unsigned int linking_factor;
/**
- * Number of timeout failures to tolerate
+ * Number of random links to be established between peers
*/
-static unsigned int num_cont_fails;
+static unsigned int num_links;
/**
* Number of times we try overlay connect operations
/**
* Search timeout in seconds.
*/
-static long search_timeout_sec;
+static struct GNUNET_TIME_Relative search_timeout = { 60000 };
+
+/**
+ * How long do we wait before starting the search?
+ * Default: 1 m.
+ */
+static struct GNUNET_TIME_Relative search_delay = { 60000 };
+
+/**
+ * Delay before setting mesh service op as done.
+ */
+static struct GNUNET_TIME_Relative mesh_done_delay = { 1000 };
+
+/**
+ * Delay to wait before starting to configure the overlay topology
+ */
+static struct GNUNET_TIME_Relative conf_topo_delay = { 10000 };
+
+/**
+ * File to log statistics to.
+ */
+static struct GNUNET_DISK_FileHandle *data_file;
+
+/**
+ * Filename to log statistics to.
+ */
+static char *data_filename;
+
+/**
+ * Maximal path compression length.
+ */
+static unsigned int max_path_compression;
+
+/******************************************************************************/
+/****************************** DECLARATIONS ********************************/
+/******************************************************************************/
+
+
+/**
+ * Method called whenever a peer has connected to the tunnel.
+ *
+ * @param cls closure
+ * @param peer_id peer identity the tunnel was created to, NULL on timeout
+ * @param atsi performance data for the connection
+ *
+ */
+void
+mesh_peer_connect_handler (void *cls,
+ const struct GNUNET_PeerIdentity* peer_id,
+ const struct GNUNET_ATS_Information * atsi);
+
+
+/**
+ * Method called whenever a peer has disconnected from the tunnel.
+ * Implementations of this callback must NOT call
+ * GNUNET_MESH_tunnel_destroy immediately, but instead schedule those
+ * to run in some other task later. However, calling
+ * "GNUNET_MESH_notify_transmit_ready_cancel" is allowed.
+ *
+ * @param cls closure
+ * @param peer_id peer identity the tunnel stopped working with
+ */
+void
+mesh_peer_disconnect_handler (void *cls,
+ const struct GNUNET_PeerIdentity * peer_id);
+
+/**
+ * Mesh connect callback.
+ *
+ * @param cls internal peer id.
+ * @param op operation handle.
+ * @param ca_result connect adapter result.
+ * @param emsg error message.
+ */
+void
+mesh_connect_cb (void *cls, struct GNUNET_TESTBED_Operation *op,
+ void *ca_result, const char *emsg);
/**
- * Search wait time in minutes.
+ * Mesh connect adapter.
+ *
+ * @param cls not used.
+ * @param cfg configuration handle.
+ *
+ * @return
*/
-static long search_wait_min;
+void *
+mesh_ca (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg);
+
+
+/**
+ * Adapter function called to destroy a connection to
+ * the mesh service
+ *
+ * @param cls closure
+ * @param op_result service handle returned from the connect adapter
+ */
+void
+mesh_da (void *cls, void *op_result);
+
+
+/******************************************************************************/
+/******************************** SHUTDOWN **********************************/
+/******************************************************************************/
/**
do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct DLLOperation *dll_op;
+ struct RegexPeer *peer;
unsigned int nhost;
unsigned int peer_cnt;
unsigned int search_str_cnt;
-
+ char output_buffer[512];
+ size_t size;
+
+ if (GNUNET_SCHEDULER_NO_TASK != abort_task)
+ GNUNET_SCHEDULER_cancel (abort_task);
+ if (GNUNET_SCHEDULER_NO_TASK != register_hosts_task)
+ GNUNET_SCHEDULER_cancel (register_hosts_task);
+
for (peer_cnt = 0; peer_cnt < num_peers; peer_cnt++)
{
- if (NULL != peers[peer_cnt].op_handle)
- GNUNET_TESTBED_operation_cancel (peers[peer_cnt].op_handle);
+ peer = &peers[peer_cnt];
+
+ if (GNUNET_YES != peer->search_str_matched && NULL != data_file)
+ {
+ prof_time = GNUNET_TIME_absolute_get_duration (peer->prof_start_time);
+ size =
+ GNUNET_snprintf (output_buffer,
+ sizeof (output_buffer),
+ "Search string not found: %s (%d)\nOn peer: %u (%p)\nWith policy file: %s\nAfter: %s\n",
+ peer->search_str,
+ peer->search_str_matched,
+ peer->id,
+ peer,
+ peer->policy_file,
+ GNUNET_STRINGS_relative_time_to_string (prof_time, GNUNET_NO));
+ if (size != GNUNET_DISK_file_write (data_file, output_buffer, size))
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Unable to write to file!\n");
+ }
+
+ if (NULL != peers[peer_cnt].mesh_op_handle)
+ GNUNET_TESTBED_operation_done (peers[peer_cnt].mesh_op_handle);
+ if (NULL != peers[peer_cnt].stats_op_handle)
+ GNUNET_TESTBED_operation_done (peers[peer_cnt].stats_op_handle);
}
- for (search_str_cnt = 0; search_str_cnt < num_search_strings; search_str_cnt++)
+
+ if (NULL != data_file)
+ GNUNET_DISK_file_close (data_file);
+
+ for (search_str_cnt = 0;
+ search_str_cnt < num_search_strings && NULL != search_strings;
+ search_str_cnt++)
{
- GNUNET_free (search_strings[search_str_cnt]);
+ GNUNET_free_non_null (search_strings[search_str_cnt]);
}
- GNUNET_free (search_strings);
- if (GNUNET_SCHEDULER_NO_TASK != abort_task)
- GNUNET_SCHEDULER_cancel (abort_task);
- if (GNUNET_SCHEDULER_NO_TASK != register_hosts_task)
- GNUNET_SCHEDULER_cancel (register_hosts_task);
+ GNUNET_free_non_null (search_strings);
+
if (NULL != reg_handle)
GNUNET_TESTBED_cancel_registration (reg_handle);
if (NULL != topology_op)
- GNUNET_TESTBED_operation_cancel (topology_op);
+ GNUNET_TESTBED_operation_done (topology_op);
for (nhost = 0; nhost < num_hosts; nhost++)
if (NULL != hosts[nhost])
GNUNET_TESTBED_host_destroy (hosts[nhost]);
GNUNET_free_non_null (hosts);
+
while (NULL != (dll_op = dll_op_head))
{
- GNUNET_TESTBED_operation_cancel (dll_op->op);
+ GNUNET_TESTBED_operation_done (dll_op->op);
GNUNET_CONTAINER_DLL_remove (dll_op_head, dll_op_tail, dll_op);
GNUNET_free (dll_op);
}
}
+/******************************************************************************/
+/********************* STATISTICS SERVICE CONNECTIONS ***********************/
+/******************************************************************************/
+
+/**
+ * Adapter function called to establish a connection to
+ * statistics service.
+ *
+ * @param cls closure
+ * @param cfg configuration of the peer to connect to; will be available until
+ * GNUNET_TESTBED_operation_done() is called on the operation returned
+ * from GNUNET_TESTBED_service_connect()
+ * @return service handle to return in 'op_result', NULL on error
+ */
+static void *
+stats_ca (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+ return GNUNET_STATISTICS_create ("<driver>", cfg);
+}
+
+
+/**
+ * Adapter function called to destroy a connection to
+ * statistics service.
+ *
+ * @param cls closure
+ * @param op_result service handle returned from the connect adapter
+ */
+static void
+stats_da (void *cls, void *op_result)
+{
+ struct RegexPeer *peer = cls;
+
+ GNUNET_assert (op_result == peer->stats_handle);
+
+ GNUNET_STATISTICS_destroy (peer->stats_handle, GNUNET_NO);
+ peer->stats_handle = NULL;
+}
+
+
+/**
+ * Process statistic values.
+ *
+ * @param cls closure
+ * @param subsystem name of subsystem that created the statistic
+ * @param name the name of the datum
+ * @param value the current value
+ * @param is_persistent GNUNET_YES if the value is persistent, GNUNET_NO if not
+ * @return GNUNET_OK to continue, GNUNET_SYSERR to abort iteration
+ */
+static int
+stats_iterator (void *cls, const char *subsystem, const char *name,
+ uint64_t value, int is_persistent)
+{
+ struct RegexPeer *peer = cls;
+ char output_buffer[512];
+ size_t size;
+
+ if (NULL == data_file)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ "%p -> %s [%s]: %llu\n",
+ peer, subsystem, name, value);
+ return GNUNET_OK;
+ }
+ size =
+ GNUNET_snprintf (output_buffer,
+ sizeof (output_buffer),
+ "%p [%s] %llu %s\n",
+ peer,
+ subsystem, value, name);
+ if (size != GNUNET_DISK_file_write (data_file, output_buffer, size))
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Unable to write to file!\n");
+
+ return GNUNET_OK;
+}
+
+
+/**
+ * Stats callback.
+ *
+ * @param cls closure
+ * @param success GNUNET_OK if statistics were
+ * successfully obtained, GNUNET_SYSERR if not.
+ */
+static void
+stats_cb (void *cls,
+ int success)
+{
+ static unsigned int peer_cnt;
+ struct RegexPeer *peer = cls;
+
+ if (GNUNET_OK != success)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "Getting statistics for peer %u failed!\n",
+ peer->id);
+ return;
+ }
+
+ GNUNET_TESTBED_operation_done (peer->stats_op_handle);
+ peer->stats_op_handle = NULL;
+
+ if (++peer_cnt == num_search_strings)
+ {
+ struct GNUNET_TIME_Relative delay = { 100 };
+ GNUNET_SCHEDULER_add_delayed (delay, &do_shutdown, NULL);
+ }
+}
+
+
+/**
+ * Function called by testbed once we are connected to stats service.
+ *
+ * @param cls the 'struct RegexPeer' for which we connected to stats
+ * @param op connect operation handle
+ * @param ca_result handle to stats service
+ * @param emsg error message on failure
+ */
+static void
+stats_connect_cb (void *cls,
+ struct GNUNET_TESTBED_Operation *op,
+ void *ca_result,
+ const char *emsg)
+{
+ struct RegexPeer *peer = cls;
+
+ if (NULL == ca_result || NULL != emsg)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "Failed to connect to statistics service on peer %u: %s\n",
+ peer->id, emsg);
+
+ peer->stats_handle = NULL;
+ return;
+ }
+
+ GNUNET_assert (NULL != peer->mesh_handle);
+
+ peer->stats_handle = ca_result;
+
+ peer->mesh_tunnel_handle = GNUNET_MESH_tunnel_create (peer->mesh_handle,
+ NULL,
+ &mesh_peer_connect_handler,
+ &mesh_peer_disconnect_handler,
+ peer);
+
+ peer->prof_start_time = GNUNET_TIME_absolute_get ();
+
+ peer->search_str_matched = GNUNET_NO;
+ GNUNET_MESH_peer_request_connect_by_string (peer->mesh_tunnel_handle,
+ peer->search_str);
+}
+
+
+/******************************************************************************/
+/************************ MESH SERVICE CONNECTIONS **************************/
+/******************************************************************************/
+
/**
* Method called whenever another peer has added us to a tunnel
* the other peer initiated.
const struct GNUNET_PeerIdentity* peer_id,
const struct GNUNET_ATS_Information * atsi)
{
- const char * search_str = (const char *)cls;
+ struct RegexPeer *peer = cls;
+ char output_buffer[512];
+ size_t size;
peers_found++;
if (NULL == peer_id)
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- "String matching timed out for string %s (%i/%i)\n",
- search_str, peers_found, num_search_strings);
+ "String matching timed out for string %s on peer %u (%i/%i)\n",
+ peer->search_str, peer->id, peers_found, num_search_strings);
+
+ printf ("String matching timed out for string %s on peer %u (%i/%i)\n",
+ peer->search_str, peer->id, peers_found, num_search_strings);
+
+ peer->search_str_matched = GNUNET_SYSERR;
}
else
{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "String %s successfully matched (%i/%i)\n",
- search_str, peers_found, num_search_strings);
+ prof_time = GNUNET_TIME_absolute_get_duration (peer->prof_start_time);
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ "String %s successfully matched on peer %u after %s (%i/%i)\n",
+ peer->search_str, peer->id, GNUNET_STRINGS_relative_time_to_string (prof_time, GNUNET_NO),
+ peers_found, num_search_strings);
+
+ printf ("String %s successfully matched on peer %u after %s (%i/%i)\n",
+ peer->search_str, peer->id, GNUNET_STRINGS_relative_time_to_string (prof_time, GNUNET_NO),
+ peers_found, num_search_strings);
+ fflush (stdout);
+
+ peer->search_str_matched = GNUNET_YES;
+
+ if (NULL != data_file)
+ {
+ size =
+ GNUNET_snprintf (output_buffer,
+ sizeof (output_buffer),
+ "Peer: %u (%p)\nHost: %s\nPolicy file: %s\nSearch string: %s\nSearch duration: %s\n\n",
+ peer->id,
+ peer,
+ GNUNET_TESTBED_host_get_hostname (peer->host_handle),
+ peer->policy_file,
+ peer->search_str,
+ GNUNET_STRINGS_relative_time_to_string (prof_time, GNUNET_NO));
+
+ if (size != GNUNET_DISK_file_write (data_file, output_buffer, size))
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Unable to write to file!\n");
+ }
+
+ if (NULL == peer->stats_handle)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "Cannot get statistics for peer %u, stats handle is NULL!\n");
+ return;
+ }
+
+ if (NULL == GNUNET_STATISTICS_get (peer->stats_handle, "mesh", NULL,
+ GNUNET_TIME_UNIT_FOREVER_REL,
+ NULL,
+ &stats_iterator, peer))
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "Could not get mesh statistics of peer %u!\n", peer->id);
+ }
+ if (NULL == GNUNET_STATISTICS_get (peer->stats_handle, "transport", NULL,
+ GNUNET_TIME_UNIT_FOREVER_REL,
+ NULL,
+ &stats_iterator, peer))
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "Could not get transport statistics of peer %u!\n", peer->id);
+ }
+ if (NULL == GNUNET_STATISTICS_get (peer->stats_handle, "dht", NULL,
+ GNUNET_TIME_UNIT_FOREVER_REL,
+ &stats_cb,
+ &stats_iterator, peer))
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "Could not get dht statistics of peer %u!\n", peer->id);
+ }
}
if (peers_found == num_search_strings)
{
-
prof_time = GNUNET_TIME_absolute_get_duration (prof_start_time);
- printf ("\nAll strings successfully matched in %.2f minutes\n", ((double)prof_time.rel_value / 1000.0 / 60.0));
- GNUNET_SCHEDULER_cancel (search_timeout_task);
- GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ "All strings successfully matched in %s\n",
+ GNUNET_STRINGS_relative_time_to_string (prof_time, GNUNET_NO));
+ printf ("All strings successfully matched. Shutting down.\n");
+ fflush (stdout);
+
+ if (GNUNET_SCHEDULER_NO_TASK != search_timeout_task)
+ GNUNET_SCHEDULER_cancel (search_timeout_task);
}
}
*/
static void
do_connect_by_string_timeout (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext * tc)
+ const struct GNUNET_SCHEDULER_TaskContext * tc)
{
- long sec = (long)cls;
-
- printf ("Searching for all strings did not succeed after %ld seconds\n", sec);
- printf ("Found %i of %i strings\n", peers_found, num_search_strings);
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ "Finding matches to all strings did not succeed after %s.\n",
+ GNUNET_STRINGS_relative_time_to_string (search_timeout, GNUNET_NO));
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ "Found %i of %i strings\n", peers_found, num_search_strings);
GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
}
const struct GNUNET_SCHEDULER_TaskContext * tc)
{
unsigned int search_cnt;
- struct Peer *peer;
+ struct RegexPeer *peer;
+
+ printf ("Starting string search.\n");
+ fflush (stdout);
for (search_cnt = 0; search_cnt < num_search_strings; search_cnt++)
{
peer = &peers[search_cnt % num_peers];
+ peer->search_str = search_strings[search_cnt];
+ peer->search_str_matched = GNUNET_NO;
+
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ "Searching for string \"%s\" on peer %d with file %s\n",
+ peer->search_str, (search_cnt % num_peers), peer->policy_file);
+
+ /* First connect to mesh service, then connect to stats service
+ and then try connecting by string in stats_connect_cb */
+ peer->mesh_op_handle =
+ GNUNET_TESTBED_service_connect (NULL,
+ peers->peer_handle,
+ "mesh",
+ &mesh_connect_cb,
+ peer,
+ &mesh_ca,
+ &mesh_da,
+ peer);
+ }
- printf ("Searching for string \"%s\" on peer %d\n",
- search_strings[search_cnt], (search_cnt % num_peers));
+ search_timeout_task = GNUNET_SCHEDULER_add_delayed (search_timeout,
+ &do_connect_by_string_timeout, NULL);
+}
- peer->mesh_tunnel_handle = GNUNET_MESH_tunnel_create (peer->mesh_handle,
- NULL,
- &mesh_peer_connect_handler,
- &mesh_peer_disconnect_handler,
- search_strings[search_cnt]);
- GNUNET_MESH_peer_request_connect_by_string (peer->mesh_tunnel_handle,
- search_strings[search_cnt]);
-
- }
- prof_start_time = GNUNET_TIME_absolute_get ();
+/**
+ * Delayed operation done for mesh service disconnects.
+ *
+ * @param cls NULL
+ * @param tc the task context
+ */
+static void
+do_mesh_op_done (void *cls,
+ const struct GNUNET_SCHEDULER_TaskContext * tc)
+{
+ struct RegexPeer *peer = cls;
+ static unsigned int peer_cnt;
+ GNUNET_TESTBED_operation_done (peer->mesh_op_handle);
+ peer->mesh_op_handle = NULL;
- search_timeout_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
- (GNUNET_TIME_UNIT_SECONDS, search_timeout_sec),
- &do_connect_by_string_timeout, (void *)search_timeout_sec);
+ if (++peer_cnt < num_peers)
+ {
+ peers[peer_cnt].mesh_op_handle =
+ GNUNET_TESTBED_service_connect (NULL,
+ peers[peer_cnt].peer_handle,
+ "mesh",
+ &mesh_connect_cb,
+ &peers[peer_cnt],
+ &mesh_ca,
+ &mesh_da,
+ &peers[peer_cnt]);
+ }
}
mesh_connect_cb (void *cls, struct GNUNET_TESTBED_Operation *op,
void *ca_result, const char *emsg)
{
- static unsigned int connected_mesh_handles;
- struct Peer *peer = (struct Peer *) cls;
+ struct RegexPeer *peer = (struct RegexPeer *) cls;
char *regex;
char *data;
char *buf;
uint64_t filesize;
unsigned int offset;
- if (NULL != emsg)
+ if (NULL != emsg || NULL == op || NULL == ca_result)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Mesh connect failed: %s\n", emsg);
GNUNET_assert (0);
}
-
- GNUNET_assert (peer->op_handle == op);
+
+ GNUNET_assert (peer->mesh_handle != NULL);
+ GNUNET_assert (peer->mesh_op_handle == op);
GNUNET_assert (peer->mesh_handle == ca_result);
GNUNET_assert (NULL != peer->policy_file);
- printf ("Announcing regexes for peer with file %s\n", peer->policy_file);
- fflush (stdout);
-
- if (GNUNET_YES != GNUNET_DISK_file_test (peer->policy_file))
- {
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- "Could not find policy file %s\n", peer->policy_file);
- return;
- }
- if (GNUNET_OK != GNUNET_DISK_file_size (peer->policy_file, &filesize, GNUNET_YES, GNUNET_YES))
- filesize = 0;
- if (0 == filesize)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Policy file %s is empty.\n", peer->policy_file);
- return;
- }
- data = GNUNET_malloc (filesize);
- if (filesize != GNUNET_DISK_fn_read (peer->policy_file, data, filesize))
- {
- GNUNET_free (data);
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Could not read policy file %s.\n",
- peer->policy_file);
- return;
- }
- buf = data;
- offset = 0;
- regex = NULL;
- while (offset < (filesize - 1))
+ switch (state)
{
- offset++;
- if (((data[offset] == '\n')) && (buf != &data[offset]))
+ case STATE_ANNOUNCE_REGEX:
{
- data[offset] = '\0';
- regex = buf;
- GNUNET_assert (NULL != regex);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Announcing regex: %s\n", regex);
- GNUNET_MESH_announce_regex (peer->mesh_handle, regex);
- buf = &data[offset + 1];
- }
- else if ((data[offset] == '\n') || (data[offset] == '\0'))
- buf = &data[offset + 1];
- }
- GNUNET_free (data);
+ static unsigned int num_files_announced;
- if (++connected_mesh_handles == num_peers)
- {
- printf ("\nAll mesh handles connected.\nWaiting %ld minutes before starting to search.\n",
- search_wait_min);
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ "Announcing regexes for peer %u with file %s\n",
+ peer->id, peer->policy_file);
+
+ if (GNUNET_YES != GNUNET_DISK_file_test (peer->policy_file))
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "Could not find policy file %s\n", peer->policy_file);
+ return;
+ }
+ if (GNUNET_OK != GNUNET_DISK_file_size (peer->policy_file, &filesize, GNUNET_YES, GNUNET_YES))
+ filesize = 0;
+ if (0 == filesize)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Policy file %s is empty.\n", peer->policy_file);
+ return;
+ }
+ data = GNUNET_malloc (filesize);
+ if (filesize != GNUNET_DISK_fn_read (peer->policy_file, data, filesize))
+ {
+ GNUNET_free (data);
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Could not read policy file %s.\n",
+ peer->policy_file);
+ return;
+ }
+ buf = data;
+ offset = 0;
+ regex = NULL;
+ while (offset < (filesize - 1))
+ {
+ offset++;
+ if (((data[offset] == '\n')) && (buf != &data[offset]))
+ {
+ data[offset] = '\0';
+ regex = buf;
+ GNUNET_assert (NULL != regex);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Announcing regex: %s on peer %u \n",
+ regex, peer->id);
+ GNUNET_MESH_announce_regex (peer->mesh_handle, regex, max_path_compression);
+ buf = &data[offset + 1];
+ }
+ else if ((data[offset] == '\n') || (data[offset] == '\0'))
+ buf = &data[offset + 1];
+ }
+ GNUNET_free (data);
- search_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
- (GNUNET_TIME_UNIT_MINUTES, search_wait_min),
- &do_connect_by_string, NULL);
+ GNUNET_SCHEDULER_add_delayed (mesh_done_delay, &do_mesh_op_done, peer);
+
+ if (++num_files_announced == num_peers)
+ {
+ state = STATE_SEARCH_REGEX;
+
+ prof_time = GNUNET_TIME_absolute_get_duration (prof_start_time);
+
+ printf ("All files announced in %s.\n",
+ GNUNET_STRINGS_relative_time_to_string (prof_time, GNUNET_NO));
+ printf ("Waiting %s before starting to search.\n",
+ GNUNET_STRINGS_relative_time_to_string (search_delay, GNUNET_YES));
+ fflush (stdout);
+
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ "All regexes announced in %s. Waiting %s before starting to search.\n",
+ GNUNET_STRINGS_relative_time_to_string (prof_time, GNUNET_NO),
+ GNUNET_STRINGS_relative_time_to_string (search_delay, GNUNET_NO));
+
+ search_task = GNUNET_SCHEDULER_add_delayed (search_delay,
+ &do_connect_by_string, NULL);
+ }
+ break;
+ }
+ case STATE_SEARCH_REGEX:
+ {
+ /* First connect to the stats service, then start to search */
+ peer->stats_op_handle =
+ GNUNET_TESTBED_service_connect (NULL,
+ peers->peer_handle,
+ "statistics",
+ &stats_connect_cb,
+ peer,
+ &stats_ca,
+ &stats_da,
+ peer);
+ break;
+ }
+ default:
+ GNUNET_break (0);
}
}
mesh_ca (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
{
GNUNET_MESH_ApplicationType app;
- struct Peer *peer = (struct Peer *) cls;
+ struct RegexPeer *peer = cls;
static struct GNUNET_MESH_MessageHandler handlers[] = {
{NULL, 0, 0}
void
mesh_da (void *cls, void *op_result)
{
- struct Peer *peer = (struct Peer *) cls;
+ struct RegexPeer *peer = (struct RegexPeer *) cls;
GNUNET_assert (peer->mesh_handle == op_result);
GNUNET_MESH_tunnel_destroy (peer->mesh_tunnel_handle);
peer->mesh_tunnel_handle = NULL;
}
+
if (NULL != peer->mesh_handle)
{
GNUNET_MESH_disconnect (peer->mesh_handle);
}
+/******************************************************************************/
+/*************************** TESTBED PEER SETUP *****************************/
+/******************************************************************************/
+
+
+/**
+ * Configure the peer overlay topology.
+ *
+ * @param cls NULL
+ * @param tc the task context
+ */
+static void
+do_configure_topology (void *cls,
+ const struct GNUNET_SCHEDULER_TaskContext * tc)
+{
+ /*
+ if (0 == linking_factor)
+ linking_factor = 1;
+ num_links = linking_factor * num_peers;
+ */
+ /* num_links = num_peers - 1; */
+ num_links = linking_factor;
+
+ /* Do overlay connect */
+ prof_start_time = GNUNET_TIME_absolute_get ();
+ topology_op =
+ GNUNET_TESTBED_overlay_configure_topology (NULL, num_peers, peer_handles,
+ GNUNET_TESTBED_TOPOLOGY_ERDOS_RENYI,
+ num_links,
+ GNUNET_TESTBED_TOPOLOGY_DISABLE_AUTO_RETRY,
+ GNUNET_TESTBED_TOPOLOGY_OPTION_END);
+ if (NULL == topology_op)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "Cannot create topology, op handle was NULL\n");
+ GNUNET_assert (0);
+ }
+}
+
+
/**
* Functions of this signature are called when a peer has been successfully
* started or stopped.
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
_("An operation has failed while starting peers\n"));
GNUNET_TESTBED_operation_done (op);
- GNUNET_SCHEDULER_cancel (abort_task);
+ if (GNUNET_SCHEDULER_NO_TASK != abort_task)
+ GNUNET_SCHEDULER_cancel (abort_task);
abort_task = GNUNET_SCHEDULER_add_now (&do_abort, NULL);
return;
}
if (++started_peers == num_peers)
{
prof_time = GNUNET_TIME_absolute_get_duration (prof_start_time);
- printf ("All peers started successfully in %.2f seconds\n",
- ((double) prof_time.rel_value) / 1000.00);
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ "All peers started successfully in %s\n",
+ GNUNET_STRINGS_relative_time_to_string (prof_time, GNUNET_NO));
result = GNUNET_OK;
- if (0 == num_links)
- {
- GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
- return;
- }
peer_handles = GNUNET_malloc (sizeof (struct GNUNET_TESTBED_Peer *) * num_peers);
for (peer_cnt = 0; peer_cnt < num_peers; peer_cnt++)
peer_handles[peer_cnt] = peers[peer_cnt].peer_handle;
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ "Waiting %s before starting to link peers\n",
+ GNUNET_STRINGS_relative_time_to_string (conf_topo_delay, GNUNET_YES));
+
+ printf ("Waiting %s before starting to link peers\n",
+ GNUNET_STRINGS_relative_time_to_string (conf_topo_delay, GNUNET_YES));
+ fflush (stdout);
+
state = STATE_PEERS_LINKING;
- /* Do overlay connect */
- prof_start_time = GNUNET_TIME_absolute_get ();
- topology_op =
- GNUNET_TESTBED_overlay_configure_topology (NULL, num_peers, peer_handles,
- GNUNET_TESTBED_TOPOLOGY_ERDOS_RENYI,
- num_links,
- GNUNET_TESTBED_TOPOLOGY_OPTION_END);
- if (NULL == topology_op)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Cannot create topology, op handle was NULL\n");
- GNUNET_assert (0);
- }
+ GNUNET_SCHEDULER_add_delayed (conf_topo_delay, &do_configure_topology, NULL);
}
}
peer_create_cb (void *cls, struct GNUNET_TESTBED_Peer *peer, const char *emsg)
{
struct DLLOperation *dll_op = cls;
- struct Peer *peer_ptr;
+ struct RegexPeer *peer_ptr;
static unsigned int created_peers;
unsigned int peer_cnt;
GNUNET_TESTBED_operation_done (dll_op->op);
GNUNET_CONTAINER_DLL_remove (dll_op_head, dll_op_tail, dll_op);
GNUNET_free (dll_op);
- GNUNET_SCHEDULER_cancel (abort_task);
+ if (GNUNET_SCHEDULER_NO_TASK != abort_task)
+ GNUNET_SCHEDULER_cancel (abort_task);
abort_task = GNUNET_SCHEDULER_add_now (&do_abort, NULL);
return;
}
GNUNET_free (dll_op);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peer %i created on host %s\n",
- created_peers,
+ peer_ptr->id,
GNUNET_TESTBED_host_get_hostname (peer_ptr->host_handle));
if (++created_peers == num_peers)
{
prof_time = GNUNET_TIME_absolute_get_duration (prof_start_time);
- printf ("All peers created successfully in %.2f seconds\n",
- ((double) prof_time.rel_value) / 1000.00);
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ "All peers created successfully in %s\n",
+ GNUNET_STRINGS_relative_time_to_string (prof_time, GNUNET_NO));
/* Now peers are to be started */
state = STATE_PEERS_STARTING;
prof_start_time = GNUNET_TIME_absolute_get ();
{
static unsigned int peer_cnt;
struct DLLOperation *dll_op;
+ struct RegexPeer *peer = &peers[peer_cnt];
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Creating peer %i on host %s for policy file %s\n",
- peer_cnt,
- GNUNET_TESTBED_host_get_hostname (hosts[peer_cnt % num_hosts]),
- filename);
+ GNUNET_assert (NULL != peer);
+
+ peer->policy_file = GNUNET_strdup (filename);
- peers[peer_cnt].policy_file = GNUNET_strdup (filename);
- peers[peer_cnt].host_handle = hosts[peer_cnt % num_hosts];
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Creating peer %i on host %s for policy file %s\n",
+ peer->id,
+ GNUNET_TESTBED_host_get_hostname (peer->host_handle),
+ filename);
dll_op = GNUNET_malloc (sizeof (struct DLLOperation));
dll_op->cls = &peers[peer_cnt];
dll_op->op = GNUNET_TESTBED_peer_create (mc,
- hosts[peer_cnt % num_hosts],
+ peer->host_handle,
cfg,
&peer_create_cb,
dll_op);
/**
- * Controller event callback
+ * Controller event callback.
*
* @param cls NULL
* @param event the controller event
case GNUNET_TESTBED_ET_OPERATION_FINISHED:
{
static unsigned int slaves_started;
+ unsigned int peer_cnt;
dll_op = event->details.operation_finished.op_cls;
GNUNET_CONTAINER_DLL_remove (dll_op_head, dll_op_tail, dll_op);
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
_("An operation has failed while starting slaves\n"));
GNUNET_TESTBED_operation_done (op);
- GNUNET_SCHEDULER_cancel (abort_task);
+ if (GNUNET_SCHEDULER_NO_TASK != abort_task)
+ GNUNET_SCHEDULER_cancel (abort_task);
abort_task = GNUNET_SCHEDULER_add_now (&do_abort, NULL);
return;
}
/* Proceed to start peers */
if (++slaves_started == num_hosts - 1)
{
- printf ("All slaves started successfully\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ "All slaves started successfully\n");
state = STATE_PEERS_CREATING;
prof_start_time = GNUNET_TIME_absolute_get ();
num_peers = GNUNET_DISK_directory_scan (policy_dir,
NULL,
NULL);
- peers = GNUNET_malloc (sizeof (struct Peer) * num_peers);
+ peers = GNUNET_malloc (sizeof (struct RegexPeer) * num_peers);
+
+ /* Initialize peers */
+ for (peer_cnt = 0; peer_cnt < num_peers; peer_cnt++)
+ {
+ struct RegexPeer *peer = &peers[peer_cnt];
+ peer->id = peer_cnt;
+ peer->policy_file = NULL;
+ /* Do not start peers on hosts[0] (master controller) */
+ peer->host_handle = hosts[1 + (peer_cnt % (num_hosts -1))];
+ peer->mesh_handle = NULL;
+ peer->mesh_tunnel_handle = NULL;
+ peer->stats_handle = NULL;
+ peer->stats_op_handle = NULL;
+ peer->search_str = NULL;
+ peer->search_str_matched = GNUNET_NO;
+ }
GNUNET_DISK_directory_scan (policy_dir,
&policy_filename_cb,
break;
case STATE_PEERS_LINKING:
switch (event->type)
+ {
+ static unsigned int established_links;
+ case GNUNET_TESTBED_ET_OPERATION_FINISHED:
+ /* Control reaches here when a peer linking operation fails */
+ if (NULL != event->details.operation_finished.emsg)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ _("An operation has failed while linking\n"));
+ printf ("F");
+ fflush (stdout);
+ retry_links++;
+ }
+ /* We do no retries, consider this link as established */
+ /* break; */
+ case GNUNET_TESTBED_ET_CONNECT:
+ {
+ char output_buffer[512];
+ size_t size;
+
+ if (0 == established_links)
+ printf ("Establishing links .");
+ else
+ {
+ printf (".");
+ fflush (stdout);
+ }
+ if (++established_links == num_links)
+ {
+ fflush (stdout);
+ prof_time = GNUNET_TIME_absolute_get_duration (prof_start_time);
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ "%u links established in %s\n",
+ num_links,
+ GNUNET_STRINGS_relative_time_to_string (prof_time, GNUNET_NO));
+ result = GNUNET_OK;
+ GNUNET_free (peer_handles);
+
+ if (NULL != data_file)
+ {
+ size =
+ GNUNET_snprintf (output_buffer,
+ sizeof (output_buffer),
+ "# of peers: %u\n# of links established: %u\n"
+ "Time to establish links: %s\nLinking failures: %u\n"
+ "path compression length: %u\n# of search strings: %u\n",
+ num_peers,
+ (established_links - cont_fails),
+ GNUNET_STRINGS_relative_time_to_string (prof_time, GNUNET_NO),
+ cont_fails,
+ max_path_compression,
+ num_search_strings);
+
+ if (size != GNUNET_DISK_file_write (data_file, output_buffer, size))
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Unable to write to file!\n");
+ }
+
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ "Connecting to mesh service and start announcing regex...\n");
+ printf ("\nStarting to connect to mesh services and announce regex\n");
+ fflush (stdout);
+
+ prof_start_time = GNUNET_TIME_absolute_get ();
+ peers[0].mesh_op_handle =
+ GNUNET_TESTBED_service_connect (NULL,
+ peers[0].peer_handle,
+ "mesh",
+ &mesh_connect_cb,
+ &peers[0],
+ &mesh_ca,
+ &mesh_da,
+ &peers[0]);
+ state = STATE_ANNOUNCE_REGEX;
+ }
+ }
+ break;
+ default:
+ GNUNET_assert (0);
+ }
+ break;
+ case STATE_ANNOUNCE_REGEX:
+ {
+ /* Handled in service connect callback */
+ break;
+ }
+ case STATE_SEARCH_REGEX:
+ {
+ /* Handled in service connect callback */
+ break;
+ }
+ default:
+ switch (state)
{
- case GNUNET_TESTBED_ET_OPERATION_FINISHED:
- /* Control reaches here when a peer linking operation fails */
- if (NULL != event->details.operation_finished.emsg)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- _("An operation has failed while linking\n"));
- retry_links++;
- if (++cont_fails > num_cont_fails)
- {
- printf ("\nAborting due to very high failure rate");
- GNUNET_SCHEDULER_cancel (abort_task);
- abort_task = GNUNET_SCHEDULER_add_now (&do_abort, NULL);
- }
- }
- break;
- case GNUNET_TESTBED_ET_CONNECT:
- {
- static unsigned int established_links;
- unsigned int peer_cnt;
-
- if (0 == established_links)
- printf ("Establishing links\n .");
- else
- {
- printf (".");
- fflush (stdout);
- }
- if (++established_links == num_links)
- {
- prof_time = GNUNET_TIME_absolute_get_duration (prof_start_time);
- printf ("\n%u links established in %.2f seconds\n",
- num_links, ((double) prof_time.rel_value) / 1000.00);
- result = GNUNET_OK;
- GNUNET_free (peer_handles);
- printf ("\nConnecting to mesh service...\n");
- for (peer_cnt = 0; peer_cnt < num_peers; peer_cnt++)
- {
- peers[peer_cnt].op_handle = GNUNET_TESTBED_service_connect (NULL,
- peers[peer_cnt].peer_handle,
- "mesh",
- &mesh_connect_cb,
- &peers[peer_cnt],
- &mesh_ca,
- &mesh_da,
- &peers[peer_cnt]);
- }
- }
- }
+ case STATE_PEERS_CREATING:
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to create peer\n");
break;
default:
- GNUNET_assert (0);
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "Unexpected controller_cb with state %i!\n", state);
}
- break;
- default:
GNUNET_assert (0);
}
}
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
_("Host registration failed for a host. Error: %s\n"), emsg);
- GNUNET_SCHEDULER_cancel (abort_task);
+ if (GNUNET_SCHEDULER_NO_TASK != abort_task)
+ GNUNET_SCHEDULER_cancel (abort_task);
abort_task = GNUNET_SCHEDULER_add_now (&do_abort, NULL);
return;
}
register_hosts_task = GNUNET_SCHEDULER_NO_TASK;
if (reg_host == num_hosts - 1)
{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"All hosts successfully registered\n");
/* Start slaves */
state = STATE_SLAVES_STARTING;
static void
status_cb (void *cls, const struct GNUNET_CONFIGURATION_Handle *config, int status)
{
- GNUNET_SCHEDULER_cancel (abort_task);
+ if (GNUNET_SCHEDULER_NO_TASK != abort_task)
+ GNUNET_SCHEDULER_cancel (abort_task);
if (GNUNET_OK != status)
{
mc_proc = NULL;
&do_abort, NULL);
}
+
/**
* Load search strings from given filename. One search string per line.
*
* @param filename filename of the file containing the search strings.
- * @param strings set of strings loaded from file. Caller needs to free this
+ * @param strings set of strings loaded from file. Caller needs to free this
* if number returned is greater than zero.
+ * @param limit upper limit on the number of strings read from the file
* @return number of strings found in the file. GNUNET_SYSERR on error.
*/
static int
-load_search_strings (const char *filename, char ***strings)
+load_search_strings (const char *filename, char ***strings, unsigned int limit)
{
char *data;
char *buf;
buf = data;
offset = 0;
str_cnt = 0;
- while (offset < (filesize - 1))
+ while (offset < (filesize - 1) && str_cnt < limit)
{
offset++;
if (((data[offset] == '\n')) && (buf != &data[offset]))
return str_cnt;
}
+
/**
* Main function that will be run by the scheduler.
*
const struct GNUNET_CONFIGURATION_Handle *config)
{
unsigned int nhost;
+ unsigned int nsearchstrs;
if (NULL == args[0])
{
}
for (nhost = 0; nhost < num_hosts; nhost++)
{
- if (GNUNET_YES != GNUNET_TESTBED_is_host_habitable (hosts[nhost]))
+ if (GNUNET_YES != GNUNET_TESTBED_is_host_habitable (hosts[nhost], config))
{
fprintf (stderr, _("Host %s cannot start testbed\n"),
GNUNET_TESTBED_host_get_hostname (hosts[nhost]));
GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
return;
}
+ if ( (NULL != data_filename) &&
+ (NULL == (data_file =
+ GNUNET_DISK_file_open (data_filename,
+ GNUNET_DISK_OPEN_READWRITE |
+ GNUNET_DISK_OPEN_TRUNCATE |
+ GNUNET_DISK_OPEN_CREATE,
+ GNUNET_DISK_PERM_USER_READ |
+ GNUNET_DISK_PERM_USER_WRITE))) )
+ GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
+ "open",
+ data_filename);
if (GNUNET_YES != GNUNET_DISK_directory_test (args[1]))
{
fprintf (stderr, _("Specified policies directory does not exist. Exiting.\n"));
GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
return;
}
- num_search_strings = load_search_strings (args[2], &search_strings);
+ nsearchstrs = load_search_strings (args[2], &search_strings, num_search_strings);
+ if (num_search_strings != nsearchstrs)
+ {
+ num_search_strings = nsearchstrs;
+ fprintf (stderr, _("Error loading search strings. Given file does not contain enough strings. Exiting.\n"));
+ GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
+ return;
+ }
if (0 >= num_search_strings || NULL == search_strings)
{
fprintf (stderr, _("Error loading search strings. Exiting.\n"));
main (int argc, char *const *argv)
{
static const struct GNUNET_GETOPT_CommandLineOption options[] = {
- { 'n', "num-links", "COUNT",
- gettext_noop ("create COUNT number of random links"),
- GNUNET_YES, &GNUNET_GETOPT_set_uint, &num_links },
- { 'e', "num-errors", "COUNT",
- gettext_noop ("tolerate COUNT number of continious timeout failures"),
- GNUNET_YES, &GNUNET_GETOPT_set_uint, &num_cont_fails },
- { 't', "matching-timeout", "TIMEOUT",
- gettext_noop ("wait TIMEOUT seconds before considering a string match as failed"),
- GNUNET_YES, &GNUNET_GETOPT_set_uint, &search_timeout_sec },
- { 's', "search-wait", "WAIT",
- gettext_noop ("wait WAIT minutes before starting string search"),
- GNUNET_YES, &GNUNET_GETOPT_set_uint, &search_wait_min },
+ {'d', "details", "FILENAME",
+ gettext_noop ("name of the file for writing statistics"),
+ 1, &GNUNET_GETOPT_set_string, &data_filename},
+ {'n', "num-links", "COUNT",
+ gettext_noop ("create COUNT number of random links between peers"),
+ GNUNET_YES, &GNUNET_GETOPT_set_uint, &linking_factor },
+ {'t', "matching-timeout", "TIMEOUT",
+ gettext_noop ("wait TIMEOUT before considering a string match as failed"),
+ GNUNET_YES, &GNUNET_GETOPT_set_relative_time, &search_timeout },
+ {'s', "search-delay", "DELAY",
+ gettext_noop ("wait DELAY before starting string search"),
+ GNUNET_YES, &GNUNET_GETOPT_set_relative_time, &search_delay },
+ {'a', "num-search-strings", "COUNT",
+ gettext_noop ("number of search strings to read from search strings file"),
+ GNUNET_YES, &GNUNET_GETOPT_set_uint, &num_search_strings },
+ {'p', "max-path-compression", "MAX_PATH_COMPRESSION",
+ gettext_noop ("maximum path compression length"),
+ 1, &GNUNET_GETOPT_set_uint, &max_path_compression},
GNUNET_GETOPT_OPTION_END
};
int ret;
GNUNET_PROGRAM_run (argc, argv, "gnunet-regex-profiler [OPTIONS] hosts-file policy-dir search-strings-file",
_("Profiler for regex/mesh"),
options, &run, NULL);
+ GNUNET_free ((void*) argv);
if (GNUNET_OK != ret)
return ret;
if (GNUNET_OK != result)