#define VERBOSE_TESTING GNUNET_NO
+#define VERBOSE_TOPOLOGY GNUNET_YES
+
#define DEBUG_CHURN GNUNET_NO
/**
*/
#define HIGH_PORT 56000
-#define MAX_OUTSTANDING_CONNECTIONS 10
+#define MAX_OUTSTANDING_CONNECTIONS 40
#define MAX_CONCURRENT_HOSTKEYS 10
*/
"CONNECT_DFS",
+ /**
+ * Find the N closest peers to each allowed peer in the
+ * topology and make sure a connection to those peers
+ * exists in the connect topology.
+ */
+ "CONNECT_CLOSEST",
+
/**
* No options specified.
*/
GNUNET_CONFIGURATION_set_value_string(uc.ret, "transport-udp", "BINDTO", "127.0.0.1");
}
-
*port = (uint16_t) uc.nport;
*upnum = uc.upnum;
uc.fdnum++;
/**
* Create a topology given a peer group (set of running peers)
- * and a connection processor.
+ * and a connection processor. This particular function creates
+ * the connections for a 2d-torus, plus additional "closest"
+ * connections per peer.
*
* @param pg the peergroup to create the topology on
* @param proc the connection processor to call to actually set
*/
static int
random_connect_iterator (void *cls,
- const GNUNET_HashCode * key,
- void *value)
+ const GNUNET_HashCode * key,
+ void *value)
{
struct RandomContext *random_ctx = cls;
double random_number;
return count;
}
+
+struct FindClosestContext
+{
+ /**
+ * The currently known closest peer.
+ */
+ struct GNUNET_TESTING_Daemon *closest;
+
+ /**
+ * The info for the peer we are adding connections for.
+ */
+ struct PeerData *curr_peer;
+
+ /**
+ * The distance (bits) between the current
+ * peer and the currently known closest.
+ */
+ unsigned int closest_dist;
+
+ /**
+ * The offset of the closest known peer in
+ * the peer group.
+ */
+ unsigned int closest_num;
+};
+
+/**
+ * Iterator over hash map entries of the allowed
+ * peer connections. Find the closest, not already
+ * connected peer and return it.
+ *
+ * @param cls closure (struct FindClosestContext)
+ * @param key current key code (hash of offset in pg)
+ * @param value value in the hash map - a GNUNET_TESTING_Daemon
+ * @return GNUNET_YES if we should continue to
+ * iterate,
+ * GNUNET_NO if not.
+ */
+static
+int find_closest_peers (void *cls, const GNUNET_HashCode * key, void *value)
+{
+ struct FindClosestContext *closest_ctx = cls;
+ struct GNUNET_TESTING_Daemon *daemon = value;
+
+ if (((closest_ctx->closest == NULL) ||
+ (GNUNET_CRYPTO_hash_matching_bits(&daemon->id.hashPubKey, &closest_ctx->curr_peer->daemon->id.hashPubKey) > closest_ctx->closest_dist))
+ && (GNUNET_YES != GNUNET_CONTAINER_multihashmap_contains(closest_ctx->curr_peer->connect_peers, key)))
+ {
+ closest_ctx->closest_dist = GNUNET_CRYPTO_hash_matching_bits(&daemon->id.hashPubKey, &closest_ctx->curr_peer->daemon->id.hashPubKey);
+ closest_ctx->closest = daemon;
+ uid_from_hash(key, &closest_ctx->closest_num);
+ }
+ return GNUNET_YES;
+}
+
+/**
+ * From the set of connections possible, choose at num connections per
+ * peer based on depth which are closest out of those allowed. Guaranteed
+ * to add num peers to connect to, provided there are that many peers
+ * in the underlay topology to connect to.
+ *
+ * @param pg the peergroup we are dealing with
+ * @param num how many connections at least should each peer have (if possible)?
+ * @param proc processor to actually add the connections
+ */
+void
+add_closest (struct GNUNET_TESTING_PeerGroup *pg, unsigned int num, GNUNET_TESTING_ConnectionProcessor proc)
+{
+ struct FindClosestContext closest_ctx;
+ uint32_t pg_iter;
+ uint32_t i;
+
+ for (i = 0; i < num; i++) /* Each time find a closest peer (from those available) */
+ {
+ for (pg_iter = 0; pg_iter < pg->total; pg_iter++)
+ {
+ closest_ctx.curr_peer = &pg->peers[pg_iter];
+ closest_ctx.closest = NULL;
+ closest_ctx.closest_dist = 0;
+ closest_ctx.closest_num = 0;
+ GNUNET_CONTAINER_multihashmap_iterate(pg->peers[pg_iter].allowed_peers, &find_closest_peers, &closest_ctx);
+ if (closest_ctx.closest != NULL)
+ {
+ GNUNET_assert((0 <= closest_ctx.closest_num) && (closest_ctx.closest_num < pg->total));
+ proc(pg, pg_iter, closest_ctx.closest_num);
+ }
+ }
+ }
+}
+
/**
* From the set of connections possible, choose at least num connections per
* peer based on depth first traversal of peer connections. If DFS leaves
}
}
+struct DuplicateStats
+{
+ /**
+ * Next item in the list
+ */
+ struct DuplicateStats *next;
+
+ /**
+ * Nasty string, concatenation of relevant information.
+ */
+ char *unique_string;
+};
+
+/**
+ * Check whether the combination of port/host/unix domain socket
+ * already exists in the list of peers being checked for statistics.
+ *
+ * @param pg the peergroup in question
+ * @param specific_peer the peer we're concerned with
+ * @param stats_list the list to return to the caller
+ *
+ * @return GNUNET_YES if the statistics instance has been seen already,
+ * GNUNET_NO if not (and we may have added it to the list)
+ */
+static int
+stats_check_existing(struct GNUNET_TESTING_PeerGroup *pg, struct PeerData *specific_peer, struct DuplicateStats **stats_list)
+{
+ struct DuplicateStats *pos;
+ char *unix_domain_socket;
+ unsigned long long port;
+ char *to_match;
+ if (GNUNET_YES != GNUNET_CONFIGURATION_get_value_yesno(pg->cfg, "testing", "single_statistics_per_host"))
+ return GNUNET_NO; /* Each peer has its own statistics instance, do nothing! */
+
+ pos = *stats_list;
+ if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(specific_peer->cfg, "statistics", "unixpath", &unix_domain_socket))
+ return GNUNET_NO;
+
+ GNUNET_CONFIGURATION_get_value_number(specific_peer->cfg, "statistics", "port", &port);
+
+ if (specific_peer->daemon->hostname != NULL)
+ GNUNET_asprintf(&to_match, "%s%s%llu", specific_peer->daemon->hostname, unix_domain_socket, port);
+ else
+ GNUNET_asprintf(&to_match, "%s%llu", unix_domain_socket, port);
+
+ while (pos != NULL)
+ {
+ if (0 == strcmp(to_match, pos->unique_string))
+ {
+ GNUNET_free(to_match);
+ return GNUNET_YES;
+ }
+ pos = pos->next;
+ }
+ pos = GNUNET_malloc(sizeof(struct DuplicateStats));
+ pos->unique_string = to_match;
+ pos->next = *stats_list;
+ *stats_list = pos;
+ return GNUNET_NO;
+}
/**
* Iterate over all (running) peers in the peer group, retrieve
struct StatsCoreContext *core_ctx;
unsigned int i;
unsigned int total_count;
+ struct DuplicateStats *stats_list;
+ struct DuplicateStats *pos;
+ stats_list = NULL;
/* Allocate a single stats iteration context */
stats_context = GNUNET_malloc(sizeof(struct StatsIterateContext));
stats_context->proc = proc;
stats_context->cls = cls;
total_count = 0;
+
for (i = 0; i < pg->total; i++)
{
- if (pg->peers[i].daemon->running == GNUNET_YES)
+ if ((pg->peers[i].daemon->running == GNUNET_YES) && (GNUNET_NO == stats_check_existing(pg, &pg->peers[i], &stats_list)))
{
/* Allocate one core context per core we need to connect to */
core_ctx = GNUNET_malloc(sizeof(struct StatsCoreContext));
total_count++;
}
}
+
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Retrieving stats from %u total instances.\n", total_count);
stats_context->total = total_count;
+ if (stats_list != NULL)
+ {
+ pos = stats_list;
+ while(pos != NULL)
+ {
+ GNUNET_free(pos->unique_string);
+ stats_list = pos->next;
+ GNUNET_free(pos);
+ pos = stats_list->next;
+ }
+ }
return;
}
#endif
perform_dfs(pg, (int)option_modifier);
break;
+ case GNUNET_TESTING_TOPOLOGY_OPTION_ADD_CLOSEST:
+#if VERBOSE_TOPOLOGY
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ _("Finding additional %u closest peers each (if possible)\n"), (unsigned int)option_modifier);
+#endif
+ add_closest(pg, (unsigned int)option_modifier, &add_actual_connections);
+ break;
case GNUNET_TESTING_TOPOLOGY_OPTION_NONE:
break;
case GNUNET_TESTING_TOPOLOGY_OPTION_ALL: