*/
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;
}
LOG_DEBUG ("Operation not found\n");
return GNUNET_YES;
}
- GNUNET_CONTAINER_DLL_remove (opc->c->ocq_head, opc->c->ocq_tail, opc);
if (OP_FORWARDED == opc->type)
{
handle_forwarded_operation_msg (c, opc,
(const struct GNUNET_MessageHeader *) msg);
return GNUNET_YES;
}
+ GNUNET_CONTAINER_DLL_remove (opc->c->ocq_head, opc->c->ocq_tail, opc);
opc->state = OPC_STATE_FINISHED;
emsg = GNUNET_TESTBED_parse_error_string_ (msg);
if (NULL == emsg)
{
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);
}
uint64_t sub_op_id;
GNUNET_assert (NULL == oc_data->sub_opc);
- sub_op_id = oc_data->p1->controller->operation_counter++;
+ sub_op_id = GNUNET_TESTBED_get_next_op_id (oc_data->p1->controller);
get_cfg_msg =
GNUNET_TESTBED_generate_slavegetconfig_msg_
(sub_op_id, GNUNET_TESTBED_host_get_id_ (oc_data->p2->host));
&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 = master->operation_counter++;
+ 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,
&oprelease_link_controllers);
GNUNET_TESTBED_operation_queue_insert_ (master->opq_parallel_operations,
opc->op);
+ GNUNET_TESTBED_operation_begin_wait_ (opc->op);
return opc->op;
}
+/**
+ * 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);
+}
+
+
/**
* 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);
+
+}
+
+
+/**
+ * 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_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,
+ uint32_t slave_host_id)
+{
+ struct OperationContext *opc;
+ struct GetSlaveConfigData *data;
+
+ data = GNUNET_malloc (sizeof (struct GetSlaveConfigData));
+ 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);
+ GNUNET_TESTBED_operation_queue_insert_ (master->opq_parallel_operations,
+ opc->op);
+ GNUNET_TESTBED_operation_begin_wait_ (opc->op);
+ return opc->op;
}
struct GNUNET_TESTBED_Controller *master,
struct GNUNET_TESTBED_Host *slave_host)
{
- 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;
- opc = GNUNET_malloc (sizeof (struct OperationContext));
- opc->state = OPC_STATE_INIT;
- opc->c = master;
- opc->id = master->operation_counter++;
- opc->type = OP_GET_SLAVE_CONFIG;
- opc->data = data;
- opc->op =
- GNUNET_TESTBED_operation_create_ (opc, &opstart_get_slave_config,
- &oprelease_get_slave_config);
- GNUNET_TESTBED_operation_queue_insert_ (master->opq_parallel_operations,
- opc->op);
- return opc->op;
+ return GNUNET_TESTBED_get_slave_config_ (op_cls, master,
+ GNUNET_TESTBED_host_get_id_ (slave_host));
}
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;
- }
}
return emsg;
}
+
+/**
+ * Function to return the operation id for a controller. The operation id is
+ * created from the controllers host id and its internal operation counter.
+ *
+ * @param controller the handle to the controller whose operation id has to be incremented
+ * @return the incremented operation id.
+ */
+uint64_t
+GNUNET_TESTBED_get_next_op_id (struct GNUNET_TESTBED_Controller *controller)
+{
+ uint64_t op_id;
+
+ op_id = (uint64_t) GNUNET_TESTBED_host_get_id_ (controller->host);
+ op_id = op_id << 32;
+ op_id |= (uint64_t) controller->operation_counter++;
+ return op_id;
+}
+
/* end of testbed_api.c */
projects / oweals / gnunet.git / blobdiff