int VSTest::init() {
char msg[256];
port_num = var_server_get_port();
hostest = var_server_get_hostname();
memset(&bob, '\0', sizeof(TCDevice));
bob.hostname = const_cast<char*>(hostest);
bob.port = port_num;
//std::cout << bob.hostname << bob.port << std::endl;
bob.disable_handshaking = TC_COMM_TRUE;
bob.disabled = TC_COMM_FALSE;
tc_connect(&bob);
if ( tc_isValid (&bob) ) {
printf ("connection is valid\n");
} else {
printf ("connection is NOT valid\n");
}
// default cycle rate
cycle_rate = 0.01;
sprintf(msg,"trick.var_cycle(%.2f)\n", cycle_rate);
vs_write(msg);
return (0);
}
/** @par Detailed Design: */
int Trick::MonteCarlo::shutdown() {
/** <ul><li> If this is a slave, run the shutdown jobs. */
if (enabled && is_slave()) {
connection_device.port = master_port;
if (tc_connect(&connection_device) == TC_SUCCESS) {
int exit_status = MonteRun::COMPLETE;
if (verbosity >= ALL) {
message_publish(MSG_INFO, "Monte [%s:%d] Sending run exit status to master: %d\n",
machine_name.c_str(), slave_id, exit_status) ;
}
int id = htonl(slave_id);
tc_write(&connection_device, (char*)&id, (int)sizeof(id));
exit_status = htonl(exit_status);
tc_write(&connection_device, (char*)&exit_status, (int)sizeof(exit_status));
run_queue(&slave_post_queue, "in slave_post queue");
tc_disconnect(&connection_device);
} else {
if (verbosity >= ERROR)
message_publish(
MSG_ERROR,
"Monte [%s:%d] Failed to connect to master.\n",
machine_name.c_str(), slave_id);
}
}
return 0;
}
int SatGraphicsComm::connect() {
int ret, num_attempts;
system(syscmd);
std::cout << "SatGraphicsComm: Starting graphics server using: \"" << syscmd << "\"" << std::endl;
tc_error( &connection, 0);
num_attempts = 0;
while(1) {
ret = tc_connect( &connection);
if (ret == TC_SUCCESS) {
std::cerr << "SatGraphicsComm: CONNECT." << std::endl;
break;
} else {
num_attempts ++;
if ( num_attempts == 30 ) {
std::cerr << "SatGraphicsComm: Couldn't connect to graphics server." << std::endl;
return 1;
}
}
sleep(1);
}
return 0;
}
TEST_F( TCConnectTest, testNullHostname ) {
device->hostname = NULL;
int connect_status = tc_connect( device );
EXPECT_EQ( connect_status, TC_CONN_DISABLED );
}
TEST_F( TCConnectTest, testDisabledDevice ) {
device->disabled = TC_COMM_TRUE;
int connect_status = tc_connect( device );
EXPECT_EQ( connect_status, TC_CONN_DISABLED );
}
int main(int argc, char *argv[], char *envp[])
{
tc_init();
enum tc_opt_mode mode =
tc_opt_init(&tc.opt, argc, argv, envp);
/*tc_validate();*/
int rc = 0;
switch (mode) {
case TC_OPT_USAGE:
tc_opt_usage();
break;
case TC_OPT_VERSION:
tc_opt_version();
break;
case TC_OPT_WAL_CAT:
rc = tc_store_cat();
break;
#if 0
case TC_OPT_RPL:
tc_connect();
rc = tc_store_remote();
break;
case TC_OPT_WAL_PLAY:
tc_connect();
rc = tc_store_play();
break;
#endif
case TC_OPT_CMD:
tc_connect();
rc = tc_clicmdv();
break;
case TC_OPT_INTERACTIVE:
tc_connect();
tc_motd();
rc = tc_cli();
break;
}
tc_shutdown();
return rc;
}
int main(int argc, char *argv[])
{
tc_init();
int rc;
enum tc_opt_mode mode = tc_opt_init(&tc.opt, argc, argv);
switch (mode) {
case TC_OPT_USAGE:
tc_opt_usage();
break;
case TC_OPT_RPL:
tc_connect();
rc = tc_wal_remote();
break;
case TC_OPT_WAL_CAT:
rc = tc_wal_cat();
break;
case TC_OPT_WAL_PLAY:
tc_connect();
rc = tc_wal_play();
break;
case TC_OPT_CMD:
tc_connect();
tc_connect_admin();
rc = tc_cli_cmdv();
break;
case TC_OPT_INTERACTIVE:
tc_connect();
tc_connect_admin();
rc = tc_cli();
break;
}
tc_free();
return rc;
}
void Trick::MonteCarlo::dispatch_run_to_slave(MonteRun *in_run, MonteSlave *in_slave) {
if (in_slave && in_run) {
current_run = in_run->id;
if (prepare_run(in_run) == -1) {
return;
}
in_slave->state = MonteSlave::RUNNING;
connection_device.hostname = (char*)in_slave->machine_name.c_str();
connection_device.port = in_slave->port;
if (tc_connect(&connection_device) == TC_SUCCESS) {
std::stringstream buffer_stream;
buffer_stream << run_directory << "/RUN_" << std::setw(5) << std::setfill('0') << in_run->id;
std::string buffer = "";
for (std::vector<std::string>::size_type j = 0; j < in_run->variables.size(); ++j) {
buffer += in_run->variables[j] + "\n";
}
buffer += std::string("trick.set_output_dir(\"") + buffer_stream.str() + std::string("\");\n");
buffer_stream.str("");
buffer_stream << in_run->id ;
buffer += std::string("trick.mc_set_current_run(") + buffer_stream.str() + std::string(");\n");
if (verbosity >= INFORMATIONAL) {
message_publish(MSG_INFO, "Monte [Master] Dispatching run %d to %s:%d.\n",
in_run->id, in_slave->machine_name.c_str(), in_slave->id) ;
}
int command = htonl(MonteSlave::PROCESS_RUN);
tc_write(&connection_device, (char *)&command, (int)sizeof(command));
int num_bytes = htonl(buffer.length());
tc_write(&connection_device, (char*)&num_bytes, (int)sizeof(num_bytes));
tc_write(&connection_device, (char*)buffer.c_str(), (int)buffer.length());
tc_disconnect(&connection_device);
++in_slave->num_dispatches;
in_slave->current_run = in_run;
struct timeval time_val;
gettimeofday(&time_val, NULL);
in_run->start_time = time_val.tv_sec + (double)time_val.tv_usec / 1000000;
++in_run->num_tries;
} else {
in_slave->state = Trick::MonteSlave::DISCONNECTED;
if (verbosity >= ERROR) {
message_publish(MSG_ERROR, "Monte [Master] Lost connection to %s:%d while dispatching run.\n",
in_slave->machine_name.c_str(), in_slave->id) ;
}
}
}
}
int main( int narg, char** args ) {
DataFiles df ;
DataFiles headers ;
TCDevice connection ;
int isAsciiData ;
int ret ;
char* file_name ;
char* msg ;
/* Zero out device */
memset(&connection, '\0', sizeof(TCDevice));
/* Initialize some stuff */
file_name = ( char* ) malloc ( 256 ) ;
msg = ( char* ) malloc ( 1024 ) ;
df.n_files = 0 ;
/* Parse args */
if ( narg != 3 ) {
fprintf(stderr, "USAGE: dr_client <host> <port> \n");
exit(-1);
}
connection.hostname = (char*) malloc ( strlen(args[1]) + 1 ) ;
strcpy(connection.hostname, args[1]);
connection.port = atoi(args[2]) ;
/* Connect to server */
ret = tc_connect(&connection);
if ( ret != TC_SUCCESS ) {
printf("ERROR: Couldn't connect to server on host \"%s\" port %d. \n",
connection.hostname, connection.port);
exit(-1);
}
/* Read data from server and dump data */
dump_data( &df, &connection, &file_name, &msg);
return 0 ;
}
int cannon_init_graphics(
CANNON* C )
{
int ret, num_attempts ;
/* Launch graphics server */
system("cd $HOME/trick_models/cannon/graphics ; cannon &");
/* Initialize clien't connection to server */
C->connection.port = 9000 ;
C->connection.hostname = (char*) malloc( 16 ) ;
strcpy( C->connection.hostname, "localhost");
/* Shutup status messages */
tc_error( &C->connection, 0 ) ;
/* Client connect to server : try for 5 seconds */
num_attempts = 0 ;
while ( 1 ) {
ret = tc_connect( &C->connection ) ;
if ( ret == TC_SUCCESS ) {
break ;
} else {
num_attempts++ ;
if ( num_attempts == 500000 ) {
fprintf(stderr, "Couldn't connect to "
"server...\n");
exit(-1);
}
RELEASE_1(); /* Pause a microsecond */
}
}
return 0 ;
}
int tc_multiconnect(TCDevice * dev_ptr, char *my_tag, char *other_tag, TrickErrorHndlr * not_used)
{
int status;
int num_try = 0;
TCDevice *server_device;
char name[80];
int size;
char *cptr;
/* Multicast vars */
struct sockaddr_in addr;
int fd, nbytes;
struct ip_mreq mreq;
BC_INFO bc_info, *bc_copy;
SEND_ME read_me;
int i_am_client;
int value;
int num_attempts = 10;
int found_conn;
#ifdef __WIN32__
HANDLE thread;
DWORD threadId;
int curr_pid;
WSADATA wsaData;
#else
pthread_t thread;
pid_t curr_pid;
#endif
(void) not_used; /* unused */
if (!dev_ptr) {
TrickErrorHndlr *temp_error_hndlr = NULL;
trick_error_report(temp_error_hndlr, TRICK_ERROR_ALERT, __FILE__, __LINE__, "Trying to connect a NULL device");
return (-1);
}
if (dev_ptr->disabled != 0) {
trick_error_report(dev_ptr->error_handler,
TRICK_ERROR_ALERT, __FILE__, __LINE__,
"[33m%s| cannot connect disabled device %s[00m\n", my_tag, other_tag);
return (TC_SUCCESS);
}
trick_error_report(dev_ptr->error_handler,
TRICK_ERROR_ADVISORY, __FILE__, __LINE__,
"[36m%s| multiconnecting to %s[00m\n", my_tag, other_tag);
/* Create a TrickComm listen device Determine port for listen device */
server_device = (TCDevice *) malloc(sizeof(TCDevice));
memset((void *) server_device, '\0', sizeof(TCDevice));
server_device->error_handler = dev_ptr->error_handler;
server_device->port = 0;
if ((status = tc_init(server_device)) != TC_SUCCESS) {
trick_error_report(server_device->error_handler,
TRICK_ERROR_ALERT, __FILE__, __LINE__, "could not open listen device!\n");
return (status);
}
/*
* Initialize Broadcast Info Structure
*/
gethostname(name, (size_t) 80);
strcpy(bc_info.send_me.addr, name);
bc_info.send_me.port = server_device->port;
bc_info.send_me.pid = curr_pid = getpid();
bc_info.send_me.conn_initiated = 0;
if (my_tag != (char *) NULL) {
strncpy(bc_info.send_me.my_tag, my_tag, (size_t) TC_TAG_LENGTH);
bc_info.send_me.my_tag[TC_TAG_LENGTH - 1] = '\0';
} else {
bc_info.send_me.my_tag[0] = '\0';
}
if (other_tag != (char *) NULL) {
strncpy(bc_info.send_me.other_tag, other_tag, (size_t) TC_TAG_LENGTH);
bc_info.send_me.other_tag[TC_TAG_LENGTH - 1] = '\0';
} else {
bc_info.send_me.other_tag[0] = '\0';
}
bc_info.device = dev_ptr;
#ifdef __WIN32__
/* Initiate use of the Windows socket DLL */
if (WSAStartup(0x202, &wsaData) == SOCKET_ERROR) {
perror("tc_multiconnect: WSAStartup");
WSACleanup();
return (TC_COULD_NOT_ACCEPT);
}
#endif
/* Create the broadcast socket */
if ((bc_info.fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
perror("tc_multiconnect socket");
}
/* Set up destination address */
memset(&bc_info.addr, 0, sizeof(bc_info.addr));
bc_info.addr.sin_family = AF_INET;
bc_info.addr.sin_addr.s_addr = inet_addr(TC_MULT_GROUP);
bc_info.addr.sin_port = htons(TC_MULT_PORT);
/*
* Create socket to listen for connections
*/
if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
perror("tc_multiconnect socket");
}
value = 1;
if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char *) &value, (socklen_t) sizeof(value)) < 0) {
perror("setsockopt: reuseaddr");
}
#ifdef SO_REUSEPORT
if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, (char *) &value, sizeof(value)) < 0) {
perror("setsockopt: reuseport");
}
#endif
/* Set up destination address */
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = htonl(INADDR_ANY);
addr.sin_port = htons(TC_MULT_PORT);
/* Bind to receive address */
if (bind(fd, (struct sockaddr *) &addr, (socklen_t) sizeof(addr)) < 0) {
perror("tc_multiconnect bind");
}
/* Use setsockopt() to request that the kernel join a multicast group */
mreq.imr_multiaddr.s_addr = inet_addr(TC_MULT_GROUP);
mreq.imr_interface.s_addr = htonl(INADDR_ANY);
size = sizeof(mreq);
cptr = (char *) &mreq;
if (setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, cptr, (socklen_t) size) < 0) {
#ifdef __WIN32__
TCHAR szError[100]; // Error message string
wsprintf(szError, TEXT("setsockopt failed! Error: %d"), WSAGetLastError());
MessageBox(NULL, szError, TEXT("Error"), MB_OK);
#endif
perror("setsockopt: ip_add_membership");
}
/* Create thread that will continually broadcast connection info on multicast port for prospective clients. */
/* make a copy of info to broadcast */
bc_copy = (BC_INFO *) malloc(sizeof(BC_INFO));
memcpy(bc_copy, &bc_info, sizeof(BC_INFO));
#ifdef __WIN32__
thread = CreateThread(NULL, 0, tc_broadcast_conninfo, &bc_copy, 0, &threadId);
#else
pthread_create(&thread, NULL, tc_broadcast_conninfo, bc_copy);
#endif
/* Wait for other peers wanting to connect to me */
i_am_client = 0;
found_conn = 0;
while (found_conn == 0) {
do {
nbytes = recvfrom(fd, &read_me, sizeof(SEND_ME), 0, NULL, NULL);
} while ((nbytes == -1) && (tc_errno == TRICKCOMM_EINTR));
if (nbytes == sizeof(read_me)) {
/*
* Read information from peer
*/
read_me.port = ntohl((uint32_t) read_me.port);
read_me.pid = ntohl((uint32_t) read_me.pid);
read_me.conn_initiated = ntohl((uint32_t) read_me.conn_initiated);
/* May I connect with this peer? Rules: Don't connect to myself! Don't connect to someone with same tag as
myself Do connect to someone with same "other tag" */
if (curr_pid != read_me.pid &&
strcmp(bc_info.send_me.my_tag, read_me.my_tag) &&
!strcmp(bc_info.send_me.other_tag, read_me.other_tag)) {
/* Decide who will function as client Whoever has smaller pid will be the client If same pid, decide by
a string compare */
if (curr_pid < read_me.pid) {
i_am_client = 1;
} else if (curr_pid == read_me.pid) {
i_am_client = (strcmp(name, read_me.addr) > 0) ? 1 : 0;
}
/*
* Client Peer initiates the connection
*/
if (i_am_client == 1) {
/* Save off addr and port to connect */
size = strlen(read_me.addr) + 1;
dev_ptr->hostname = (char *) malloc((size_t) size);
strcpy(dev_ptr->hostname, read_me.addr);
dev_ptr->port = read_me.port;
read_me.conn_initiated = 1;
read_me.port = htonl((uint32_t) read_me.port);
read_me.pid = htonl((uint32_t) read_me.pid);
read_me.conn_initiated = htonl((uint32_t) read_me.conn_initiated);
sendto(bc_info.fd, (char *) &read_me, sizeof(SEND_ME), 0,
(struct sockaddr *) &bc_info.addr, (socklen_t) sizeof(bc_info.addr));
found_conn = 1;
}
} else if (curr_pid == read_me.pid &&
!strcmp(bc_info.send_me.addr, read_me.addr) &&
!strcmp(bc_info.send_me.my_tag, read_me.my_tag) &&
!strcmp(bc_info.send_me.other_tag, read_me.other_tag) && read_me.conn_initiated == 1) {
found_conn = 1;
}
}
}
if (other_tag != (char *) NULL) {
strncpy(dev_ptr->client_tag, other_tag, (size_t) TC_TAG_LENGTH);
dev_ptr->client_tag[TC_TAG_LENGTH - 1] = '\0';
}
if (i_am_client == 1) {
/* Client connects */
/* Disconnect unneeded listen device */
tc_disconnect(server_device);
free((void *) server_device);
tc_set_blockio_timeout_limit(dev_ptr, MAX_BLOCKIO_TIMEOUT_LIMIT);
status = 1;
while ((status != TC_SUCCESS) && (num_try < num_attempts)) {
status = tc_connect(dev_ptr);
#if __WIN32__
Sleep(200);
#else
usleep(200000);
#endif
num_try++;
}
} else {
/*
* Server accepts
*/
status = 1;
while (status != TC_SUCCESS && (num_try < num_attempts)) {
if (tc_listen(server_device)) {
status = tc_accept(server_device, dev_ptr);
if (dev_ptr != NULL) {
tc_set_blockio_timeout_limit(dev_ptr, MAX_BLOCKIO_TIMEOUT_LIMIT);
}
}
num_try++;
#if __WIN32__
Sleep(200);
#else
usleep(200000);
#endif
}
tc_disconnect(server_device);
free((void *) server_device);
}
if (status != TC_SUCCESS) {
trick_error_report(server_device->error_handler,
TRICK_ERROR_ALERT, __FILE__, __LINE__, "could not open connection!\n");
return (status);
}
/* Shutdown the broadcast */
shutdown(bc_info.fd, 2);
/* Return the pointer to the TCDevice as the tc_id. */
return (TC_SUCCESS);
}
TEST_F( TCConnectTest, testNoDevice ) {
int connect_status = tc_connect( NULL );
EXPECT_EQ( connect_status, -1 );
}
