Colony

/**

 * @file ColonetServer.cpp

 *

 * @brief colonet_server - primary server application for Colonet

 *

 * @author Jason Knichel

 * @author Eugene Marinelli

 * @date 10/31/06

 */

#include <arpa/inet.h>

#include <fcntl.h>

#include <errno.h>

#include <netinet/in.h>

#include <string.h>

#include <unistd.h>

#include <sys/select.h>

#include <sys/socket.h>

#include <colonet_wireless.h>

#include <ColonetServer.h>

#include <ConnectionPool.h>

#include <options.h>

#include <Log.h>

#define LISTEN_BACKLOG 5

#define LOG_BUFFER_LENGTH 128

#define MAX_MSG_BUFFER_LENGTH 128

#define REFRESH_VIRTUAL_WALL_PERIOD 400

#define u_int32_t unsigned

/**

 * @brief Default constructor for ColonetServer

 */

ColonetServer::ColonetServer() {

  listen_socket = 0;

  connection_pool = new ConnectionPool(this);

}

/**

 * @brief Destructor for ColonetServer

 */

ColonetServer::~ColonetServer() {

}

/**

 * @brief Initializes the various elements needed for the server to run

 *

 * @param argc The number of command line arguments passed to the program

 * @param argv The command line arguments passed to the program

 *

 * @return 0 on success, negative error code on failure

 */

int ColonetServer::initialize_server(int argc, char * argv[]) {

  options_parseCmdLine(argc, argv);

  if (optionsG.logging_enabled) {

    logger = new Log("colonet_server_log.txt");

  }

  if (initialize_connection(optionsG.listen_port) < 0) {

    return -1;

  }

  if (initialize_wireless() < 0) {

    fprintf(stderr, "%s: initWireless failed\n", __FUNCTION__);

    //TODO: Can we continue safely without wireless?

    //return -1;

  }

  return 0;

}

/**

 * @brief Starts the server listening on the socket that was opened for listening

 *

 * @return 0 on success, negative error code on failure

 */

int ColonetServer::start_listening() {

  if (listen(listen_socket, LISTEN_BACKLOG) < 0) {

    if (optionsG.logging_enabled) {

      logger->log_error("\t\nThere was an error telling the socket to listen for connections from clients.  "

                        "Terminating Server...\n");

    }

    return -1;

  }

  return 0;

}

/**

 * @brief The function that is run in the new pthread in order to do the position monitoring

 *

 * @param arg the argument to give to the new thread

 */

void* loop_position_monitor(void* arg) {

  PositionMonitor* p = (PositionMonitor*) arg;

  p->run();

  return NULL;

}

/**

 * @brief This function spawns a new thread to do the position monitoring based off data

 *  retrieved from the library that parses the image from the camera

 */

int ColonetServer::run_position_monitor() {

  pthread_t posmon_thread;

  pthread_create(&posmon_thread, NULL, loop_position_monitor, &position_monitor);

  return 0;

}

/**

 * @brief The function that is run in the new pthread in order to do the client processing

 */

void ColonetServer::loop_server() {

  //add the socket that you will listen to connections on to the connection pool

  connection_pool->add_new_socket_to_pool(listen_socket);

  int accept_socket = 0;

  struct sockaddr_in client_addr;

  socklen_t client_addr_size = sizeof(client_addr);

  if (optionsG.logging_enabled) {

    logger->log_message("Server initialized.  About to start listening for connections");

  }

  while(1) {

    //sleep for a little bit so this program doesn't hog cpu

    usleep(10000);

    //tell the connection pool to look at the file descriptors and see which ones are ready

    connection_pool->perform_select(listen_socket);

    //either no descriptors are ready or there was an error

    if (connection_pool->get_number_clients_ready() <= 0) {

      continue;

    }

    //check to see if a new client is trying to connect

    if (connection_pool->is_socket_ready_to_read(listen_socket)) {

      printf("Something is trying to connect...\n");

      //accept the connection

      if ((accept_socket = accept(listen_socket, (struct sockaddr*) &client_addr, &client_addr_size)) < 0) {

        if (errno == EMFILE) {

          printf("\tWhen attempting to accept a connection, reached the per process limit of file descriptors."

                 "  Dropping the new connection.\n");

          continue;

        } else {

          printf("\tThere was an error when attempting to accept a connection");

        }

        continue;

      }

      if (optionsG.logging_enabled) {

        char log_buffer[LOG_BUFFER_LENGTH];

        snprintf(log_buffer, LOG_BUFFER_LENGTH, "Client at address %s attempting to connect.",

                                                                 inet_ntoa(client_addr.sin_addr));

        logger->log_string(LOG_TYPE_CONNECT, log_buffer);

      }

      //add the new client to the connection pool

      if (connection_pool->add_client(accept_socket) < 0) {

        printf("\tThere was an error when trying to add a client to the connection pool.");

        continue;

      }

      if (optionsG.logging_enabled) {

        char log_buffer[LOG_BUFFER_LENGTH];

        snprintf(log_buffer, LOG_BUFFER_LENGTH, "Client at address %s successfully added to connection pool.",

                 inet_ntoa(client_addr.sin_addr));

        logger->log_string(LOG_TYPE_CONNECT, log_buffer);

      }

    }

    //check all the clients in the connection pool

    if (connection_pool->check_clients() < 0) {

      printf("\tThere was an error trying to update the clients.");

    }

  }

}

/**

 * @brief Launchpad function to start loop_server() since callbacks don't support member functions

 *

 * @param arg the argument to give to the new thread

 */

void * launch_loop_server(void *arg) {

  ColonetServer *object = (ColonetServer*) arg;

  object->loop_server();

  return NULL;

}

/**

 * @brief Starts the server running (starts an infinite loop)

 */

int ColonetServer::run_server() {

  pthread_t server_thread;

  pthread_create(&server_thread, NULL, launch_loop_server, this);

  return 0;

}

/**

 * @brief Main loop of the server, runs periodic tasks

 *

 * @return 0 on success, negative error code on failure

 */

int ColonetServer::run_loop() {

  int refresh_virtual_wall_count = 0;

  while(1) {

    //sleep for a little bit so this program doesn't hog cpu

    usleep(10000);

    /* Refresh virtual wall. */

    if (refresh_virtual_wall_count++ == REFRESH_VIRTUAL_WALL_PERIOD) {

      fprintf(stderr, "Sending virtual wall info to robots.\n");

      refresh_virtual_wall_count = 0;

      virtual_wall.send_to_robots();

    }

  }

  return 0;

}

/**

 * @brief when the server receives a new wireless message, it calls this function to process it

 *

 * @param source - ID of robot that message is from.

 * @param dest - ID of internet client to send message to.

 * @param data - Data to send to internet client.

 * @param len - Length of the data param.

 */

int ColonetServer::process_received_wireless_message(int dest, char* data, int len) {

  //try to pass the robot's response onto the client it wanted to respond to

  if (connection_pool->write_to_client(dest, data, len) == ERROR_INVALID_CLIENT_ID) {

    printf("The robot wanted to pass the data to a client not in the pool.\n");

    return -1;

  }

  printf("Processing data from robot: %s\n", data);

  return 0;

}

/**

 * @brief Initializes the wireless

 *

 * @return 0 on success, negative error code on error

 */

int ColonetServer::initialize_wireless() {

  char* log_filename = NULL;

  if (optionsG.logging_enabled) {

    printf("Logging enabled. Log filename: %s\n", optionsG.log_filename);

    log_filename = optionsG.log_filename;

  } else {

    printf("Logging disabled.\n");

  }

  //initialize the wireless library giving it the port and the log file name

  if (colonet_wl_init(optionsG.wireless_port, log_filename) != 0) {

    fprintf(stderr, "ERROR - colonet_wl_init failed.\n");

    return -1;

  }

  //call the function that will start the thread that will listen for wireless messages

  if (colonet_wl_run_listener_thread()) {

    fprintf(stderr, "%s: colonet_wl_run_listener_thread failed.\n", __FUNCTION__);

    return -1;

  }

  return 0;

}

/**

 * @brief Initialize a connection to listen on

 *

 * @port The port to try to open to listen on

 *

 * @return 0 on success, negative error code on error

 */

int ColonetServer::initialize_connection(int port) {

  printf("Initializing connection that will be used to listen for clients...\n");

  int options = 1;

  struct sockaddr_in my_address;

  //get a socket fd

  if ((listen_socket = socket(AF_INET, SOCK_STREAM, 0)) < 0) {

    printf("\tThere was an error creating socket\n");

    return -1;

  }

  //set up the address struct

  memset(&my_address,'\0',sizeof(my_address));

  my_address.sin_family = AF_INET;

  my_address.sin_addr.s_addr = htonl(INADDR_ANY);

  my_address.sin_port = htons(port);

  setsockopt(listen_socket, SOL_SOCKET, SO_REUSEADDR, &options, sizeof(options));

  //get the current socket options

  if ((options = fcntl(listen_socket, F_GETFL)) < 0) {

    printf("\tThere was an error getting the socket options.\n");

    return -1;

  }

  //set the socket to non blocking

  options = (options | O_NONBLOCK);

  if (fcntl(listen_socket, F_SETFL, options) < 0) {

    printf("\tThere was an error setting the socket to be non blocking.\n");

    return -1;

  }

  //bind the socket to listen on the specified port

  if (bind(listen_socket, (struct sockaddr *) &my_address, sizeof(my_address)) < 0) {

    printf("\tThere was an error binding the socket\n");

    return -1;

  }

  return 0;

}

/**

 * @brief returns the position monitor

 */

PositionMonitor* ColonetServer::getPositionMonitor() {

  return &position_monitor;

}

VirtualWall* ColonetServer::getVirtualWall() {

  return &virtual_wall;

}