Changeset 1502 for code/trunk/src/network/ClientConnection.cc

Timestamp:

Jun 1, 2008, 3:54:20 PM (17 years ago)

Author:

rgrieder

Message:

• @everyone: Do not create a branch until I've added the svn:eol-style property correctly. Otherwise this would cost me another 4 hours or so when we want to merge back.
• merged network branch back to trunk
• I had to omit the changes from last evening concerning the line endings
• might not work yet because of the line endings
• @beni: script branch is the only branch still open. you probably will have to apply a patch because of inconsistent new lines

File:

• code/trunk/src/network/ClientConnection.cc (modified) (10 diffs)

code/trunk/src/network/ClientConnection.cc

@@ -50 +50 @@
 {
   //static boost::thread_group network_threads;
+
+  boost::recursive_mutex ClientConnection::enet_mutex_;
 
   ClientConnection::ClientConnection(int port, std::string address) {
@@ -75 +77 @@
 
 
-  ENetPacket *ClientConnection::getPacket(ENetAddress &address) {
+  /*ENetPacket *ClientConnection::getPacket(ENetAddress &address) {
     if(!buffer.isEmpty()) {
       //std::cout << "###BUFFER IS NOT EMPTY###" << std::endl;
@@ -88 +90 @@
     ENetAddress address; //sems that address is not needed
     return getPacket(address);
+  }*/
+  
+  ENetEvent *ClientConnection::getEvent(){
+    if(!buffer.isEmpty())
+      return buffer.pop();
+    else
+      return NULL;
   }
 
@@ -98 +107 @@
     //network_threads.create_thread(boost::bind(boost::mem_fn(&ClientConnection::receiverThread), this));
     // wait 10 seconds for the connection to be established
-    return waitEstablished(10000);
+    return waitEstablished(3000);
   }
 
@@ -117 +126 @@
       return false;
     }
+    boost::recursive_mutex::scoped_lock lock(enet_mutex_);
     if(enet_peer_send(server, 0, packet)<0)
       return false;
@@ -123 +133 @@
   }
 
-  bool ClientConnection::sendPackets(ENetEvent *event) {
+  bool ClientConnection::sendPackets() {
     if(server==NULL)
       return false;
-    if(enet_host_service(client, event, NETWORK_SEND_WAIT)>=0){
-      return true;}
-    else
-      return false;
-  }
-
-  bool ClientConnection::sendPackets() {
-    ENetEvent event;
-    if(server==NULL)
-      return false;
-    if(enet_host_service(client, &event, NETWORK_SEND_WAIT)>=0){
-      return true;}
-    else
-      return false;
+    boost::recursive_mutex::scoped_lock lock(enet_mutex_);
+    enet_host_flush(client);
+    lock.unlock();
+    return true;
   }
 
   void ClientConnection::receiverThread() {
     // what about some error-handling here ?
-    enet_initialize();
     atexit(enet_deinitialize);
-    ENetEvent event;
-    client = enet_host_create(NULL, NETWORK_CLIENT_MAX_CONNECTIONS, 0, 0);
-    if(client==NULL)
+    ENetEvent *event;
+    {
+      boost::recursive_mutex::scoped_lock lock(enet_mutex_);
+      enet_initialize();
+      client = enet_host_create(NULL, NETWORK_CLIENT_MAX_CONNECTIONS, 0, 0);
+      lock.unlock();
+    }
+    if(client==NULL) {
+      COUT(2) << "ClientConnection: could not create client host" << std::endl;
       // add some error handling here ==========================
       quit=true;
+    }
     //connect to the server
     if(!establishConnection()){
+      COUT(2) << "clientConn: receiver thread: could not establishConnection" << std::endl;
       quit=true;
       return;
     }
+    event = new ENetEvent;
     //main loop
     while(!quit){
       //std::cout << "connection loop" << std::endl;
-      if(enet_host_service(client, &event, NETWORK_CLIENT_TIMEOUT)<0){
-        // we should never reach this point
-        quit=true;
-        // add some error handling here ========================
+      {
+        boost::recursive_mutex::scoped_lock lock(enet_mutex_);
+        if(enet_host_service(client, event, NETWORK_CLIENT_TIMEOUT)<0){
+          // we should never reach this point
+          quit=true;
+          continue;
+          // add some error handling here ========================
+        }
+        lock.unlock();
       }
-      switch(event.type){
+      switch(event->type){
         // log handling ================
       case ENET_EVENT_TYPE_CONNECT:
+        break;
       case ENET_EVENT_TYPE_RECEIVE:
         COUT(5) << "Cl.Con: receiver-Thread while loop: got new packet" << std::endl;
-        if ( !processData(&event) ) COUT(2) << "Current packet was not pushed to packetBuffer -> ev ongoing SegFault" << std::endl;
+        if ( !processData(event) ) COUT(2) << "Current packet was not pushed to packetBuffer -> ev ongoing SegFault" << std::endl;
         COUT(5) << "Cl.Con: processed Data in receiver-thread while loop" << std::endl;
+        event = new ENetEvent;
         break;
       case ENET_EVENT_TYPE_DISCONNECT:
@@ -178 +193 @@
         break;
       case ENET_EVENT_TYPE_NONE:
-        continue;
+        //receiverThread_->yield();
+        usleep(1000);
+        break;
       }
-      //receiverThread_->yield();
     }
     // now disconnect
@@ -186 +202 @@
     if(!disconnectConnection())
       // if disconnecting failed destroy conn.
+      boost::recursive_mutex::scoped_lock lock(enet_mutex_);
       enet_peer_reset(server);
     return;
@@ -192 +209 @@
   bool ClientConnection::disconnectConnection() {
     ENetEvent event;
+    boost::recursive_mutex::scoped_lock lock(enet_mutex_);
     enet_peer_disconnect(server, 0);
     while(enet_host_service(client, &event, NETWORK_CLIENT_TIMEOUT) > 0){
@@ -212 +230 @@
     ENetEvent event;
     // connect to peer (server is type ENetPeer*)
+    boost::recursive_mutex::scoped_lock lock(enet_mutex_);
     server = enet_host_connect(client, &serverAddress, NETWORK_CLIENT_CHANNELS);
-    if(server==NULL)
+    if(server==NULL) {
+      COUT(2) << "ClientConnection: server == NULL" << std::endl;
       // error handling
       return false;
+    }
     // handshake
-    if(enet_host_service(client, &event, NETWORK_CLIENT_TIMEOUT)>0 && event.type == ENET_EVENT_TYPE_CONNECT){
+    if(enet_host_service(client, &event, NETWORK_CLIENT_TIMEOUT)>=0 && event.type == ENET_EVENT_TYPE_CONNECT){
       established=true;
       return true;
     }
-    else
-      return false;
+    else {
+      COUT(2) << "ClientConnection: enet_host_service < 0 or event.type != ENET_EVENT_TYPE_CONNECT # EVENT:" << event.type << std::endl;
+      return false;
+    }
   }