gnunet-svn
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[GNUnet-SVN] r16741 - gnunet/src/mesh


From: gnunet
Subject: [GNUnet-SVN] r16741 - gnunet/src/mesh
Date: Fri, 9 Sep 2011 17:38:50 +0200

Author: bartpolot
Date: 2011-09-09 17:38:50 +0200 (Fri, 09 Sep 2011)
New Revision: 16741

Modified:
   gnunet/src/mesh/gnunet-service-mesh.c
   gnunet/src/mesh/mesh_api_new.c
   gnunet/src/mesh/test_mesh_local.c
Log:
Fixed test local to pass at least when DHT is not used 


Modified: gnunet/src/mesh/gnunet-service-mesh.c
===================================================================
--- gnunet/src/mesh/gnunet-service-mesh.c       2011-09-09 15:06:53 UTC (rev 
16740)
+++ gnunet/src/mesh/gnunet-service-mesh.c       2011-09-09 15:38:50 UTC (rev 
16741)
@@ -817,8 +817,11 @@
 announce_application (void *cls, const GNUNET_HashCode * key, void *value)
 {
   /* FIXME are hashes in multihash map equal on all aquitectures? */
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "MESH:  putting in DHT %s\n",
+              GNUNET_h2s_full(key));
   GNUNET_DHT_put (dht_handle, key, 10U, GNUNET_DHT_RO_RECORD_ROUTE,
-                  GNUNET_BLOCK_TYPE_ANY, sizeof (struct GNUNET_PeerIdentity),
+                  GNUNET_BLOCK_TYPE_TEST, sizeof (struct GNUNET_PeerIdentity),
                   (const char *) &my_full_id,
                   GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get (),
                                             APP_ANNOUNCE_TIME),
@@ -880,7 +883,7 @@
                   &my_full_id.hashPubKey,       /* Key to use */
                   10U,          /* Replication level */
                   GNUNET_DHT_RO_RECORD_ROUTE,   /* DHT options */
-                  GNUNET_BLOCK_TYPE_ANY,        /* Block type */
+                  GNUNET_BLOCK_TYPE_TEST,        /* Block type */
                   0,            /* Size of the data */
                   NULL,         /* Data itself */
                   GNUNET_TIME_absolute_get_forever (),  /* Data expiration */
@@ -1877,7 +1880,7 @@
     GNUNET_PEER_resolve (peer_info->id, &pi);
     peer_info->dhtget = GNUNET_DHT_get_start (dht_handle,       /* handle */
                                               GNUNET_TIME_UNIT_FOREVER_REL,
-                                              GNUNET_BLOCK_TYPE_ANY, /* type */
+                                              GNUNET_BLOCK_TYPE_TEST, /* type 
*/
                                               &pi.hashPubKey, /*key to search 
*/
                                               4,       /* replication level */
                                               GNUNET_DHT_RO_RECORD_ROUTE,
@@ -1969,8 +1972,13 @@
     /* we don't have a route to the peer, let's try a direct lookup */
     if (NULL == peer_info->dhtget)
     {
-      peer_info->dhtget = GNUNET_DHT_get_start (dht_handle, 
GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_BLOCK_TYPE_ANY, &pi->hashPubKey, 10U,  /* 
replication level */
-                                                GNUNET_DHT_RO_RECORD_ROUTE, 
NULL,       /* bloom filter */
+      peer_info->dhtget = GNUNET_DHT_get_start (dht_handle, /* handle */
+                                                GNUNET_TIME_UNIT_FOREVER_REL,
+                                                GNUNET_BLOCK_TYPE_TEST,
+                                                &pi->hashPubKey,
+                                                10U,  /* replication level */
+                                                GNUNET_DHT_RO_RECORD_ROUTE,
+                                                NULL,   /* bloom filter */
                                                 0,      /* mutator */
                                                 NULL,   /* xquery */
                                                 0,      /* xquery bits */
@@ -2036,18 +2044,26 @@
       continue;
     }
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: matching client found\n");
-    GNUNET_CONTAINER_multihashmap_iterate (c->tunnels, &delete_tunnel_entry, 
c);
-    GNUNET_CONTAINER_multihashmap_destroy (c->tunnels);
+    if (NULL != c->tunnels)
+    {
+      GNUNET_CONTAINER_multihashmap_iterate (c->tunnels,
+                                             &delete_tunnel_entry,
+                                             c);
+      GNUNET_CONTAINER_multihashmap_destroy (c->tunnels);
+    }
 
     /* deregister clients applications */
-    GNUNET_CONTAINER_multihashmap_iterate(c->apps, &deregister_app, NULL);
-    GNUNET_CONTAINER_multihashmap_destroy(c->apps);
+    if (NULL != c->apps)
+    {
+      GNUNET_CONTAINER_multihashmap_iterate(c->apps, &deregister_app, NULL);
+      GNUNET_CONTAINER_multihashmap_destroy(c->apps);
+    }
     if (0 == GNUNET_CONTAINER_multihashmap_size(applications))
     {
       GNUNET_SCHEDULER_cancel (announce_applications_task);
     }
-
-    GNUNET_CONTAINER_multihashmap_destroy(c->types);
+    if (NULL != c->types)
+      GNUNET_CONTAINER_multihashmap_destroy(c->types);
     GNUNET_CONTAINER_DLL_remove (clients, clients_tail, c);
     next = c->next;
     GNUNET_free (c);
@@ -2359,7 +2375,9 @@
   /* Start DHT search if needed */
   if (MESH_PEER_READY != peer_info->state && NULL == peer_info->dhtget)
   {
-    peer_info->dhtget = GNUNET_DHT_get_start (dht_handle, 
GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_BLOCK_TYPE_ANY, 
&peer_msg->peer.hashPubKey, 4,   /* replication level */
+    peer_info->dhtget = GNUNET_DHT_get_start (dht_handle, 
GNUNET_TIME_UNIT_FOREVER_REL,
+                                              GNUNET_BLOCK_TYPE_TEST,
+                                              &peer_msg->peer.hashPubKey, 4,   
/* replication level */
                                               GNUNET_DHT_RO_RECORD_ROUTE, 
NULL, /* bloom filter */
                                               0,        /* mutator */
                                               NULL,     /* xquery */
@@ -2506,11 +2524,12 @@
     pc.header.size = htons (sizeof (struct GNUNET_MESH_PeerControl));
     pc.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_LOCAL_PEER_ADD);
     pc.tunnel_id = htonl (t->local_tid);
-    pc.peer = my_full_id;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:  notifying client\n");
     GNUNET_SERVER_notification_context_unicast (nc,   /* context */
                                                 client,       /* dest */
                                                 &pc.header,   /* msg */
                                                 GNUNET_NO);   /* can drop? */
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:  Done\n");
     GNUNET_SERVER_receive_done (client, GNUNET_OK);
     return;
   }
@@ -2519,10 +2538,13 @@
   {
     GNUNET_DHT_get_stop (c->dht_get_type);
   }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "MESH:  looking in DHT for %s\n",
+              GNUNET_h2s_full(&hash));
   c->dht_get_type =
       GNUNET_DHT_get_start (dht_handle,
                             GNUNET_TIME_UNIT_FOREVER_REL,
-                            GNUNET_BLOCK_TYPE_ANY,
+                            GNUNET_BLOCK_TYPE_TEST,
                             &hash,
                             10U,
                             GNUNET_DHT_RO_RECORD_ROUTE,

Modified: gnunet/src/mesh/mesh_api_new.c
===================================================================
--- gnunet/src/mesh/mesh_api_new.c      2011-09-09 15:06:53 UTC (rev 16740)
+++ gnunet/src/mesh/mesh_api_new.c      2011-09-09 15:38:50 UTC (rev 16741)
@@ -773,6 +773,7 @@
   GNUNET_PEER_Id id;
   uint16_t size;
 
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "mesh: processig peer event\n");
   size = ntohs (msg->header.size);
   if (size != sizeof (struct GNUNET_MESH_PeerControl))
   {
@@ -788,8 +789,9 @@
   id = GNUNET_PEER_search (&msg->peer);
   if ((p = retrieve_peer (t, id)) == NULL)
     p = add_peer_to_tunnel (t, &msg->peer);
-  if (GNUNET_MESSAGE_TYPE_MESH_LOCAL_PEER_ADD == msg->header.type)
+  if (GNUNET_MESSAGE_TYPE_MESH_LOCAL_PEER_ADD == ntohs(msg->header.type))
   {
+    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "mesh: adding peer\n");
     if (NULL != t->connect_handler)
     {
       atsi.type = 0;
@@ -800,6 +802,7 @@
   }
   else
   {
+    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "mesh: removing peer\n");
     if (NULL != t->disconnect_handler && p->connected)
     {
       t->disconnect_handler (t->cls, &msg->peer);
@@ -807,6 +810,7 @@
     remove_peer_from_tunnel (p);
     GNUNET_free (p);
   }
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "mesh: processing peer event END\n");
 }
 
 
@@ -902,7 +906,9 @@
 {
   struct GNUNET_MESH_Handle *h = cls;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "mesh: received a message from MESH\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "mesh: received a message type %hu from MESH\n",
+              ntohs (msg->type));
   if (msg == NULL)
   {
     reconnect (h);

Modified: gnunet/src/mesh/test_mesh_local.c
===================================================================
--- gnunet/src/mesh/test_mesh_local.c   2011-09-09 15:06:53 UTC (rev 16740)
+++ gnunet/src/mesh/test_mesh_local.c   2011-09-09 15:38:50 UTC (rev 16741)
@@ -181,6 +181,7 @@
     const struct GNUNET_PeerIdentity * peer)
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: peer connected\n");
+  GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_SECONDS, &do_shutdown, NULL);
 }
 
 
@@ -215,7 +216,16 @@
 static struct GNUNET_MESH_MessageHandler handlers2[] = { {NULL, 0, 0} };
 
 
+/**
+ * Start looking for a peer by type
+ */
+static void
+do_find (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  GNUNET_MESH_peer_request_connect_by_type(t, 1);
+}
 
+
 /**
  * Main test function
  */
@@ -226,7 +236,7 @@
   static const GNUNET_MESH_ApplicationType app1[] = { 1, 0 };
   static const GNUNET_MESH_ApplicationType app2[] = { 0 };
 
-  test_task = (GNUNET_SCHEDULER_TaskIdentifier) 0;
+  test_task = GNUNET_SCHEDULER_NO_TASK;
   mesh_peer_1 = GNUNET_MESH_connect (cfg,       /* configuration */
                                      10,        /* queue size */
                                      (void *) 1,        /* cls */
@@ -257,9 +267,7 @@
                                  &peer_conected,
                                  &peer_disconnected,
                                  (void *) 2);
-  GNUNET_MESH_peer_request_connect_by_type(t, 1);
-
-
+  GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_SECONDS, &do_find, NULL);
 }
 
 




reply via email to

[Prev in Thread] Current Thread [Next in Thread]