*/
struct GetSlaveConfigData
{
- /**
- * The operation closure
- */
- void *op_cls;
-
/**
* The id of the slave controller
*/
*/
struct GNUNET_TESTBED_ControllerLinkMessage *msg;
- /**
- * The operation closure
- */
- void *op_cls;
-
};
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");
}
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)
data = opc->data;
GNUNET_assert (NULL != data);
- event.details.operation_finished.op_cls = data->op_cls;
GNUNET_free (data);
opc->data = NULL;
}
if (NULL != c->cc)
c->cc (c->cc_cls, &event);
}
+ else
+ LOG_DEBUG ("Not calling callback\n");
return GNUNET_YES;
}
{
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);
const struct GNUNET_TESTBED_SlaveConfiguration * msg)
{
struct OperationContext *opc;
- void *op_cls;
uint64_t op_id;
struct GNUNET_TESTBED_EventInformation event;
{
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;
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);
}
&helper_mst, &helper_exp_cb, cp);
else
{
- char *remote_args[8];
+ char *remote_args[10];
unsigned int argp;
const char *username;
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);
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",
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;
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";
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 */
}
(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);
}
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);
/**
- * Same as the GNUNET_TESTBED_controller_link, however expects configuration in
- * serialized and compressed
+ * Same as the GNUNET_TESTBED_controller_link_2, but with ids for delegated host
+ * and slave host
*
* @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
+ * @param slave_host_id id of the host which is used to run the slave controller
* @param sxcfg serialized and compressed configuration
* @param sxcfg_size the size sxcfg
* @param scfg_size the size of uncompressed serialized configuration
* @return the operation handle
*/
struct GNUNET_TESTBED_Operation *
-GNUNET_TESTBED_controller_link_2 (void *op_cls,
- struct GNUNET_TESTBED_Controller *master,
- struct GNUNET_TESTBED_Host *delegated_host,
- struct GNUNET_TESTBED_Host *slave_host,
- const char *sxcfg, size_t sxcfg_size,
- size_t scfg_size, int is_subordinate)
+GNUNET_TESTBED_controller_link_2_ (void *op_cls,
+ struct GNUNET_TESTBED_Controller *master,
+ uint32_t delegated_host_id,
+ uint32_t slave_host_id,
+ const char *sxcfg, size_t sxcfg_size,
+ size_t scfg_size, int is_subordinate)
{
struct OperationContext *opc;
struct GNUNET_TESTBED_ControllerLinkMessage *msg;
struct ControllerLinkData *data;
uint16_t msg_size;
- GNUNET_assert (GNUNET_YES ==
- GNUNET_TESTBED_is_host_registered_ (delegated_host, master));
- if ((NULL != slave_host) && (0 != GNUNET_TESTBED_host_get_id_ (slave_host)))
- GNUNET_assert (GNUNET_YES ==
- GNUNET_TESTBED_is_host_registered_ (slave_host, master));
msg_size = sxcfg_size + sizeof (struct GNUNET_TESTBED_ControllerLinkMessage);
msg = GNUNET_malloc (msg_size);
msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_LCONTROLLERS);
msg->header.size = htons (msg_size);
- msg->delegated_host_id = htonl (GNUNET_TESTBED_host_get_id_ (delegated_host));
- msg->slave_host_id =
- htonl (GNUNET_TESTBED_host_get_id_
- ((NULL != slave_host) ? slave_host : master->host));
+ msg->delegated_host_id = htonl (delegated_host_id);
+ msg->slave_host_id = htonl (slave_host_id);
msg->config_size = htons ((uint16_t) scfg_size);
msg->is_subordinate = (GNUNET_YES == is_subordinate) ? 1 : 0;
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,
}
+/**
+ * Same as the GNUNET_TESTBED_controller_link, however expects configuration in
+ * serialized and compressed
+ *
+ * @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 sxcfg serialized and compressed configuration
+ * @param sxcfg_size the size sxcfg
+ * @param scfg_size the size of uncompressed serialized configuration
+ * @param is_subordinate GNUNET_YES if the controller at delegated_host should
+ * be started by the slave controller; GNUNET_NO if the slave
+ * controller has to connect to the already started delegated
+ * controller via TCP/IP
+ * @return the operation handle
+ */
+struct GNUNET_TESTBED_Operation *
+GNUNET_TESTBED_controller_link_2 (void *op_cls,
+ struct GNUNET_TESTBED_Controller *master,
+ struct GNUNET_TESTBED_Host *delegated_host,
+ struct GNUNET_TESTBED_Host *slave_host,
+ const char *sxcfg, size_t sxcfg_size,
+ size_t scfg_size, int is_subordinate)
+{
+ uint32_t delegated_host_id;
+ uint32_t slave_host_id;
+
+ GNUNET_assert (GNUNET_YES ==
+ GNUNET_TESTBED_is_host_registered_ (delegated_host, master));
+ delegated_host_id = GNUNET_TESTBED_host_get_id_ (delegated_host);
+ slave_host_id =
+ GNUNET_TESTBED_host_get_id_ ((NULL != slave_host)
+ ? slave_host : master->host);
+ if ((NULL != slave_host) && (0 != GNUNET_TESTBED_host_get_id_ (slave_host)))
+ GNUNET_assert (GNUNET_YES ==
+ GNUNET_TESTBED_is_host_registered_ (slave_host, master));
+
+ return GNUNET_TESTBED_controller_link_2_ (op_cls,
+ master,
+ delegated_host_id,
+ slave_host_id,
+ sxcfg, sxcfg_size,
+ scfg_size, is_subordinate);
+ GNUNET_break (0);
+}
+
+
/**
* Compresses given configuration using zlib compress
*
}
+/**
+ * Same as the GNUNET_TESTBED_controller_link, but with ids for delegated host
+ * and slave host
+ *
+ * @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_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
+ * controller has to connect to the already started delegated
+ * controller via TCP/IP
+ * @return the operation handle
+ */
+struct GNUNET_TESTBED_Operation *
+GNUNET_TESTBED_controller_link_ (void *op_cls,
+ struct GNUNET_TESTBED_Controller *master,
+ uint32_t delegated_host_id,
+ uint32_t slave_host_id,
+ const struct GNUNET_CONFIGURATION_Handle
+ *slave_cfg,
+ int is_subordinate)
+{
+ struct GNUNET_TESTBED_Operation *op;
+ char *config;
+ char *cconfig;
+ size_t cc_size;
+ size_t config_size;
+
+ config = GNUNET_CONFIGURATION_serialize (slave_cfg, &config_size);
+ cc_size = GNUNET_TESTBED_compress_config_ (config, config_size, &cconfig);
+ GNUNET_free (config);
+ /* Configuration doesn't fit in 1 message */
+ GNUNET_assert ((UINT16_MAX -
+ sizeof (struct GNUNET_TESTBED_ControllerLinkMessage)) >=
+ cc_size);
+ op = GNUNET_TESTBED_controller_link_2_ (op_cls, master, delegated_host_id,
+ slave_host_id, (const char *) cconfig,
+ cc_size, config_size, is_subordinate);
+ GNUNET_free (cconfig);
+ return op;
+}
+
+
/**
* Create a link from slave controller to delegated controller. Whenever the
* master controller is asked to start a peer at the delegated controller the
const struct GNUNET_CONFIGURATION_Handle
*slave_cfg, int is_subordinate)
{
- struct GNUNET_TESTBED_Operation *op;
- char *config;
- char *cconfig;
- size_t cc_size;
- size_t config_size;
+ uint32_t slave_host_id;
+ uint32_t delegated_host_id;
GNUNET_assert (GNUNET_YES ==
GNUNET_TESTBED_is_host_registered_ (delegated_host, master));
- if ((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 ==
GNUNET_TESTBED_is_host_registered_ (slave_host, master));
- config = GNUNET_CONFIGURATION_serialize (slave_cfg, &config_size);
- cc_size = GNUNET_TESTBED_compress_config_ (config, config_size, &cconfig);
- GNUNET_free (config);
- /* Configuration doesn't fit in 1 message */
- GNUNET_assert ((UINT16_MAX -
- sizeof (struct GNUNET_TESTBED_ControllerLinkMessage)) >= cc_size);
- op = GNUNET_TESTBED_controller_link_2 (op_cls, master, delegated_host,
- slave_host, (const char *) cconfig,
- cc_size, config_size, is_subordinate);
- GNUNET_free (cconfig);
- return op;
+ return GNUNET_TESTBED_controller_link_ (op_cls, master,
+ delegated_host_id,
+ slave_host_id,
+ slave_cfg,
+ is_subordinate);
+
}
/**
- * Function to acquire the configuration of a running slave controller. The
- * completion of the operation is signalled through the controller_cb from
- * GNUNET_TESTBED_controller_connect(). If the operation is successful the
- * handle to the configuration is available in the generic pointer of
- * operation_finished field of struct GNUNET_TESTBED_EventInformation.
+ * Like GNUNET_TESTBED_get_slave_config(), however without the host registration
+ * check. Another difference is that this function takes the id of the slave
+ * host.
*
* @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
- * @return the operation handle; NULL if the slave_host is not registered at
- * master
+ * @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 *
-GNUNET_TESTBED_get_slave_config (void *op_cls,
- struct GNUNET_TESTBED_Controller *master,
- struct GNUNET_TESTBED_Host *slave_host)
-{
+GNUNET_TESTBED_get_slave_config_ (void *op_cls,
+ struct GNUNET_TESTBED_Controller *master,
+ uint32_t slave_host_id)
+{
struct OperationContext *opc;
struct GetSlaveConfigData *data;
- if (GNUNET_NO == GNUNET_TESTBED_is_host_registered_ (slave_host, master))
- return NULL;
data = GNUNET_malloc (sizeof (struct GetSlaveConfigData));
- data->slave_id = GNUNET_TESTBED_host_get_id_ (slave_host);
- data->op_cls = op_cls;
+ data->slave_id = slave_host_id;
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);
}
+/**
+ * Function to acquire the configuration of a running slave controller. The
+ * completion of the operation is signalled through the controller_cb from
+ * GNUNET_TESTBED_controller_connect(). If the operation is successful the
+ * handle to the configuration is available in the generic pointer of
+ * operation_finished field of struct GNUNET_TESTBED_EventInformation.
+ *
+ * @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
+ * @return the operation handle; NULL if the slave_host is not registered at
+ * master
+ */
+struct GNUNET_TESTBED_Operation *
+GNUNET_TESTBED_get_slave_config (void *op_cls,
+ struct GNUNET_TESTBED_Controller *master,
+ struct GNUNET_TESTBED_Host *slave_host)
+{
+ if (GNUNET_NO == GNUNET_TESTBED_is_host_registered_ (slave_host, master))
+ return NULL;
+ return GNUNET_TESTBED_get_slave_config_ (op_cls, master,
+ GNUNET_TESTBED_host_get_id_ (slave_host));
+}
+
+
/**
* Ask the testbed controller to write the current overlay topology to
* a file. Naturally, the file will only contain a snapshot as the
void
GNUNET_TESTBED_operation_done (struct GNUNET_TESTBED_Operation *operation)
{
- switch (operation->type)
- {
- case OP_PEER_CREATE:
- case OP_PEER_DESTROY:
- case OP_PEER_START:
- case OP_PEER_STOP:
- case OP_PEER_INFO:
- case OP_OVERLAY_CONNECT:
- case OP_LINK_CONTROLLERS:
GNUNET_TESTBED_operation_release_ (operation);
- return;
- default:
- GNUNET_assert (0);
- break;
- }
}