/ - Diff - Colony - Robotics Club

     /* Globals */
     static ColonetWireless* wireless;
     extern ConnectionPool connection_pool;
     extern ConnectionPool * connection_pool;
     /* Public functions */
-...
         printf("response\n");
         int dest = (int)(pkt->msg_dest);
         if (dest < connection_pool.get_next_available_slot())
         if (dest < connection_pool->get_next_available_slot())
+        {
           char buffer[WRITE_BUFFER_SIZE];
-...
           snprintf(buffer, WRITE_BUFFER_SIZE, "%d\n", value);
           int len = strlen(buffer);
           connection_pool.write_to_client(dest, buffer, len);
           connection_pool->write_to_client(dest, buffer, len);
           printf("Put data in write buffer for client.\n");
+        }
         else

     /**
      * @author Jason Knichel
      * @date 9/10/07
      */
     #ifndef COLONETSERVER_H
     #define COLONETSERVER_H
     #include "ConnectionPool.h"
     #include "Logging.h"
     class ColonetServer {
     public:
       ColonetServer();
       ~ColonetServer();
       int initialize_server(int argc, char * argv[]);
       int log_error(char * error_message);
       int log_message(char * message);
       int run_server(int listenSocket);
       ConnectionPool * get_connection_pool_pointer();
     private:
       ConnectionPool connection_pool;
       Log logger;
     };
     #endif

trunk/code/projects/colonet/ColonetServer/includes/Logging.h
	1	//TODO: rename either the file or the class so they match
1	2	/**
2	3	*
3	4	* @author Jason Knichel

     #include "includes/Logging.h"
     extern int listenSocket;
     extern Log * logger;
     int initializeServer(int argc, char** argv)
+    {
       printf("Initializing Server...\n");
       parseCmdLine(argc, argv);
       //TODO: make it so the log file name is passed in on command line and default it to something if it isn't
       logger = new Log("logFile.txt");
       if (initConnection(optionsG.listen_port) < 0)
         return -1;
       if (initWireless() < 0) {
         fprintf(stderr, "%s: initWireless failed\n", __FUNCTION__);
         return -1;
+      }
       return 0;
+    }
     /*
     int parseCommandLine(int argc, char * argv[], commandParams_t * params)
+    {

     #include <errno.h>
     #include <arpa/inet.h>
     #include <colonet_wireless.h>
     #include "includes/ColonetServer.h"
     #include "includes/initialization.h"
     #include "includes/ConnectionPool.h"
     #include "includes/client.h"
-...
     #define LISTEN_BACKLOG 5
     #define LOG_BUFFER_LENGTH 128
     ConnectionPool * connection_pool;
     ColonetServer::ColonetServer(): logger("logFile.txt") {
+    }
     ColonetServer::~ColonetServer() {
+    }
     int ColonetServer::initialize_server(int argc, char * argv[]) {
       printf("Initializing Server...\n");
       parseCmdLine(argc, argv);
       if (initConnection(optionsG.listen_port) < 0)
         return -1;
       if (initWireless() < 0) {
         fprintf(stderr, "%s: initWireless failed\n", __FUNCTION__);
         return -1;
+      }
       return 0;
+    }
     int ColonetServer::log_error(char * error_message) {
       return logger.logMessage(LOG_TYPE_ERROR, error_message);
+    }
     int ColonetServer::log_message(char * message) {
       return logger.logMessage(LOG_TYPE_MESSAGE, message);
+    }
     int listenSocket = 0;
     ConnectionPool connection_pool;
     Log * logger;
     //ConnectionPool connection_pool;
     //TODO: make it so the log file name is passed in on command line and default it to something if it isn't
     //Log logger("logFile.txt");
     int main(int argc, char** argv) {
       if (initializeServer(argc, argv) < 0) {
         printf("\t\nThere was an error initializing the server. "
                "Terminating server...\n");
       ColonetServer colonet_server;
       connection_pool = colonet_server.get_connection_pool_pointer();
       if (colonet_server.initialize_server(argc, argv) < 0) {
         colonet_server.log_error("\t\nThere was an error initializing the server. "
                                  "Terminating server...\n");
         return -1;
+      }
       if (listen(listenSocket, LISTEN_BACKLOG) < 0) {
         printf("\t\nThere was an error telling the socket to "
                "listen for connections from clients.  Terminating Server...\n");
         colonet_server.log_error("\t\nThere was an error telling the socket to "
                                  "listen for connections from clients.  Terminating Server...\n");
         return -1;
+      }
       connection_pool.set_listen_socket_in_ready_set(listenSocket);
       colonet_server.run_server(listenSocket);
       //TODO: why is all of this in that if statement and not just conn_pool.maxfd = listenSocket ?
       if (listenSocket > connection_pool.get_max_file_descriptor()) {
         connection_pool.set_max_file_descriptor(listenSocket);
       return 0;
+    }
     int ColonetServer::run_server(int listen_socket) {
       connection_pool.set_listen_socket_in_ready_set(listen_socket);
       //TODO: why is all of this in that if statement and not just conn_pool.maxfd = listen_socket ?
       if (listen_socket > connection_pool.get_max_file_descriptor()) {
         connection_pool.set_max_file_descriptor(listen_socket);
         int acceptSocket = 0;
         struct sockaddr_in clientAddr;
         socklen_t clen = sizeof(clientAddr);
-...
         memset(&selectTimeout,0,sizeof(selectTimeout));
         logger->logMessage(LOG_TYPE_MESSAGE, "Server initialized.  About to start listening for connections");
         logger.logMessage(LOG_TYPE_MESSAGE, "Server initialized.  About to start listening for connections");
         while(1) {
           connection_pool.perform_select(listenSocket, &selectTimeout);
           connection_pool.perform_select(listen_socket, &selectTimeout);
           //either no descriptors are ready or there was an error
           //TODO: check for specific errors
-...
             continue;
+          }
           if (connection_pool.is_socket_ready_to_read(listenSocket)) {
           if (connection_pool.is_socket_ready_to_read(listen_socket)) {
             printf("Something is trying to connect...\n");
             if ((acceptSocket = accept(listenSocket, (struct sockaddr*) &clientAddr, &clen)) < 0) {
             if ((acceptSocket = accept(listen_socket, (struct sockaddr*) &clientAddr, &clen)) < 0) {
               if (errno == EMFILE) {
                 printf("\tWhen attempting to accept a connection, "
                        "reached the per process limit of file descriptors."
-...
             char logBuffer[LOG_BUFFER_LENGTH];
             snprintf(logBuffer, LOG_BUFFER_LENGTH, "Client at address %s attempting to connect.", inet_ntoa(clientAddr.sin_addr));
             logger->logMessage(LOG_TYPE_CONNECT, logBuffer);
             logger.logMessage(LOG_TYPE_CONNECT, logBuffer);
             //TODO: remove this
             //printf("Attempting to add a client.\n");
-...
+            }
             snprintf(logBuffer, LOG_BUFFER_LENGTH, "Client at address %s successfully added to connection pool.", inet_ntoa(clientAddr.sin_addr));
             logger->logMessage(LOG_TYPE_CONNECT, logBuffer);
             logger.logMessage(LOG_TYPE_CONNECT, logBuffer);
+          }
-...
+        }
+      }
        return 0;
       return 0;
+    }
     ConnectionPool * ColonetServer::get_connection_pool_pointer() {
       return &connection_pool;
+    }

Project

General

Profile

Colony

Revision 20