projects / oweals / gnunet.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
- relaxed to accommodate overlay linking timeouts
[oweals/gnunet.git] / src / testbed / testbed_api.c
diff --git a/src/testbed/testbed_api.c b/src/testbed/testbed_api.c
index f33336903bc7280dc88667c24f24e8aff281c071..ebb9496f2805a4d840f7d622e2f8f8b9ae063369 100644 (file)
--- a/src/testbed/testbed_api.c
+++ b/src/testbed/testbed_api.c
@@ -239,11 +239,6 @@ struct ForwardedOperationData
  */
 struct GetSlaveConfigData
 {
-  /**
-   * The operation closure
-   */
-  void *op_cls;
-
   /**
    * The id of the slave controller
    */
@@ -262,11 +257,6 @@ struct ControllerLinkData
    */
   struct GNUNET_TESTBED_ControllerLinkMessage *msg;
 
-  /**
-   * The operation closure
-   */
-  void *op_cls;
-
 };
 
 
@@ -389,7 +379,7 @@ handle_opsuccess (struct GNUNET_TESTBED_Controller *c,
   uint64_t op_id;
 
   op_id = GNUNET_ntohll (msg->operation_id);
-  LOG_DEBUG ("Operation %ul successful\n", op_id);
+  LOG_DEBUG ("Operation %lu successful\n", op_id);
   if (NULL == (opc = find_opc (c, op_id)))
   {
     LOG_DEBUG ("Operation not found\n");
@@ -397,7 +387,7 @@ handle_opsuccess (struct GNUNET_TESTBED_Controller *c,
   }
   event.type = GNUNET_TESTBED_ET_OPERATION_FINISHED;
   event.details.operation_finished.operation = opc->op;
-  event.details.operation_finished.op_cls = NULL;
+  event.details.operation_finished.op_cls = opc->op_cls;
   event.details.operation_finished.emsg = NULL;
   event.details.operation_finished.generic = NULL;
   switch (opc->type)
@@ -425,7 +415,6 @@ handle_opsuccess (struct GNUNET_TESTBED_Controller *c,
       
       data = opc->data;
       GNUNET_assert (NULL != data);      
-      event.details.operation_finished.op_cls = data->op_cls;
       GNUNET_free (data);
       opc->data = NULL;
     }
@@ -440,6 +429,8 @@ handle_opsuccess (struct GNUNET_TESTBED_Controller *c,
     if (NULL != c->cc)
       c->cc (c->cc_cls, &event);
   }
+  else
+    LOG_DEBUG ("Not calling callback\n");
   return GNUNET_YES;
 }
 
@@ -758,7 +749,7 @@ handle_op_fail_event (struct GNUNET_TESTBED_Controller *c,
   {
     event.type = GNUNET_TESTBED_ET_OPERATION_FINISHED;
     event.details.operation_finished.operation = opc->op;
-    event.details.operation_finished.op_cls = NULL;
+    event.details.operation_finished.op_cls = opc->op_cls;
     event.details.operation_finished.emsg = emsg;
     event.details.operation_finished.generic = NULL;
     c->cc (c->cc_cls, &event);
@@ -846,7 +837,6 @@ handle_slave_config (struct GNUNET_TESTBED_Controller *c,
                     const struct GNUNET_TESTBED_SlaveConfiguration * msg)
 {
   struct OperationContext *opc;
-  void *op_cls;
   uint64_t op_id;
   struct GNUNET_TESTBED_EventInformation event;  
 
@@ -860,8 +850,7 @@ handle_slave_config (struct GNUNET_TESTBED_Controller *c,
   {
     GNUNET_break (0);
     return GNUNET_YES;
-  }  
-  op_cls = ((struct GetSlaveConfigData *) opc->data)->op_cls;
+  }
   GNUNET_free (opc->data);
   opc->data = NULL;
   opc->state = OPC_STATE_FINISHED;
@@ -873,7 +862,7 @@ handle_slave_config (struct GNUNET_TESTBED_Controller *c,
     event.type = GNUNET_TESTBED_ET_OPERATION_FINISHED;   
     event.details.operation_finished.generic = opc->data;
     event.details.operation_finished.operation = opc->op;
-    event.details.operation_finished.op_cls = op_cls;
+    event.details.operation_finished.op_cls = opc->op_cls;
     event.details.operation_finished.emsg = NULL;
     c->cc (c->cc_cls, &event);
   }
@@ -1473,7 +1462,7 @@ GNUNET_TESTBED_controller_start (const char *controller_ip,
                              &helper_mst, &helper_exp_cb, cp);
   else
   {
-    char *remote_args[8];
+    char *remote_args[10];
     unsigned int argp;
     const char *username;
 
@@ -1491,10 +1480,12 @@ GNUNET_TESTBED_controller_start (const char *controller_ip,
     remote_args[argp++] = cp->port;
     remote_args[argp++] = "-o";
     remote_args[argp++] = "BatchMode=yes";
+    remote_args[argp++] = "-o";
+    remote_args[argp++] = "NoHostAuthenticationForLocalhost=yes";
     remote_args[argp++] = cp->dst;
     remote_args[argp++] = HELPER_TESTBED_BINARY_SSH;
     remote_args[argp++] = NULL;
-    GNUNET_assert (argp == 8);
+    GNUNET_assert (argp == 10);
     cp->helper =
         GNUNET_HELPER_start (GNUNET_NO, "ssh", remote_args, &helper_mst,
                              &helper_exp_cb, cp);
@@ -1575,6 +1566,7 @@ GNUNET_TESTBED_controller_connect (const struct GNUNET_CONFIGURATION_Handle
   unsigned long long max_parallel_operations;
   unsigned long long max_parallel_service_connections;
   unsigned long long max_parallel_topology_config_operations;
+  unsigned long long max_parallel_overlay_connect_operations;
 
   if (GNUNET_OK !=
       GNUNET_CONFIGURATION_get_value_number (cfg, "testbed",
@@ -1600,6 +1592,14 @@ GNUNET_TESTBED_controller_connect (const struct GNUNET_CONFIGURATION_Handle
     GNUNET_break (0);
     return NULL;
   }
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_number (cfg, "testbed",
+                                             "MAX_PARALLEL_OVERLAY_CONNECT_OPERATIONS",
+                                             &max_parallel_overlay_connect_operations))
+  {
+    GNUNET_break (0);
+    return NULL;
+  }
   controller = GNUNET_malloc (sizeof (struct GNUNET_TESTBED_Controller));
   controller->cc = cc;
   controller->cc_cls = cc_cls;
@@ -1637,7 +1637,10 @@ GNUNET_TESTBED_controller_connect (const struct GNUNET_CONFIGURATION_Handle
                                               max_parallel_service_connections);
   controller->opq_parallel_topology_config_operations=
       GNUNET_TESTBED_operation_queue_create_ ((unsigned int)
-                                              max_parallel_service_connections);
+                                              max_parallel_topology_config_operations);
+  controller->opq_parallel_overlay_connect_operations=
+      GNUNET_TESTBED_operation_queue_create_ ((unsigned int)
+                                              max_parallel_overlay_connect_operations);
   controller_hostname = GNUNET_TESTBED_host_get_hostname_ (host);
   if (NULL == controller_hostname)
     controller_hostname = "127.0.0.1";
@@ -1692,6 +1695,8 @@ GNUNET_TESTBED_controller_configure_sharing (struct GNUNET_TESTBED_Controller
   memcpy (&msg[1], service_name, service_name_size);
   GNUNET_TESTBED_queue_message_ (controller,
                                  (struct GNUNET_MessageHeader *) msg);
+  GNUNET_break (0);             /* This function is not yet implemented on the
+                                   testbed service */
 }
 
 
@@ -1726,6 +1731,8 @@ GNUNET_TESTBED_controller_disconnect (struct GNUNET_TESTBED_Controller
       (controller->opq_parallel_service_connections);
   GNUNET_TESTBED_operation_queue_destroy_
       (controller->opq_parallel_topology_config_operations);
+  GNUNET_TESTBED_operation_queue_destroy_
+      (controller->opq_parallel_overlay_connect_operations);
   GNUNET_free (controller);
 }
 
@@ -1787,9 +1794,13 @@ GNUNET_TESTBED_register_host (struct GNUNET_TESTBED_Controller *controller,
   msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_ADDHOST);
   msg->host_id = htonl (GNUNET_TESTBED_host_get_id_ (host));
   msg->ssh_port = htons (GNUNET_TESTBED_host_get_ssh_port_ (host));
-  msg->user_name_length = htons (user_name_length);
   if (NULL != username)
+  {
+    msg->user_name_length = htons (user_name_length - 1);
     memcpy (&msg[1], username, user_name_length);
+  }
+  else
+    msg->user_name_length = htons (user_name_length);
   strcpy (((void *) &msg[1]) + user_name_length, hostname);
   GNUNET_TESTBED_queue_message_ (controller,
                                  (struct GNUNET_MessageHeader *) msg);
@@ -1860,13 +1871,13 @@ GNUNET_TESTBED_controller_link_2_ (void *op_cls,
   memcpy (&msg[1], sxcfg, sxcfg_size);
   data = GNUNET_malloc (sizeof (struct ControllerLinkData));
   data->msg = msg;
-  data->op_cls = op_cls;
   opc = GNUNET_malloc (sizeof (struct OperationContext));
   opc->c = master;
   opc->data = data;
   opc->type = OP_LINK_CONTROLLERS;
   opc->id = GNUNET_TESTBED_get_next_op_id (opc->c);
   opc->state = OPC_STATE_INIT;
+  opc->op_cls = op_cls;
   msg->operation_id = GNUNET_htonll (opc->id);
   opc->op =
       GNUNET_TESTBED_operation_create_ (opc, &opstart_link_controllers,
@@ -1959,9 +1970,11 @@ GNUNET_TESTBED_compress_config_ (const char *config, size_t size,
  * @param op_cls the operation closure for the event which is generated to
  *          signal success or failure of this operation
  * @param master handle to the master controller who creates the association
- * @param delegated_host requests to which host should be delegated; cannot be NULL
- * @param slave_host which host is used to run the slave controller; use NULL to
- *          make the master controller connect to the delegated host
+ * @param delegated_host_id id of the host to which requests should be
+ *          delegated; cannot be NULL
+ * @param slave_host_id id of the host which should connect to controller
+ *          running on delegated host ; use NULL to make the master controller
+ *          connect to the delegated host
  * @param slave_cfg configuration to use for the slave controller
  * @param is_subordinate GNUNET_YES if the controller at delegated_host should
  *          be started by the slave controller; GNUNET_NO if the slave
@@ -2041,8 +2054,9 @@ GNUNET_TESTBED_controller_link (void *op_cls,
 
   GNUNET_assert (GNUNET_YES ==
                  GNUNET_TESTBED_is_host_registered_ (delegated_host, master));
-  slave_host_id = (NULL == slave_host) ?
-      0 : GNUNET_TESTBED_host_get_id_ (slave_host);
+  slave_host_id = 
+      GNUNET_TESTBED_host_get_id_ ((NULL != slave_host)
+                                   ? slave_host : master->host);
   delegated_host_id = GNUNET_TESTBED_host_get_id_ (delegated_host);
   if ((NULL != slave_host) && (0 != slave_host_id))
     GNUNET_assert (GNUNET_YES ==
@@ -2063,9 +2077,9 @@ GNUNET_TESTBED_controller_link (void *op_cls,
  *
  * @param op_cls the closure for the operation
  * @param master the handle to master controller
- * @param slave_host the host where the slave controller is running; the handle
- *          to the slave_host should remain valid until this operation is
- *          cancelled or marked as finished
+ * @param slave_host_id id of the host where the slave controller is running to
+ *          the slave_host should remain valid until this operation is cancelled
+ *          or marked as finished
  * @return the operation handle;
  */
 struct GNUNET_TESTBED_Operation *
@@ -2078,13 +2092,13 @@ GNUNET_TESTBED_get_slave_config_ (void *op_cls,
 
   data = GNUNET_malloc (sizeof (struct GetSlaveConfigData));
   data->slave_id = slave_host_id;
-  data->op_cls = op_cls;
   opc = GNUNET_malloc (sizeof (struct OperationContext));
   opc->state = OPC_STATE_INIT;
   opc->c = master;
   opc->id = GNUNET_TESTBED_get_next_op_id (master);
   opc->type = OP_GET_SLAVE_CONFIG;
   opc->data = data;
+  opc->op_cls = op_cls;
   opc->op =
       GNUNET_TESTBED_operation_create_ (opc, &opstart_get_slave_config,
                                         &oprelease_get_slave_config);
Unnamed repository; edit this file 'description' to name the repository.