* Testbed Helper binary name
*/
#define HELPER_TESTBED_BINARY "gnunet-helper-testbed"
+#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;
+
+};
/**
};
+/**
+ * Context data for get slave config operations
+ */
+struct GetSlaveConfigData
+{
+ /**
+ * The id of the slave controller
+ */
+ uint32_t slave_id;
+
+};
+
+
+/**
+ * Context data for controller link operations
+ */
+struct ControllerLinkData
+{
+ /**
+ * The controller link message
+ */
+ struct GNUNET_TESTBED_ControllerLinkMessage *msg;
+
+};
+
+
/**
* Returns the operation context with the given id if found in the Operation
* context queues of the controller
}
+/**
+ * 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;
break;
case GNUNET_TESTBED_PIT_CONFIGURATION:
pinfo->result.cfg = /* Freed in oprelease_peer_getinfo */
- GNUNET_TESTBED_get_config_from_peerinfo_msg_ (msg);
+ GNUNET_TESTBED_extract_config_ (&msg->header);
break;
case GNUNET_TESTBED_PIT_GENERIC:
GNUNET_assert (0); /* never reach here */
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)
+ *
+ * @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_slave_config (struct GNUNET_TESTBED_Controller *c,
+ const struct GNUNET_TESTBED_SlaveConfiguration * msg)
+{
+ struct OperationContext *opc;
+ uint64_t op_id;
+ struct GNUNET_TESTBED_EventInformation event;
+
+ 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_GET_SLAVE_CONFIG != opc->type)
+ {
+ GNUNET_break (0);
+ return GNUNET_YES;
+ }
+ GNUNET_free (opc->data);
+ opc->data = NULL;
+ opc->state = OPC_STATE_FINISHED;
+ GNUNET_CONTAINER_DLL_remove (opc->c->ocq_head, opc->c->ocq_tail, opc);
+ if ((0 != (GNUNET_TESTBED_ET_OPERATION_FINISHED & c->event_mask)) &&
+ (NULL != c->cc))
+ {
+ opc->data = GNUNET_TESTBED_extract_config_ (&msg->header);
+ 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 = opc->op_cls;
+ event.details.operation_finished.emsg = NULL;
+ c->cc (c->cc_cls, &event);
+ }
+ return GNUNET_YES;
+}
+
+
+/**
+ * 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)
*
GNUNET_TESTBED_OperationFailureEventMessage *)
msg);
break;
+ case GNUNET_MESSAGE_TYPE_TESTBED_SLAVECONFIG:
+ GNUNET_assert (msize >
+ sizeof (struct GNUNET_TESTBED_SlaveConfiguration));
+ status =
+ 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);
*/
static void
oprelease_link_controllers (void *cls)
+{
+ struct OperationContext *opc = cls;
+ struct ControllerLinkData *data;
+
+ 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);
+}
+
+
+/**
+ * Function to be called when get slave config operation is ready
+ *
+ * @param cls the OperationContext of type OP_GET_SLAVE_CONFIG
+ */
+static void
+opstart_get_slave_config (void *cls)
+{
+ struct OperationContext *opc = cls;
+ struct GetSlaveConfigData *data;
+ struct GNUNET_TESTBED_SlaveGetConfigurationMessage *msg;
+
+ data = opc->data;
+ 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;
+}
+
+
+/**
+ * Function to be called when get slave config operation is cancelled or finished
+ *
+ * @param cls the OperationContext of type OP_GET_SLAVE_CONFIG
+ */
+static void
+oprelease_get_slave_config (void *cls)
{
struct OperationContext *opc = cls;
- if (OPC_STATE_INIT == opc->state)
+ switch (opc->state)
+ {
+ case OPC_STATE_INIT:
+ GNUNET_free (opc->data);
+ break;
+ case OPC_STATE_STARTED:
GNUNET_free (opc->data);
- if (OPC_STATE_STARTED == opc->state)
GNUNET_CONTAINER_DLL_remove (opc->c->ocq_head, opc->c->ocq_tail, opc);
+ break;
+ case OPC_STATE_FINISHED:
+ if (NULL != opc->data)
+ GNUNET_CONFIGURATION_destroy (opc->data);
+ break;
+ }
GNUNET_free (opc);
}
{
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;
+ 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);
/**
* Stop the controller process (also will terminate all peers and controllers
* dependent on this controller). This function blocks until the testbed has
- * been fully terminated (!).
+ * been fully terminated (!). The controller status cb from
+ * GNUNET_TESTBED_controller_start() will not be called.
*
* @param cproc the controller process 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",
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 */
}
GNUNET_TESTBED_operation_queue_destroy_ (controller->opq_parallel_operations);
GNUNET_TESTBED_operation_queue_destroy_
(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
*
}
+/**
+ * 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
* 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.
+ * 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
- * @param slave_host which host is used to run the slave controller
+ * @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 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,
+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)
{
- 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);
- GNUNET_assert ((UINT16_MAX - sizeof (struct GNUNET_TESTBED_ControllerLinkMessage)) >= cc_size); /* Configuration doesn't fit in 1 message */
- op = GNUNET_TESTBED_controller_link_2 (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);
+ 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
+ * 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));
}
* 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;
}
/**
- * Generates configuration by parsing Peer configuration information reply message
+ * Generates configuration by uncompressing configuration in given message. The
+ * given message should be of the following types:
+ * GNUNET_MESSAGE_TYPE_TESTBED_PEERCONFIG,
+ * GNUNET_MESSAGE_TYPE_TESTBED_SLAVECONFIG
*
- * @param msg the peer configuration information message
+ * @param msg the message containing compressed configuration
* @return handle to the parsed configuration
*/
struct GNUNET_CONFIGURATION_Handle *
-GNUNET_TESTBED_get_config_from_peerinfo_msg_ (const struct
- GNUNET_TESTBED_PeerConfigurationInformationMessage
- *msg)
-{
+GNUNET_TESTBED_extract_config_ (const struct GNUNET_MessageHeader *msg)
+{
struct GNUNET_CONFIGURATION_Handle *cfg;
- char *config;
- uLong config_size;
+ Bytef *data;
+ const Bytef *xdata;
+ uLong data_len;
+ uLong xdata_len;
int ret;
- uint16_t msize;
- config_size = (uLong) ntohs (msg->config_size);
- config = GNUNET_malloc (config_size);
- msize = ntohs (msg->header.size);
- msize -= sizeof (struct GNUNET_TESTBED_PeerConfigurationInformationMessage);
+ switch (ntohs (msg->type))
+ {
+ case GNUNET_MESSAGE_TYPE_TESTBED_PEERCONFIG:
+ {
+ const struct GNUNET_TESTBED_PeerConfigurationInformationMessage *imsg;
+
+ imsg = (const struct GNUNET_TESTBED_PeerConfigurationInformationMessage *)
+ msg;
+ data_len = (uLong) ntohs (imsg->config_size);
+ xdata_len = ntohs (imsg->header.size)
+ - sizeof (struct GNUNET_TESTBED_PeerConfigurationInformationMessage);
+ xdata = (const Bytef *) &imsg[1];
+ }
+ break;
+ case GNUNET_MESSAGE_TYPE_TESTBED_SLAVECONFIG:
+ {
+ const struct GNUNET_TESTBED_SlaveConfiguration *imsg;
+
+ imsg = (const struct GNUNET_TESTBED_SlaveConfiguration *) msg;
+ data_len = (uLong) ntohs (imsg->config_size);
+ xdata_len = ntohs (imsg->header.size)
+ - sizeof (struct GNUNET_TESTBED_SlaveConfiguration);
+ xdata = (const Bytef *) &imsg[1];
+ }
+ break;
+ default:
+ GNUNET_assert (0);
+ }
+ data = GNUNET_malloc (data_len);
if (Z_OK !=
(ret =
- uncompress ((Bytef *) config, &config_size, (const Bytef *) &msg[1],
- (uLong) msize)))
+ uncompress (data, &data_len, xdata, xdata_len)))
GNUNET_assert (0);
cfg = GNUNET_CONFIGURATION_create ();
GNUNET_assert (GNUNET_OK ==
- GNUNET_CONFIGURATION_deserialize (cfg, config,
- (size_t) config_size,
+ GNUNET_CONFIGURATION_deserialize (cfg, (const char *) data,
+ (size_t) data_len,
GNUNET_NO));
- GNUNET_free (config);
+ GNUNET_free (data);
return cfg;
}
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 */
projects / oweals / gnunet.git / blobdiff