static void set_random_seed(struct mtwist_state **mt)
{
struct timeval tv;
gettimeofday(&tv, NULL);
*mt = mtwist_init(tv.tv_usec);
}
void initialize_random_orientations_and_spins(int mtwist_seed)
{
int i;
struct mtwist_state *mt;
mt = mtwist_init(mtwist_seed);
for (i = 0; i < NRANDOM_ORIENTATIONS; i++) {
float angle = mtwist_float(mt) * 2.0 * M_PI;
consistent_random_axis_quat(mt, &random_orientation[i], angle);
}
for (i = 0; i < NRANDOM_SPINS; i++) {
float angular_speed = ((float) mtwist_int(mt, 100) / 10.0 - 5.0) * M_PI / 180.0;
consistent_random_axis_quat(mt, &random_spin[i], angular_speed);
}
mtwist_free(mt);
}
int
main(int argc, char **argv)
{
char * region = (char *) getenv("region" );
char * client_user = (char *) getenv("client_user" );
char * client_device = (char *) getenv("client_device" );
char * server_user = (char *) getenv("server_user" );
char * server_device = (char *) getenv("server_device" );
char * server_instance = (char *) getenv("server_instance");
char * server_ans_blob = (char *) getenv("ans_blob" );
char * server_ans_key = (char *) getenv("ans_key" );
//pxd_declare_t declare; // TODO: remove
pxd_open_t open_client;
pxd_id_t client_id;
pxd_cred_t client_creds;
pxd_client_t * client;
pxd_open_t open_server;
pxd_id_t server_id;
pxd_cred_t server_creds;
ans_client_t * ans_client;
pxd_cred_t connect_creds;
pxd_connect_t connect;
pxd_error_t error;
mtwist_t mt;
//int lookup_result;
int tries;
//int lookup_tries;
int connect_tries;
uint32_t seed;
LOGInit("pxd_triangle", null);
pxd_host = (char *) getenv("pxd_host");
ans_host = (char *) getenv("ans_host");
if (pxd_host == null || ans_host == null || region == null) {
printf("pxd_host, ans_host, and region must be set.\n");
exit(1);
}
if (client_user == null || client_device == null) {
printf("client_user and client_device must be set.\n");
exit(1);
}
if (server_user == null || server_device == null || server_instance == null) {
printf("server_user, server_device, and server_instance must be set.\n");
exit(1);
}
if (server_ans_blob == null || server_ans_key == null) {
printf("ans_blob and ans_key must be set.\n");
exit(1);
}
seed = VPLTime_GetTime() ^ getpid();
mtwist_init(&mt, seed);
/*
* Set up the structures for opening a client connection.
*/
memset(&open_client, 0, sizeof(open_client ));
memset(&client_creds, 0, sizeof(client_creds));
memset(&client_id, 0, sizeof(client_id ));
open_client.cluster_name = pxd_host;
open_client.credentials = &client_creds;
open_client.credentials->id = &client_id;
open_client.credentials->key = client_key;
open_client.credentials->key_length = sizeof(client_key);
open_client.credentials->id->region = region;
open_client.credentials->id->instance_id = (char *) "CCD-client";
open_client.credentials->key = client_key;
open_client.credentials->key_length = sizeof(client_key);
/*
* Now open the client CCD connection.
*/
client = do_open(&open_client, client_user, client_device, false);
free(open_client.credentials->opaque);
open_client.credentials->opaque = null;
/*
* Okay, open the server CCD connection.
*/
server_info = &open_server;
memset(&open_server, 0, sizeof(open_server ));
memset(&server_creds, 0, sizeof(server_creds));
memset(&server_id, 0, sizeof(server_id ));
open_server.cluster_name = pxd_host;
open_server.credentials = &server_creds;
open_server.credentials->id = &server_id;
open_server.credentials->key = server_key;
open_server.credentials->key_length = sizeof(server_key);
open_server.credentials->id->region = region;
open_server.credentials->id->instance_id = server_instance;
open_server.credentials->key = server_key;
open_server.credentials->key_length = sizeof(server_key);
server = do_open(&open_server, server_user, server_device, true );
free(open_server.credentials->opaque);
open_server.credentials->opaque = null;
if (client == null || server == null) {
error("A pxd_open operation failed.\n");
exit(1);
}
ans_client = open_ans(open_server.credentials, ans_host, server_ans_blob, server_ans_key);
VPLThread_Sleep(VPLTime_FromMillisec(1000));
/*
* Declare the server CCD to the PXD demon.
*/
/*memset(&declare, 0, sizeof(declare ));
memset(&ip_address, 0, sizeof(ip_address));
declare.ans_dns = ans_host;
declare.pxd_dns = pxd_host;
declare.address_count = 1;
declare.addresses[0].ip_address = ip_address; // not used
declare.addresses[0].ip_length = sizeof(ip_address);
declare.addresses[0].port = 8;
pxd_declare(server, &declare, &error);
if (error.error != 0) {
error("pxd_declare failed: %s.\n", error.message);
exit(1);
}*/
/*
* Now try a lookup of the server CCD on the CCD client side.
* The lookup should cause PXD to send a server wakeup message
* to the server side.
*/
/*lookup_tries = 4;
log("Starting the pxd_lookup attempts.\n");
do {
lookup_result = -1;
pxd_lookup(client, &server_id, &lookup_result, &error);
if (error.error != 0) {
error("pxd_lookup failed: %s.\n", error.message);
exit(1);
}
tries = 40;
while (lookup_result < 0 && tries-- > 0) {
VPLThread_Sleep(VPLTime_FromMillisec(100));
}
if (lookup_result != pxd_op_successful) {
sleep(1);
}
} while (lookup_tries-- > 0 && lookup_result != pxd_op_successful);
if (lookup_result != pxd_op_successful) {
error("pxd_lookup failed: %s (%d).\n",
pxd_string(lookup_result), (int) lookup_result);
exit(1);
}*/
/*
* Start the connection attempt.
*/
memset(&connect, 0, sizeof(connect ));
memset(&connect_creds, 0, sizeof(connect_creds));
connect.target = server_info->credentials->id;
connect.creds = &connect_creds;
connect.pxd_dns = lookup_host;
connect.creds->id = &client_id;
connect.creds->key = session_key;
connect.creds->key_length = sizeof(session_key);
make_ccd_creds(connect.target, connect.creds);
/*
* Now add the address. It's not used yet, so its content is irrelevant,
* and I might not even need to set it.
*/
connect.address_count = 1;
connect.addresses[0].ip_address = saved_address;
connect.addresses[0].ip_length = saved_length;
connect.addresses[0].port = 7000;
connect_tries = 3;
do {
connect_finished = false;
log("calling pxd_connect\n");
pxd_connect(client, &connect, &error);
if (error.error != 0) {
error("pxd_connect failed: %s.\n", error.message);
exit(1);
}
/*
* The connection setup might be done on the server, with
* some look. So start trying receive operations. We don't
* have ANS providing synchronization, so we need to give
* it a few shots.
*/
tries = 10;
while ((!connect_finished || incoming_logins == 0) && tries-- > 0) {
sleep(1);
}
if (!connect_finished) {
error("The proxy connection operation didn't complete.\n");
exit(1);
}
log(" === A connect operation completed.\n");
} while (!connect_passed && connect_tries-- > 0);
tries = 5;
free(connect.creds->opaque);
connect.creds->opaque = null;
while (incoming_logins == 0 && tries-- > 0) {
sleep(1);
}
/*
* At this point, we should have received the callback for the
* connection attempt and an incoming login.
*/
if (!connect_passed || incoming_logins == 0) {
error("The proxy connection operation didn't complete or didn't pass.\n");
error("connect_finished: %d, connect_passed %d, incoming_logins %d\n",
(int) connect_finished, (int) connect_passed, (int) incoming_logins);
exit(1);
}
log(" === The connect operation succeeded.\n");
pxd_close(&client, true, &error);
if (error.error != 0) {
error("The client close failed: %s.\n", error.message);
exit(1);
}
pxd_close(&server, true, &error);
if (error.error != 0) {
error("The server close failed: %s.\n", error.message);
exit(1);
}
ans_close(ans_client, true);
free(lookup_host);
pxd_free_address(&server_address);
sleep(1); // Wait for the threads to exit (we hope)
printf("The pxd triangle test passed.\n");
return 0;
}
