#define HELPER_TESTBED_BINARY_SSH ". ~/.bashrc; gnunet-helper-testbed"
+/**
+ * Handle for controller process
+ */
+struct GNUNET_TESTBED_ControllerProc
+{
+ /**
+ * The process handle
+ */
+ struct GNUNET_HELPER_Handle *helper;
+
+ /**
+ * The host where the helper is run
+ */
+ struct GNUNET_TESTBED_Host *host;
+
+ /**
+ * The controller error callback
+ */
+ GNUNET_TESTBED_ControllerStatusCallback cb;
+
+ /**
+ * The closure for the above callback
+ */
+ void *cls;
+
+ /**
+ * The send handle for the helper
+ */
+ struct GNUNET_HELPER_SendHandle *shandle;
+
+ /**
+ * The message corresponding to send handle
+ */
+ struct GNUNET_MessageHeader *msg;
+
+ /**
+ * The port number for ssh; used for helpers starting ssh
+ */
+ char *port;
+
+ /**
+ * The ssh destination string; used for helpers starting ssh
+ */
+ char *dst;
+
+ /**
+ * The configuration of the running testbed service
+ */
+ struct GNUNET_CONFIGURATION_Handle *cfg;
+
+};
+
+
/**
* The message queue for sending messages to the controller service
*/
struct GetSlaveConfigData
{
/**
- * The operation closure
+ * The id of the slave controller
*/
- void *op_cls;
+ uint32_t slave_id;
+
+};
+
+/**
+ * Context data for controller link operations
+ */
+struct ControllerLinkData
+{
/**
- * The id of the slave controller
+ * The controller link message
*/
- uint32_t slave_id;
+ struct GNUNET_TESTBED_ControllerLinkMessage *msg;
};
}
+/**
+ * Handler for forwarded operations
+ *
+ * @param c the controller handle
+ * @param opc the opearation context
+ * @param msg the message
+ */
+static void
+handle_forwarded_operation_msg (struct GNUNET_TESTBED_Controller *c,
+ struct OperationContext *opc,
+ const struct GNUNET_MessageHeader *msg)
+{
+ struct ForwardedOperationData *fo_data;
+
+ fo_data = opc->data;
+ if (NULL != fo_data->cc)
+ fo_data->cc (fo_data->cc_cls, msg);
+ GNUNET_CONTAINER_DLL_remove (c->ocq_head, c->ocq_tail, opc);
+ GNUNET_free (fo_data);
+ GNUNET_free (opc);
+}
+
+
/**
* Handler for GNUNET_MESSAGE_TYPE_TESTBED_ADDHOSTCONFIRM message from
* controller (testbed service)
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");
return GNUNET_YES;
}
+ event.type = GNUNET_TESTBED_ET_OPERATION_FINISHED;
+ event.details.operation_finished.operation = opc->op;
+ event.details.operation_finished.op_cls = opc->op_cls;
+ event.details.operation_finished.emsg = NULL;
+ event.details.operation_finished.generic = NULL;
switch (opc->type)
{
case OP_FORWARDED:
{
- struct ForwardedOperationData *fo_data;
-
- fo_data = opc->data;
- if (NULL != fo_data->cc)
- fo_data->cc (fo_data->cc_cls, (const struct GNUNET_MessageHeader *) msg);
- GNUNET_CONTAINER_DLL_remove (c->ocq_head, c->ocq_tail, opc);
- GNUNET_free (fo_data);
- GNUNET_free (opc);
+ handle_forwarded_operation_msg
+ (c, opc, (const struct GNUNET_MessageHeader *) msg);
return GNUNET_YES;
}
break;
}
break;
case OP_LINK_CONTROLLERS:
+ {
+ struct ControllerLinkData *data;
+
+ data = opc->data;
+ GNUNET_assert (NULL != data);
+ GNUNET_free (data);
+ opc->data = NULL;
+ }
break;
default:
GNUNET_assert (0);
- }
- 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.emsg = NULL;
- event.details.operation_finished.generic = NULL;
+ }
GNUNET_CONTAINER_DLL_remove (opc->c->ocq_head, opc->c->ocq_tail, opc);
opc->state = OPC_STATE_FINISHED;
if (0 != (c->event_mask & (1L << GNUNET_TESTBED_ET_OPERATION_FINISHED)))
if (NULL != c->cc)
c->cc (c->cc_cls, &event);
}
+ else
+ LOG_DEBUG ("Not calling callback\n");
return GNUNET_YES;
}
* Handler for GNUNET_MESSAGE_TYPE_TESTBED_PEERCREATESUCCESS message from
* controller (testbed service)
*
- * @param c the controller handler
+ * @param c the controller handle
* @param msg message received
* @return GNUNET_YES if we can continue receiving from service; GNUNET_NO if
* not
}
if (OP_FORWARDED == opc->type)
{
- struct ForwardedOperationData *fo_data;
-
- fo_data = opc->data;
- if (NULL != fo_data->cc)
- fo_data->cc (fo_data->cc_cls, (const struct GNUNET_MessageHeader *) msg);
- GNUNET_CONTAINER_DLL_remove (c->ocq_head, c->ocq_tail, opc);
- GNUNET_free (fo_data);
- GNUNET_free (opc);
+ handle_forwarded_operation_msg (c, opc,
+ (const struct GNUNET_MessageHeader *) msg);
return GNUNET_YES;
}
GNUNET_assert (OP_PEER_CREATE == opc->type);
}
if (OP_FORWARDED == opc->type)
{
- struct ForwardedOperationData *fo_data;
-
- fo_data = opc->data;
- if (NULL != fo_data->cc)
- fo_data->cc (fo_data->cc_cls, (const struct GNUNET_MessageHeader *) msg);
- GNUNET_CONTAINER_DLL_remove (c->ocq_head, c->ocq_tail, opc);
- GNUNET_free (fo_data);
- GNUNET_free (opc);
+ handle_forwarded_operation_msg (c, opc,
+ (const struct GNUNET_MessageHeader *) msg);
return GNUNET_YES;
}
GNUNET_assert ((OP_PEER_START == opc->type) || (OP_PEER_STOP == opc->type));
LOG_DEBUG ("Operation not found\n");
return GNUNET_YES;
}
+ if (OP_FORWARDED == opc->type)
+ {
+ handle_forwarded_operation_msg (c, opc,
+ (const struct GNUNET_MessageHeader *) msg);
+ return GNUNET_YES;
+ }
+ GNUNET_assert (OP_OVERLAY_CONNECT == opc->type);
data = opc->data;
GNUNET_assert (NULL != data);
GNUNET_assert ((ntohl (msg->peer1) == data->p1->unique_id) &&
}
if (OP_FORWARDED == opc->type)
{
- struct ForwardedOperationData *fo_data;
-
- fo_data = opc->data;
- if (NULL != fo_data->cc)
- fo_data->cc (fo_data->cc_cls, (const struct GNUNET_MessageHeader *) msg);
- GNUNET_CONTAINER_DLL_remove (c->ocq_head, c->ocq_tail, opc);
- GNUNET_free (fo_data);
- GNUNET_free (opc);
+ handle_forwarded_operation_msg (c, opc,
+ (const struct GNUNET_MessageHeader *) msg);
return GNUNET_YES;
}
data = opc->data;
GNUNET_CONTAINER_DLL_remove (opc->c->ocq_head, opc->c->ocq_tail, opc);
if (OP_FORWARDED == opc->type)
{
- struct ForwardedOperationData *fo_data;
-
- fo_data = opc->data;
- if (NULL != fo_data->cc)
- fo_data->cc (fo_data->cc_cls, (const struct GNUNET_MessageHeader *) msg);
- GNUNET_free (fo_data);
- GNUNET_free (opc);
+ handle_forwarded_operation_msg (c, opc,
+ (const struct GNUNET_MessageHeader *) msg);
return GNUNET_YES;
}
opc->state = OPC_STATE_FINISHED;
{
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);
}
+/**
+ * Function to build GET_SLAVE_CONFIG message
+ *
+ * @param op_id the id this message should contain in its operation id field
+ * @param slave_id the id this message should contain in its slave id field
+ * @return newly allocated SlaveGetConfigurationMessage
+ */
+static struct GNUNET_TESTBED_SlaveGetConfigurationMessage *
+GNUNET_TESTBED_generate_slavegetconfig_msg_ (uint64_t op_id, uint32_t slave_id)
+{
+ struct GNUNET_TESTBED_SlaveGetConfigurationMessage *msg;
+ uint16_t msize;
+
+ msize = sizeof (struct GNUNET_TESTBED_SlaveGetConfigurationMessage);
+ msg = GNUNET_malloc (msize);
+ msg->header.size = htons (msize);
+ msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_GETSLAVECONFIG);
+ msg->operation_id = GNUNET_htonll (op_id);
+ msg->slave_id = htonl (slave_id);
+ return msg;
+}
+
+
/**
* Handler for GNUNET_MESSAGE_TYPE_TESTBED_SLAVECONFIG message from controller
* (testbed service)
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);
}
}
+/**
+ * Callback to check status for suboperations generated during overlay connect.
+ *
+ * @param cls the OverlayConnectData
+ * @param message the reply message to the suboperation
+ */
+static void
+overlay_connect_ondemand_handler (void *cls,
+ const struct GNUNET_MessageHeader *message)
+{
+ struct OverlayConnectData *oc_data = cls;
+
+ switch (oc_data->state)
+ {
+ case OCD_CFG_ACQUIRE:
+ {
+ struct GNUNET_CONFIGURATION_Handle *cfg;
+
+ if (GNUNET_MESSAGE_TYPE_TESTBED_SLAVECONFIG != ntohs (message->type))
+ {
+ GNUNET_break (0); /* treat operation as failed */
+ }
+ cfg = GNUNET_TESTBED_extract_config_ (message);
+ if (NULL == cfg)
+ {
+ GNUNET_break (0); /* failed operation */
+ }
+ oc_data->state = OCD_LINK_CONTROLLERS;
+ }
+ default:
+ GNUNET_assert (0);
+ }
+}
+
+
+/**
+ * Handler for GNUNET_MESSAGE_TYPE_TESTBED_NEEDCONTROLLERCONFIG message from
+ * controller (testbed service)
+ *
+ * @param c the controller handler
+ * @param msg message received
+ * @return GNUNET_YES if we can continue receiving from service; GNUNET_NO if
+ * not
+ */
+static int
+handle_need_controller_config (struct GNUNET_TESTBED_Controller *c,
+ const struct GNUNET_TESTBED_NeedControllerConfig * msg)
+{
+ struct OperationContext *opc;
+ struct OverlayConnectData *oc_data;
+ uint64_t op_id;
+
+ op_id = GNUNET_ntohll (msg->operation_id);
+ if (NULL == (opc = find_opc (c, op_id)))
+ {
+ LOG_DEBUG ("Operation not found\n");
+ return GNUNET_YES;
+ }
+ if (OP_FORWARDED == opc->type)
+ {
+ handle_forwarded_operation_msg (c, opc,
+ (const struct GNUNET_MessageHeader *) msg);
+ return GNUNET_YES;
+ }
+ GNUNET_assert (OP_OVERLAY_CONNECT == opc->type);
+ oc_data = opc->data;
+ /* FIXME: Should spawn operations to:
+ 1. Acquire configuration of peer2's controller,
+ 2. link peer1's controller to peer2's controller
+ 3. ask them to attempt overlay connect on peer1 and peer2 again */
+ switch (oc_data->state)
+ {
+ case OCD_INIT:
+ {
+ struct GNUNET_TESTBED_SlaveGetConfigurationMessage *get_cfg_msg;
+ uint64_t sub_op_id;
+
+ GNUNET_assert (NULL == oc_data->sub_opc);
+ 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));
+ oc_data->state = OCD_CFG_ACQUIRE;
+ oc_data->sub_opc =
+ GNUNET_TESTBED_forward_operation_msg_ (oc_data->p1->controller,
+ sub_op_id, &get_cfg_msg->header,
+ overlay_connect_ondemand_handler,
+ oc_data);
+ }
+ break;
+ default:
+ GNUNET_assert (0);
+ }
+ return GNUNET_YES;
+}
+
+
/**
* Handler for messages from controller (testbed service)
*
handle_slave_config (c, (const struct
GNUNET_TESTBED_SlaveConfiguration *) msg);
break;
+ case GNUNET_MESSAGE_TYPE_TESTBED_NEEDCONTROLLERCONFIG:
+ GNUNET_assert (msize == sizeof (struct
+ GNUNET_TESTBED_NeedControllerConfig));
+ status =
+ handle_need_controller_config (c, (const struct
+ GNUNET_TESTBED_NeedControllerConfig
+ *) msg);
+ break;
default:
GNUNET_assert (0);
}
}
-/**
- * Handle for controller process
- */
-struct GNUNET_TESTBED_ControllerProc
-{
- /**
- * The process handle
- */
- struct GNUNET_HELPER_Handle *helper;
-
- /**
- * The host where the helper is run
- */
- struct GNUNET_TESTBED_Host *host;
-
- /**
- * The controller error callback
- */
- GNUNET_TESTBED_ControllerStatusCallback cb;
-
- /**
- * The closure for the above callback
- */
- void *cls;
-
- /**
- * The send handle for the helper
- */
- struct GNUNET_HELPER_SendHandle *shandle;
-
- /**
- * The message corresponding to send handle
- */
- struct GNUNET_MessageHeader *msg;
-
- /**
- * The port number for ssh; used for helpers starting ssh
- */
- char *port;
-
- /**
- * The ssh destination string; used for helpers starting ssh
- */
- char *dst;
-
- /**
- * The configuration of the running testbed service
- */
- struct GNUNET_CONFIGURATION_Handle *cfg;
-
-};
-
-
/**
* Functions with this signature are called whenever a
* complete message is received by the tokenizer.
opstart_link_controllers (void *cls)
{
struct OperationContext *opc = cls;
+ struct ControllerLinkData *data;
struct GNUNET_TESTBED_ControllerLinkMessage *msg;
GNUNET_assert (NULL != opc->data);
- msg = opc->data;
- opc->data = NULL;
+ data = opc->data;
+ msg = data->msg;
+ data->msg = NULL;
opc->state = OPC_STATE_STARTED;
GNUNET_CONTAINER_DLL_insert_tail (opc->c->ocq_head, opc->c->ocq_tail, opc);
GNUNET_TESTBED_queue_message_ (opc->c, &msg->header);
oprelease_link_controllers (void *cls)
{
struct OperationContext *opc = cls;
+ struct ControllerLinkData *data;
- if (OPC_STATE_INIT == opc->state)
- GNUNET_free (opc->data);
- if (OPC_STATE_STARTED == opc->state)
+ data = opc->data;
+ switch (opc->state)
+ {
+ case OPC_STATE_INIT:
+ GNUNET_free (data->msg);
+ break;
+ case OPC_STATE_STARTED:
GNUNET_CONTAINER_DLL_remove (opc->c->ocq_head, opc->c->ocq_tail, opc);
+ break;
+ case OPC_STATE_FINISHED:
+ break;
+ }
+ GNUNET_free_non_null (data);
GNUNET_free (opc);
}
struct OperationContext *opc = cls;
struct GetSlaveConfigData *data;
struct GNUNET_TESTBED_SlaveGetConfigurationMessage *msg;
- uint16_t msize;
-
+
data = opc->data;
- msize = sizeof (struct GNUNET_TESTBED_SlaveGetConfigurationMessage);
- msg = GNUNET_malloc (msize);
- msg->header.size = htons (msize);
- msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_GETSLAVECONFIG);
- msg->operation_id = GNUNET_htonll (opc->id);
- msg->slave_id = htonl (data->slave_id);
+ msg = GNUNET_TESTBED_generate_slavegetconfig_msg_ (opc->id, data->slave_id);
GNUNET_CONTAINER_DLL_insert_tail (opc->c->ocq_head, opc->c->ocq_tail, opc);
GNUNET_TESTBED_queue_message_ (opc->c, &msg->header);
opc->state = OPC_STATE_STARTED;
{
struct GNUNET_TESTBED_ControllerProc *cp;
struct GNUNET_TESTBED_HelperInit *msg;
+ const char *hostname;
static char *const binary_argv[] = {
HELPER_TESTBED_BINARY, NULL
};
+ hostname = NULL;
cp = GNUNET_malloc (sizeof (struct GNUNET_TESTBED_ControllerProc));
if ((NULL == host) || (0 == GNUNET_TESTBED_host_get_id_ (host)))
cp->helper =
&helper_mst, &helper_exp_cb, cp);
else
{
- char *remote_args[8];
+ char *remote_args[10];
unsigned int argp;
const char *username;
- const char *hostname;
username = GNUNET_TESTBED_host_get_username_ (host);
hostname = GNUNET_TESTBED_host_get_hostname_ (host);
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);
cp->host = host;
cp->cb = cb;
cp->cls = cls;
- msg = GNUNET_TESTBED_create_helper_init_msg_ (controller_ip, cfg);
+ msg = GNUNET_TESTBED_create_helper_init_msg_ (controller_ip, hostname, cfg);
cp->msg = &msg->header;
cp->shandle =
GNUNET_HELPER_send (cp->helper, &msg->header, GNUNET_NO, &clear_msg, 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 scfg
+ * @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 master controller; GNUNET_NO if we are just
- * allowed to use the slave via TCP/IP
+ * 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 (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;
opc = GNUNET_malloc (sizeof (struct OperationContext));
opc->c = master;
- opc->data = msg;
+ 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,
}
+/**
+ * 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
*
/**
- * Create a link from slave controller to delegated controller. Whenever the
- * master controller is asked to start a peer at the delegated controller the
- * request will be routed towards slave controller (if a route exists). The
- * slave controller will then route it to the delegated controller. The
- * configuration of the slave controller is given and to be used to either
- * create the slave controller or to connect to an existing slave controller
- * process. 'is_subordinate' specifies if the given slave controller should be
- * started and managed by the master controller, or if the slave already has a
- * master and this is just a secondary master that is also allowed to use the
- * existing slave.
+ * 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 requests to which host should be delegated
- * @param slave_host which host is used to run the slave controller
+ * @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 slave should be started (and stopped)
- * by the master controller; GNUNET_NO if we are just
- * allowed to use the slave via TCP/IP
+ * @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 (struct GNUNET_TESTBED_Controller *master,
- struct GNUNET_TESTBED_Host *delegated_host,
- struct GNUNET_TESTBED_Host *slave_host,
+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)
+ *slave_cfg,
+ int is_subordinate)
{
struct GNUNET_TESTBED_Operation *op;
char *config;
size_t cc_size;
size_t config_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));
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 (master, delegated_host, slave_host,
- (const char *) cconfig, cc_size,
- config_size, is_subordinate);
+ 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
+ * request will be routed towards slave controller (if a route exists). The
+ * slave controller will then route it to the delegated controller. The
+ * configuration of the delegated controller is given and is used to either
+ * create the delegated controller or to connect to an existing controller. Note
+ * that while starting the delegated controller the configuration will be
+ * modified to accommodate available free ports. the 'is_subordinate' specifies
+ * if the given delegated controller should be started and managed by the slave
+ * controller, or if the delegated controller already has a master and the slave
+ * controller connects to it as a non master controller. The success or failure
+ * of this operation will be signalled through the
+ * GNUNET_TESTBED_ControllerCallback() with an event of type
+ * GNUNET_TESTBED_ET_OPERATION_FINISHED
+ *
+ * @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 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,
+ struct GNUNET_TESTBED_Host *delegated_host,
+ struct GNUNET_TESTBED_Host *slave_host,
+ const struct GNUNET_CONFIGURATION_Handle
+ *slave_cfg, int is_subordinate)
+{
+ uint32_t slave_host_id;
+ uint32_t delegated_host_id;
+
+ GNUNET_assert (GNUNET_YES ==
+ GNUNET_TESTBED_is_host_registered_ (delegated_host, master));
+ 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));
+ 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);
+ return opc->op;
+}
+
+
/**
* Function to acquire the configuration of a running slave controller. The
* completion of the operation is signalled through the controller_cb from
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));
}
* want to use this in testing
*
* @param cname the ip address of the controlling host
+ * @param hostname the hostname of the destination this message is intended for
* @param cfg the configuration that has to used to start the testbed service
* thru helper
* @return the initialization message
*/
struct GNUNET_TESTBED_HelperInit *
GNUNET_TESTBED_create_helper_init_msg_ (const char *cname,
+ const char *hostname,
const struct GNUNET_CONFIGURATION_Handle
*cfg)
{
size_t config_size;
size_t xconfig_size;
uint16_t cname_len;
+ uint16_t hostname_len;
uint16_t msg_size;
config = GNUNET_CONFIGURATION_serialize (cfg, &config_size);
GNUNET_TESTBED_compress_config_ (config, config_size, &xconfig);
GNUNET_free (config);
cname_len = strlen (cname);
+ hostname_len = (NULL == hostname) ? 0 : strlen (hostname);
msg_size =
xconfig_size + cname_len + 1 + sizeof (struct GNUNET_TESTBED_HelperInit);
+ msg_size += hostname_len;
msg = GNUNET_realloc (xconfig, msg_size);
- (void) memmove (((void *) &msg[1]) + cname_len + 1, msg, xconfig_size);
+ (void) memmove (((void *) &msg[1]) + cname_len + 1 + hostname_len,
+ msg,
+ xconfig_size);
msg->header.size = htons (msg_size);
msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_HELPER_INIT);
msg->cname_size = htons (cname_len);
+ msg->hostname_size = htons (hostname_len);
msg->config_size = htons (config_size);
(void) strcpy ((char *) &msg[1], cname);
+ if (0 != hostname_len)
+ (void) strncpy (((char *) &msg[1]) + cname_len + 1, hostname, hostname_len);
return msg;
}
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 NULL;
msize -= sizeof (struct GNUNET_TESTBED_OperationFailureEventMessage);
emsg = (const char *) &msg[1];
- if ('\0' != emsg[msize])
+ if ('\0' != emsg[msize - 1])
{
GNUNET_break (0);
return NULL;
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 */