long test3(const char* timeLog_filepath, int num_of_clients, int ksm )
{
char shell_command[BUFSIZ];
char cache_filepath[1024];
char client_name[1024];
char group_name[1024];
int i,j,k;
long total_time = 0.0L;
FILE* timeLog_file = NULL;
char* base_client_name =
(ksm==2)? KSM2_BASE_CLIENT_NAME:KSM1_BASE_CLIENT_NAME;
// Create client principals and its cache for each client
for( i = 0; i < num_of_clients; i++ ) {
//printf("\rCreating client principal and ticket cache %d of %d",
// i+1, num_of_clients);
snprintf(client_name, 1024, "%s%d", base_client_name, i);
create_client_princ( client_name );
create_client_cache( client_name );
}
//printf("\n");
// Execute all client request sequentially
for( i = 1; i <= group_count; i++ ) {
memset(group_name, 0, 1024);
snprintf(group_name, 1024, "group%d", i);
int a[num_of_clients], nvalues = num_of_clients;
for( k = 0; k < nvalues; k++ ) a[k] = k;
for( k = 0; k < nvalues -1; k++) {
int c = rand() / (RAND_MAX/(nvalues-k) + 1 );
int t = a[k]; a[k] = a[k+c]; a[k+c] = t;
}
for( j = 0; j < group_size; j++ ) {
int cid = a[j]; // client id
snprintf(client_name, 1024, "%s%d", base_client_name, cid);
snprintf(cache_filepath, 1024, "%s/%s%d.cache",
RUNTIME_DIR, base_client_name, cid);
if( client_exec( group_name, cache_filepath,
timeLog_filepath, ksm) < 0 )
{
for( k = 0; k < num_of_clients; k++ ) {
snprintf(client_name, 1024, "%s%d",
base_client_name, k);
delete_client_cache( client_name );
delete_client_princ( client_name );
}
delete_service("group",group_count);
printf("Client failed\n");
exit(1);
}
long last_val = get_last_value( timeLog_filepath );
if( last_val > 100 || last_val < 0) {
snprintf(shell_command, BUFSIZ,"%s %s",
DEL_LAST_LINE,
timeLog_filepath,
NULL);
// Reject data that's out of range
system(shell_command);
if (ksm == 2) {
delete_client_cache( client_name );
create_client_cache( client_name );
}
// printf("last_val too high, reject%ld\n", last_val);
j--;
}
}
}
timeLog_file = fopen(timeLog_filepath, "r");
if( timeLog_file != NULL ) {
char line[128];
for(i = 0; i < group_size*group_count; i++ ) {
if( fgets(line, sizeof(line),
timeLog_file) != NULL )
{
total_time += atol( line );
}
}
fclose(timeLog_file);
}
else {
perror( timeLog_filepath );
}
for( i = 0; i < num_of_clients; i++ ) {
snprintf(client_name, 1024, "%s%d", base_client_name, i);
delete_client_cache( client_name );
delete_client_princ( client_name );
}
//printf("\n");
return total_time;
}
int main(int argc, char **argv)
{
// Prepare the environment
int sys_return_val = 0;
std::string cmd = "l3dclient_mklocal_dir.sh";
sys_return_val = std::system(cmd.c_str());
std::cout<<std::endl<<"SYSTEM -> "<<sys_return_val<<std::endl;
try
{
std::string name = "NONAME";
std::string ip = "localhost";
std::string port = "8080";
QApplication app(argc, argv);
// SoQt::init ... only after QApplication...
SoQt::init(argv[0]);
// Log IN
login_dialog ldia;
int dialogCode = ldia.exec();
if( dialogCode == QDialog::Rejected )
{
return 0;
}
else
{
name = ldia.lineEdit_name->text().toStdString();
ip = ldia.lineEdit_ip->text().toStdString();
port = ldia.lineEdit_port->text().toStdString();
}
// END LOG IN
boost::asio::io_service io_service;
boost::asio::ip::tcp::resolver resolver(io_service);
boost::asio::ip::tcp::resolver::query query(ip.c_str(), port.c_str());
boost::asio::ip::tcp::resolver::iterator iterator = resolver.resolve(query);
client c(io_service, iterator);
std::string executors_name = name.c_str();
command_executor client_exec(executors_name);
c.add_observer(&client_exec);
global_client = &c;
qDebug()<<"==============================\n";
// DOWNLOAD WORLD RESOURCES
c.send(std::string("@get_resources"));
qDebug()<<"==============================\n";
int avatar_gender = ldia.selected_avatar;
avatar my_avatar(executors_name, c, avatar_gender );
user_avatar = & my_avatar;
//start BOOST_ASIO
boost::thread asio_th(boost::bind(&boost::asio::io_service::run, &io_service));
if(asio_th.joinable()) {
cout << "Detaching thread" << endl;
asio_th.detach();
}
// The scene
SoSeparator *root = startUpScene( my_avatar.get3d_model() );
root->ref();
gui viewer(root, app, camera);
client_exec.set_vrml_tree_node( root );
viewer.showMaximized();
return app.exec();
}
catch(std::exception &e)
{
std::cout<<std::endl<<e.what();
exit(EXIT_FAILURE);
}
catch(std::string msg)
{
std::cout<<std::endl<<msg;
exit(EXIT_FAILURE);
}
return EXIT_SUCCESS;
}
void server_exec(Socket server, SockAddrIn server_addr, ClientSet* clients,
NoticeBoard* board)
{
int i;
if (listen(server, 5) == -1) {
error("Could not listen on socket");
exit(1);
}
while (running) {
usleep(100000);
/* -- Accepting connections -- */
socklen_t sz = sizeof(server_addr);
Socket new_socket = accept(server, (SockAddr*)&server_addr, &sz);
/* Error handling, most likely EAGAIN since we're using
* non blocking sockets.
*/
if (new_socket == -1) {
if (errno != EAGAIN) {
error("Could not accept connection");
}
} else {
int j = 0;
fcntl(new_socket, F_SETFL, O_NONBLOCK);
Client* c = ClientSet_Add(clients, new_socket);
if (c == NULL) continue;
memset(c->properties.nick, 0, NICK_MAXLEN);
strcpy(c->properties.nick, "user");
for (i = 0; i < clients->size; i++) {
if (&clients->clients[i] == c ||
clients->clients[i].state == DISCONNECTED) continue;
if (!strcmp(clients->clients[i].properties.nick,
c->properties.nick)) {
j++;
sprintf(c->properties.nick, "user(%d)", j);
i = 0;
}
}
SockAddr peer_address;
socklen_t addrlen = sizeof(peer_address);
int has_error = getpeername(new_socket, &peer_address,
&addrlen);
if (has_error == -1) {
error("Error getting peer name");
}
SockAddrIn *addr_in = (struct sockaddr_in *)&peer_address;
c->ip_string = ipaddr(*addr_in);
printf("Client connected (%s)\n", c->ip_string);
send_motd(c);
}
/* -- Reading data -- */
for (i = 0; i < clients->size; i++) {
if (clients->clients[i].state == DISCONNECTED) {
Client_Destroy(&clients->clients[i]);
continue;
}
client_exec(&(clients->clients[i]), i, clients, board);
}
}
}
