X-Git-Url: https://git.llucax.com/z.facultad/75.42/plaqui.git/blobdiff_plain/802f79cdb0d688127b8a639cd3173d801a1466cd..0949257d7ae221c05b1bc35f7d05528f187cc42c:/Server/src/controlclient.cpp?ds=sidebyside diff --git a/Server/src/controlclient.cpp b/Server/src/controlclient.cpp index 7138b44..e4293ae 100644 --- a/Server/src/controlclient.cpp +++ b/Server/src/controlclient.cpp @@ -25,26 +25,136 @@ // $Id$ // +#include "plaqui/server/response.h" #include "plaqui/server/controlclient.h" -// XXX -#include +#include +#include +#ifdef DEBUG +# include +#endif // DEBUG -using namespace PlaQui::Server; +using namespace std; -ControlClient::ControlClient(std::string host, int port): - Connection(sockbuf::sock_stream) { - // FIXME - poner en run(). +namespace PlaQui { + +namespace Server { + +ControlClient::~ControlClient(void) { +#ifdef DEBUG + cerr << __FILE__ << "(" << __LINE__ << ")" + << ": destructor." << endl; +#endif // DEBUG + // FIXME Temporal: espero que el receiver muera. + if (receiver) { + receiver->finish(); + } + while (receiver) { + Glib::usleep(100000); // 0,1 segundo + } +} + +ControlClient::ControlClient(const string& _host, + const Connection::Port& _port) throw(sockerr): + Connection(sockbuf::sock_stream, _host, _port) { socket->connect(host.c_str(), port); + host = socket->localhost(); + port = socket->localport(); +#ifdef DEBUG + cerr << __FILE__ << "(" << __LINE__ << ")" + << ": host = " << host + << " | port = " << port << endl; +#endif // DEBUG + // FIXME temporal + receiver = new Receiver(7528, host); + receiver->signal_finished().connect(SigC::slot_class(*this, + &ControlClient::on_receiver_finished)); + receiver->signal_error().connect(SigC::slot_class(*this, + &ControlClient::on_receiver_error)); } -void ControlClient::real_run(void) { - // FIXME - debería tirar una excepción? - if (!socket->is_open()) { - std::cerr << "No se pudo conectar a " << socket->peerhost() << - ":" << socket->peerport() << "." << std::endl; - } else { - std::cerr << "Conectado a " << socket->peerhost() << - ":" << socket->peerport() << "." << std::endl; +void ControlClient::real_run(void) throw() { +#ifdef DEBUG + cerr << __FILE__ << "(" << __LINE__ << ")" + << ": real_run." << endl; + cerr << ": REAL | host = " << host + << " | port = " << port << endl; +#endif // DEBUG + // TODO Temporal: el receiver empieza a escuchar. + receiver->run(); + while (!stop()) { + Response response; + try { + socket >> response; + // Si se cerró el socket. + } catch (const ios::failure& e) { + // FIXME poner buenos codigos de error. + signal_error().emit(1000000, "Se desconectó."); + return; + } catch (const sockerr& e) { + signal_error().emit(e.serrno(), e.errstr()); + return; + } catch (const xmlpp::parse_error& e) { + signal_error().emit(100001, e.what()); + continue; + // Si hay un error al parsear la respuesta. + } catch (const HTTPResponse::Error& e) { +#ifdef DEBUG + cerr << __FILE__ << "(" << __LINE__ << ")" + << " : real_run() ERROR nro: " << e << endl; +#endif // DEBUG + signal_error().emit(e, "La respuesta recibida es inválida"); + continue; + } + switch (response.get_code()) { + case Response::OK: + ok_received(response.get_contents()); + break; + default: + error_received(response.get_code(), response.get_description()); + break; + } } } +void ControlClient::send(const Command& command) { + try { + socket << command << flush; + } catch (const sockerr& e) { + signal_error().emit(e.serrno(), e.errstr()); + finish(); + } +#ifdef DEBUG + cerr << __FILE__ << "(" << __LINE__ << ")" + << ": send() Enviado!" << endl; +#endif // DEBUG +} + +void ControlClient::on_receiver_finished(void) { + receiver = NULL; +} + +void ControlClient::on_receiver_error(const Runnable::Error& code, + const string& desc) { + signal_error().emit(code, string("Receiver Error: ") + desc); +} + +ControlClient::SignalOKReceived& ControlClient::signal_ok_received(void) { + return ok_received; +} + +ControlClient::SignalErrorReceived& ControlClient::signal_error_received(void) { + return error_received; +} + +// TODO - temporal +ControlClient::SignalFrameReceived& ControlClient::signal_frame_received(void) { + // XXX - cuidado, esto puede dar quilombo si no esta protegido por un mutex, + // aunque no deberia porque la señal no es llamada hasta que no se empice + // la transmision y la señal se conecta antes de pedir la transmision. + return receiver->signal_frame_received(); +} + +} // namespace Server + +} // namespace PlaQui +