source/network/server.cpp

   1 #include <msp/core/refptr.h>
   2 #include <msp/net/inet.h>
   3 #include <msp/net/resolve.h>
   4 #include "libr2c2/catalogue.h"
   5 #include "libr2c2/driver.h"
   6 #include "libr2c2/route.h"
   7 #include "libr2c2/train.h"
   8 #include "libr2c2/trainrouter.h"
   9 #include "libr2c2/trainstatus.h"
  10 #include "libr2c2/vehicletype.h"
  11 #include "server.h"
  12
  13 using namespace std;
  14 using namespace Msp;
  15
  16 namespace R2C2 {
  17
  18 Server::Server(Layout &l):
  19         layout(l),
  20         listen_sock(Net::INET),
  21         event_disp(0)
  22 {
  23         layout.get_driver().signal_power.connect(sigc::hide(sigc::mem_fun(this, &Server::driver_state_changed)));
  24         layout.get_driver().signal_halt.connect(sigc::hide(sigc::mem_fun(this, &Server::driver_state_changed)));
  25         layout.signal_emergency.connect(sigc::mem_fun(this, &Server::emergency));
  26
  27         layout.signal_train_added.connect(sigc::mem_fun(this, &Server::train_added));
  28
  29         const map<unsigned, Train *> &trains = layout.get_trains();
  30         for(map<unsigned, Train *>::const_iterator i=trains.begin(); i!=trains.end(); ++i)
  31                 train_added(*i->second);
  32
  33         RefPtr<Net::SockAddr> addr = Net::resolve("*", "8315", Net::INET);
  34         listen_sock.listen(*addr, 4);
  35         listen_sock.signal_data_available.connect(sigc::mem_fun(this, &Server::incoming_connection));
  36 }
  37
  38 Server::~Server()
  39 { }
  40
  41 void Server::use_event_dispatcher(IO::EventDispatcher &ed)
  42 {
  43         event_disp = &ed;
  44         event_disp->add(listen_sock);
  45 }
  46
  47 void Server::incoming_connection()
  48 {
  49         Net::StreamSocket *sock = listen_sock.accept();
  50         if(event_disp)
  51                 event_disp->add(*sock);
  52         connections.push_back(new Connection(*this, sock));
  53 }
  54
  55 void Server::driver_state_changed()
  56 {
  57         DriverStatePacket pkt;
  58         pkt.power = layout.get_driver().get_power();
  59         pkt.halt = layout.get_driver().is_halted();
  60         send(pkt);
  61 }
  62
  63 void Server::emergency(Block *, const string &msg)
  64 {
  65         EmergencyPacket pkt;
  66         pkt.message = msg;
  67         send(pkt);
  68 }
  69
  70 void Server::train_added(Train &train)
  71 {
  72         train.signal_control_changed.connect(sigc::bind<0>(sigc::mem_fun(this, &Server::train_control_changed), sigc::ref(train)));
  73         train.signal_function_changed.connect(sigc::bind<0>(sigc::mem_fun(this, &Server::train_function_changed), sigc::ref(train)));
  74         train.signal_ai_event.connect(sigc::bind<0>(sigc::mem_fun(this, &Server::train_ai_event), sigc::ref(train)));
  75
  76         TrainInfoPacket pkt;
  77         pkt.address = train.get_address();
  78         pkt.loco_type = layout.get_catalogue().get_name(&train.get_locomotive_type());
  79         pkt.name = train.get_name();
  80         send(pkt);
  81
  82         if(!train.get_ai_of_type<TrainStatus>())
  83                 new TrainStatus(train);
  84 }
  85
  86 void Server::train_control_changed(const Train &train, const string &control, float value)
  87 {
  88         TrainControlPacket pkt;
  89         pkt.address = train.get_address();
  90         pkt.control = control;
  91         pkt.value = value;
  92         send(pkt);
  93 }
  94
  95 void Server::train_function_changed(const Train &train, unsigned, bool)
  96 {
  97         TrainFunctionPacket pkt;
  98         pkt.address = train.get_address();
  99         pkt.functions = train.get_functions();
 100         send(pkt);
 101 }
 102
 103 void Server::train_ai_event(const Train &train, TrainAI &, const TrainAI::Message &ev)
 104 {
 105         if(ev.type=="route-changed")
 106         {
 107                 TrainRoutePacket pkt;
 108                 pkt.address = train.get_address();
 109                 if(const Route *route = ev.value.value<const Route *>())
 110                         pkt.route = route->get_name();
 111                 send(pkt);
 112         }
 113         else if(ev.type=="status-changed")
 114         {
 115                 TrainStatusPacket pkt;
 116                 pkt.address = train.get_address();
 117                 pkt.status = ev.value.value<std::string>();
 118                 send(pkt);
 119         }
 120 }
 121
 122 template<typename P>
 123 void Server::send(const P &pkt)
 124 {
 125         for(vector<Connection *>::const_iterator i=connections.begin(); i!=connections.end(); ++i)
 126                 if(!(*i)->stale && (*i)->comm.is_handshake_done())
 127                         (*i)->comm.send(pkt);
 128 }
 129
 130
 131 Server::Connection::Connection(Server &s, Net::StreamSocket *o):
 132         server(s),
 133         socket(o),
 134         comm(*socket, server.proto, *this)
 135 {
 136         socket->signal_end_of_file.connect(sigc::mem_fun(this, &Connection::end_of_file));
 137         comm.signal_handshake_done.connect(sigc::mem_fun(this, &Connection::handshake_done));
 138         comm.signal_error.connect(sigc::mem_fun(this, &Connection::comm_error));
 139         comm.initiate_handshake();
 140 }
 141
 142 Server::Connection::~Connection()
 143 {
 144         delete socket;
 145 }
 146
 147 void Server::Connection::handshake_done()
 148 {
 149         {
 150                 DriverStatePacket pkt;
 151                 pkt.power = server.layout.get_driver().get_power();
 152                 pkt.halt = server.layout.get_driver().is_halted();
 153                 comm.send(pkt);
 154         }
 155
 156         const set<Route *> &routes = server.layout.get_all<Route>();
 157         for(set<Route *>::const_iterator i=routes.begin(); i!=routes.end(); ++i)
 158                 if(!(*i)->is_temporary())
 159                 {
 160                         RouteInfoPacket pkt;
 161                         pkt.name = (*i)->get_name();
 162                         comm.send(pkt);
 163                 }
 164
 165         const Catalogue &cat = server.layout.get_catalogue();
 166         const map<unsigned, Train *> &trains = server.layout.get_trains();
 167         for(map<unsigned, Train *>::const_iterator i=trains.begin(); i!=trains.end(); ++i)
 168         {
 169                 const Train &train = *i->second;
 170
 171                 {
 172                         TrainInfoPacket pkt;
 173                         pkt.address = train.get_address();
 174                         pkt.loco_type = cat.get_name(&train.get_locomotive_type());
 175                         pkt.name = train.get_name();
 176                         comm.send(pkt);
 177                 }
 178                 for(unsigned j=0;; ++j)
 179                 {
 180                         const char *name = train.get_controller().enumerate_controls(j);
 181                         if(!name)
 182                                 break;
 183
 184                         TrainControlPacket pkt;
 185                         pkt.address = train.get_address();
 186                         pkt.control = name;
 187                         pkt.value = train.get_control(name);
 188                         comm.send(pkt);
 189                 }
 190                 {
 191                         TrainFunctionPacket pkt;
 192                         pkt.address = train.get_address();
 193                         pkt.functions = train.get_functions();
 194                         comm.send(pkt);
 195                 }
 196                 if(TrainStatus *status = train.get_ai_of_type<TrainStatus>())
 197                 {
 198                         TrainStatusPacket pkt;
 199                         pkt.address = train.get_address();
 200                         pkt.status = status->get_status();
 201                         comm.send(pkt);
 202                 }
 203                 if(TrainRouter *router = train.get_ai_of_type<TrainRouter>())
 204                 {
 205                         TrainRoutePacket pkt;
 206                         pkt.address = train.get_address();
 207                         pkt.route = router->get_route()->get_name();
 208                         comm.send(pkt);
 209                 }
 210         }
 211 }
 212
 213 void Server::Connection::end_of_file()
 214 {
 215         stale = true;
 216 }
 217
 218 void Server::Connection::receive(const DriverStatePacket &pkt)
 219 {
 220         Driver &driver = server.layout.get_driver();
 221         if(pkt.power!=driver.get_power())
 222                 driver.set_power(pkt.power);
 223         if(pkt.halt!=driver.is_halted())
 224                 driver.halt(pkt.halt);
 225 }
 226
 227 void Server::Connection::receive(const TrainControlPacket &pkt)
 228 {
 229         try
 230         {
 231                 Train &train = server.layout.get_train(pkt.address);
 232                 train.set_control(pkt.control, pkt.value);
 233         }
 234         catch(const exception &e)
 235         {
 236                 error(e.what());
 237         }
 238 }
 239
 240 void Server::Connection::receive(const TrainFunctionPacket &pkt)
 241 {
 242         try
 243         {
 244                 Train &train = server.layout.get_train(pkt.address);
 245                 for(unsigned i=0; i<9; ++i)
 246                         if(((pkt.functions^train.get_functions())>>i)&1)
 247                                 train.set_function(i, (pkt.functions>>i)&1);
 248         }
 249         catch(const exception &e)
 250         {
 251                 error(e.what());
 252         }
 253 }
 254
 255 void Server::Connection::receive(const TrainRoutePacket &pkt)
 256 {
 257         try
 258         {
 259                 Train &train = server.layout.get_train(pkt.address);
 260                 if(pkt.route.empty())
 261                         train.ai_message(TrainAI::Message("clear-route"));
 262                 else
 263                 {
 264                         Route &route = server.layout.get_route(pkt.route);
 265                         train.ai_message(TrainAI::Message("set-route", &route));
 266                 }
 267         }
 268         catch(const exception &e)
 269         {
 270                 error(e.what());
 271         }
 272 }
 273
 274 void Server::Connection::comm_error(const exception &)
 275 {
 276         stale = true;
 277 }
 278
 279 void Server::Connection::error(const string &msg)
 280 {
 281         ErrorPacket pkt;
 282         pkt.message = msg;
 283         comm.send(pkt);
 284 }
 285
 286 } // namespace R2C2