Se agrega un try para tratar de solucionar situaciones en las que el server

[z.facultad/75.42/plaqui.git] / Server / src / plant.cpp

diff --git a/Server/src/plant.cpp b/Server/src/plant.cpp
index ce9f737d19822eba5ba4dac9d74875f36a9c8a64..f3a0a98c2962c846955440429b982463a76b90c7 100644 (file)
--- a/Server/src/plant.cpp
+++ b/Server/src/plant.cpp
@@ -27,7 +27,7 @@
 
 #include "plaqui/server/plant.h"
 #include <glibmm/timer.h>
-#include <sigc++/slot.h>
+#include <sigc++/class_slot.h>
 #include <fstream>
 #ifdef DEBUG
 #      include <iostream>
@@ -44,49 +44,56 @@ Plant::~Plant(void) {
        cerr << __FILE__ << "(" << __LINE__ << ")"
                << ": destructor." << endl;
 #endif // DEBUG
-       // Termino transmisiones.
-       Glib::Mutex::Lock lock(transmissions_mutex);
-       for (TransmitterList::iterator trans = transmissions.end();
+       // Mando a terminar todas las transmisiones.
+       transmissions_mutex.lock();
+       for (TransmitterList::iterator trans = transmissions.begin();
                        trans != transmissions.end(); trans++) {
-               (*trans)->finish(true);
+               (*trans)->finish();
+       }
+       TransmitterList::size_type count = transmissions.size();
+       transmissions_mutex.unlock();
+       // Espero que terminen realmente.
+       while (count) {
+               Glib::usleep(10000); // 10 milisegundos
+               transmissions_mutex.lock();
+               count = transmissions.size();
+               transmissions_mutex.unlock();
        }
 }
 
-Plant::Plant(const string& filename): simulator(filename), filename(filename) {
+Plant::Plant(const string& filename): simulator(filename), filename(filename),
+               wait_time(DEFAULT_WAIT_TIME), paused(true) {
 #ifdef DEBUG
        cerr << __FILE__ << "(" << __LINE__ << ")"
                << ": constructor. filename = " << filename << endl;
 #endif // DEBUG
-       // TODO plant
-/*     simulator.add_pump("bomba1");
-       simulator.add_conduct("c");
-       simulator.add_conduct("c1");
-       simulator.add_drainage("d");
-       simulator.add_tank("tanque");
-       
-       simulator.connect("bomba1", "c", Model::IConector::OUT);
-       simulator.connect("c", "tanque", Model::IConector::OUT);
-       simulator.connect("tanque", "c1", Model::IConector::OUT);
-       simulator.connect("c1", "d", Model::IConector::OUT);
-*/     
 }
 
-void Plant::real_run(void) {
+void Plant::real_run(void) throw() {
 #ifdef DEBUG
        cerr << __FILE__ << "(" << __LINE__ << ")"
                << ": real_run." << endl;
 #endif // DEBUG
-       while (!stop) {
-               simulator_mutex.lock();
-               simulator.simulate();
-               simulator_mutex.unlock();
-               transmissions_mutex.lock();
-               for (TransmitterList::iterator i = transmissions.begin();
-                               i != transmissions.end(); i++) {
-                       (*i)->send(simulator.get_state_as_xml());
+       unsigned wait;
+       while (!stop()) {
+               if (paused) { // Si está pausada, espera un tiempo sin simular.
+                       Glib::usleep(DEFAULT_WAIT_TIME);
+               } else { // Si está andando, simula y manda estado.
+                       simulator_mutex.lock();
+                       simulator.simulate();
+                       string plantstatus = simulator.get_state_as_xml();
+                       simulator_mutex.unlock();
+                       transmissions_mutex.lock();
+                       for (TransmitterList::iterator i = transmissions.begin();
+                                       i != transmissions.end(); i++) {
+                               (*i)->send(plantstatus);
+                       }
+                       transmissions_mutex.unlock();
+                       wait_time_mutex.lock();
+                       wait = wait_time;
+                       wait_time_mutex.unlock();
+                       Glib::usleep(wait);
                }
-               transmissions_mutex.unlock();
-               Glib::usleep(1000000);
        }
 }
 
@@ -111,24 +118,18 @@ bool Plant::transmission_start(string& host, Connection::Port& port) {
        Transmitter* trans;
        try {
                trans = new Transmitter(host, port);
-       } catch (const sockerr& e) { // TODO - Hace mas selectivo el catch?
+       } catch (const sockerr& e) {
 #ifdef DEBUG
                cerr << __FILE__ << "(" << __LINE__ << ")"
                        << ": transmission_start ERROR (" << e.serrno()
                        << "): " << e.errstr() << endl;
 #endif // DEBUG
-               //delete trans;
                return false;
-//     } catch (...) { // TODO - Hace mas selectivo el catch?
-//#ifdef DEBUG
-//             cerr << __FILE__ << "(" << __LINE__ << ")"
-//                     << ": transmission_start ERROR: desconocido."
-//                     << endl;
-//#endif // DEBUG
-//             //delete trans;
-//             return false;
        }
        transmissions.push_back(trans);
+       trans->signal_finished().connect(SigC::bind(
+                               SigC::slot_class(*this, &Plant::on_transmission_finished),
+                               trans));
        trans->run();
        host = trans->get_host();
        port = trans->get_port();
@@ -138,9 +139,9 @@ bool Plant::transmission_start(string& host, Connection::Port& port) {
 bool Plant::transmission_stop(const string& host,
                const Connection::Port& port) {
 #ifdef DEBUG
-               cerr << __FILE__ << "(" << __LINE__ << ")"
-                       << ": transmission_stop(host = " << host <<
-                       ", port = " << port << ")." << endl;
+       cerr << __FILE__ << "(" << __LINE__ << ")"
+               << ": transmission_stop(host = " << host <<
+               ", port = " << port << ")." << endl;
 #endif // DEBUG
        Glib::Mutex::Lock lock(transmissions_mutex);
        for (TransmitterList::iterator i = transmissions.begin();
@@ -153,7 +154,7 @@ bool Plant::transmission_stop(const string& host,
        return false; // No la encontró.
 }
 
-bool Plant::on_transmission_finished(Transmitter* transmission) {
+void Plant::on_transmission_finished(Transmitter* transmission) {
 #ifdef DEBUG
        cerr << __FILE__ << "(" << __LINE__ << ")"
                <<  ": on_transmission_finished(transmission = "
@@ -188,32 +189,22 @@ const string Plant::get_xml(void) const {
 #endif // DEBUG
        ostringstream oss;
        ifstream ifs(filename.c_str());
+       // FIXME Saco la línea de definición de XML (<?xml ?>), ver si esta hecho muy
+       // feo.
+       ifs.ignore(50, '\n'); // Ignora 50 caracteres o hasta un enter.
        ifs >> oss.rdbuf();
        return oss.str();
 }
 
-/*
-bool Plant::transmission_exists(const string& host,
-               const Connection::Port& port) {
-       Glib::Mutex::Lock lock(transmissions_mutex);
-       for (TransmitterList::const_iterator i = transmissions.begin();
-                       i != transmissions.end(); i++) {
-               if (((*i)->get_host() == host) && ((*i)->get_oprt() == port)) {
-                       return true;
-               }
-       }
-       return false; // No la encontró.
+void Plant::set_frequency(unsigned hz) {
+       Glib::Mutex::Lock lock(wait_time_mutex);
+       wait_time = hz ? (1000000u/hz) : DEFAULT_WAIT_TIME;
 }
-*/
 
-//const std::string& Plant::get_filename(void) const {
-//     return filename;
-//}
-
-/// \todo FIXME esto deberia estar protegido por un mutex.
-//Plant::SignalUpdated& Plant::signal_updated(void) {
-//     return updated;
-//}
+void Plant::set_paused(bool paused_) {
+       Glib::Mutex::Lock lock(paused_mutex);
+       paused = paused_;
+}
 
 } // namespace Server