Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/netp3/src/network/ConnectionManager.cc @ 3050

Last change on this file since 3050 was 2992, checked in by scheusso, 16 years ago

some fixes (in tick, getDeltaTime) and error output

  • Property svn:eol-style set to native
File size: 8.8 KB
RevLine 
[1282]1/*
2 *   ORXONOX - the hottest 3D action shooter ever to exist
3 *                    > www.orxonox.net <
4 *
5 *
6 *   License notice:
7 *
8 *   This program is free software; you can redistribute it and/or
9 *   modify it under the terms of the GNU General Public License
10 *   as published by the Free Software Foundation; either version 2
11 *   of the License, or (at your option) any later version.
12 *
13 *   This program is distributed in the hope that it will be useful,
14 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
15 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 *   GNU General Public License for more details.
17 *
18 *   You should have received a copy of the GNU General Public License
19 *   along with this program; if not, write to the Free Software
20 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
21 *
22 *   Author:
23 *      Oliver Scheuss, (C) 2007
24 *   Co-authors:
25 *      ...
26 *
27 */
28
29//
30// C++ Interface: ConnectionManager
31//
32// Description: The Class ConnectionManager manages the servers conenctions to the clients.
33// each connection is provided by a new process. communication between master process and
34// connection processes is provided by ...
35//
36//
37// Author:  Oliver Scheuss
38//
39
[1842]40#include "ConnectionManager.h"
41
[2773]42#include <enet/enet.h>
[1282]43#include <iostream>
[2773]44#include <cassert>
[1282]45// boost.thread library for multithreading support
[1755]46#include <boost/thread/thread.hpp>
[1282]47#include <boost/bind.hpp>
[2773]48#include <boost/thread/recursive_mutex.hpp>
[1282]49
[2896]50#include "util/Debug.h"
[1282]51#include "util/Math.h"
[1502]52#include "util/Sleep.h"
[1282]53#include "ClientInformation.h"
[2662]54#include "synchronisable/Synchronisable.h"
[1735]55#include "packet/ClassID.h"
[1282]56
57namespace std
58{
59  bool operator< (ENetAddress a, ENetAddress b) {
[2990]60    return a.host <= b.host;
[1282]61  }
62}
63
[2171]64namespace orxonox
[1282]65{
66  //boost::thread_group network_threads;
[2773]67  static boost::recursive_mutex enet_mutex_g;
[1747]68
[1735]69  ConnectionManager *ConnectionManager::instance_=0;
[1747]70
[1735]71  ConnectionManager::ConnectionManager():receiverThread_(0){
72    assert(instance_==0);
73    instance_=this;
[2990]74    quit_=false;
[2773]75    bindAddress = new ENetAddress();
76    bindAddress->host = ENET_HOST_ANY;
77    bindAddress->port = NETWORK_PORT;
[1282]78  }
[1747]79
[1735]80  ConnectionManager::ConnectionManager(int port){
81    assert(instance_==0);
82    instance_=this;
[2990]83    quit_=false;
[2773]84    bindAddress = new ENetAddress();
85    bindAddress->host = ENET_HOST_ANY;
86    bindAddress->port = port;
[1502]87  }
[1282]88
[2087]89  ConnectionManager::ConnectionManager(int port, const std::string& address) :receiverThread_(0) {
[1735]90    assert(instance_==0);
91    instance_=this;
[2990]92    quit_=false;
[2773]93    bindAddress = new ENetAddress();
94    enet_address_set_host (bindAddress, address.c_str());
95    bindAddress->port = NETWORK_PORT;
[1282]96  }
97
[1735]98  ConnectionManager::ConnectionManager(int port, const char *address) : receiverThread_(0) {
99    assert(instance_==0);
100    instance_=this;
[2990]101    quit_=false;
[2773]102    bindAddress = new ENetAddress();
103    enet_address_set_host (bindAddress, address);
104    bindAddress->port = NETWORK_PORT;
[1282]105  }
[1747]106
[1735]107  ConnectionManager::~ConnectionManager(){
[2990]108    if(!quit_)
[1735]109      quitListener();
[1907]110    instance_=0;
[2773]111    delete bindAddress;
[1735]112  }
[1282]113
[1747]114
[1502]115  ENetEvent *ConnectionManager::getEvent(){
116    if(!buffer.isEmpty())
117      return buffer.pop();
118    else
119      return NULL;
[1282]120  }
121
122  bool ConnectionManager::queueEmpty() {
123    return buffer.isEmpty();
124  }
125
126  void ConnectionManager::createListener() {
127    receiverThread_ = new boost::thread(boost::bind(&ConnectionManager::receiverThread, this));
128    return;
129  }
130
131  bool ConnectionManager::quitListener() {
[2990]132    quit_=true;
[1282]133    receiverThread_->join();
134    return true;
135  }
[1747]136
137
[1282]138  bool ConnectionManager::addPacket(ENetPacket *packet, ENetPeer *peer) {
[2773]139    boost::recursive_mutex::scoped_lock lock(enet_mutex_g);
[1735]140    if(enet_peer_send(peer, NETWORK_DEFAULT_CHANNEL, packet)!=0)
[1282]141      return false;
142    return true;
143  }
144
145  bool ConnectionManager::addPacket(ENetPacket *packet, int clientID) {
[1735]146    ClientInformation *temp = ClientInformation::findClient(clientID);
[1502]147    if(!temp){
148      COUT(3) << "C.Man: addPacket findClient failed" << std::endl;
[1282]149      return false;
[1502]150    }
[1735]151    return addPacket(packet, temp->getPeer());
[1282]152  }
153
154  bool ConnectionManager::addPacketAll(ENetPacket *packet) {
[1735]155    if(!instance_)
156      return false;
[2773]157    boost::recursive_mutex::scoped_lock lock(enet_mutex_g);
[1735]158    for(ClientInformation *i=ClientInformation::getBegin()->next(); i!=0; i=i->next()){
[1534]159      COUT(3) << "adding broadcast packet for client: " << i->getID() << std::endl;
160      if(enet_peer_send(i->getPeer(), 0, packet)!=0)
[1282]161        return false;
162    }
163    return true;
164  }
165
[1502]166  // we actually dont need that function, because host_service does that for us
[1282]167  bool ConnectionManager::sendPackets() {
[1735]168    if(server==NULL || !instance_)
[1282]169      return false;
[2773]170    boost::recursive_mutex::scoped_lock lock(enet_mutex_g);
[1502]171    enet_host_flush(server);
172    lock.unlock();
173    return true;
[1282]174  }
175
176  void ConnectionManager::receiverThread() {
177    // what about some error-handling here ?
[1502]178    ENetEvent *event;
[1282]179    atexit(enet_deinitialize);
[1502]180    { //scope of the mutex
[2773]181      boost::recursive_mutex::scoped_lock lock(enet_mutex_g);
[1502]182      enet_initialize();
[2773]183      server = enet_host_create(bindAddress, NETWORK_MAX_CONNECTIONS, 0, 0);
[1502]184      lock.unlock();
185    }
[1282]186    if(server==NULL){
187      // add some error handling here ==========================
[2990]188      quit_=true;
[1282]189      return;
190    }
191
[1502]192    event = new ENetEvent;
[2990]193    while(!quit_)
194    {
[1502]195      { //mutex scope
[2773]196        boost::recursive_mutex::scoped_lock lock(enet_mutex_g);
[1502]197        if(enet_host_service(server, event, NETWORK_WAIT_TIMEOUT)<0){
198          // we should never reach this point
[2990]199          printf("ConnectionManager: ENet returned with an error\n");
200          quit_=true;
[2992]201          printf("waaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaahhhhhhhhhhhhhhhh\n");
[1502]202          continue;
203          // add some error handling here ========================
204        }
205        lock.unlock();
[1282]206      }
207      switch(event->type){
208        // log handling ================
209        case ENET_EVENT_TYPE_CONNECT:
[2992]210//             printf("====================================================================");
[1502]211        case ENET_EVENT_TYPE_DISCONNECT:
[1282]212        case ENET_EVENT_TYPE_RECEIVE:
213            processData(event);
[1502]214            event = new ENetEvent;
[1282]215          break;
216        case ENET_EVENT_TYPE_NONE:
[1502]217          //receiverThread_->yield();
[2990]218          msleep(10);
[1282]219          break;
220      }
221//       usleep(100);
[1502]222      //receiverThread_->yield(); //TODO: find apropriate
[1282]223    }
224    disconnectClients();
225    // if we're finishied, destroy server
[1502]226    {
[2773]227      boost::recursive_mutex::scoped_lock lock(enet_mutex_g);
[1502]228      enet_host_destroy(server);
229      lock.unlock();
230    }
[1282]231  }
[1747]232
[1282]233  //### added some bugfixes here, but we cannot test them because
234  //### the server crashes everytime because of some gamestates
235  //### (trying to resolve that now)
236  void ConnectionManager::disconnectClients() {
237    ENetEvent event;
[1735]238    ClientInformation *temp = ClientInformation::getBegin()->next();
[1282]239    while(temp!=0){
[1502]240      {
[2773]241        boost::recursive_mutex::scoped_lock lock(enet_mutex_g);
[1502]242        enet_peer_disconnect(temp->getPeer(), 0);
243        lock.unlock();
244      }
[1282]245      temp = temp->next();
246    }
247    //bugfix: might be the reason why server crashes when clients disconnects
[1735]248    temp = ClientInformation::getBegin()->next();
[2773]249    boost::recursive_mutex::scoped_lock lock(enet_mutex_g);
[1502]250    while( temp!=0 && enet_host_service(server, &event, NETWORK_WAIT_TIMEOUT) >= 0){
[1282]251      switch (event.type)
252      {
253      case ENET_EVENT_TYPE_NONE: break;
254      case ENET_EVENT_TYPE_CONNECT: break;
255      case ENET_EVENT_TYPE_RECEIVE:
256        enet_packet_destroy(event.packet);
257        break;
258      case ENET_EVENT_TYPE_DISCONNECT:
259        COUT(4) << "disconnecting all clients" << std::endl;
[1735]260        if(ClientInformation::findClient(&(event.peer->address)))
261          delete ClientInformation::findClient(&(event.peer->address));
[1282]262        //maybe needs bugfix: might also be a reason for the server to crash
263        temp = temp->next();
264        break;
265      }
266    }
267    return;
268  }
269
270
[2773]271  int ConnectionManager::getClientID(ENetPeer* peer) {
272    return getClientID(&(peer->address));
[1282]273  }
274
[2773]275  int ConnectionManager::getClientID(ENetAddress* address) {
276    return ClientInformation::findClient(address)->getID();
[1282]277  }
278
279  ENetPeer *ConnectionManager::getClientPeer(int clientID) {
[1735]280    return ClientInformation::findClient(clientID)->getPeer();
[1282]281  }
282
[2759]283
[1735]284  void ConnectionManager::syncClassid(unsigned int clientID) {
[2759]285    int failures=0;
286    packet::ClassID *classid = new packet::ClassID();
287    classid->setClientID(clientID);
288    while(!classid->send() && failures < 10){
289      failures++;
[1282]290    }
[2759]291    assert(failures<10);
[1282]292    COUT(4) << "syncClassid:\tall synchClassID packets have been sent" << std::endl;
293  }
[2759]294 
[1282]295
296  void ConnectionManager::disconnectClient(ClientInformation *client){
[1502]297    {
[2773]298      boost::recursive_mutex::scoped_lock lock(enet_mutex_g);
[1502]299      enet_peer_disconnect(client->getPeer(), 0);
300      lock.unlock();
301    }
[1282]302  }
303
[1747]304
[1282]305}
Note: See TracBrowser for help on using the repository browser.