X-Git-Url: https://git.llucax.com/z.facultad/75.42/plaqui.git/blobdiff_plain/ab9300aaf1217f0c3b45dd5f1f1fdc1c5e5bd1be..dafb509182bac9b314202fe7dfaf58206da5ccbe:/Server/src/server.cpp?ds=sidebyside diff --git a/Server/src/server.cpp b/Server/src/server.cpp index 134bcf5..5e7197a 100644 --- a/Server/src/server.cpp +++ b/Server/src/server.cpp @@ -26,65 +26,429 @@ // #include "plaqui/server/server.h" +#include "plaqui/server/string.h" #include "plaqui/server/connection.h" #include "plaqui/server/controlserver.h" #include +#include +#include +#include #ifdef DEBUG # include #endif // DEBUG -PlaQui::Server::Server::~Server(void) { -#ifdef DEBUG - std::cerr << __FILE__ << ": destructor." << std::endl; -#endif // DEBUG -} +using namespace std; + +namespace PlaQui { + +namespace Server { -PlaQui::Server::Server::Server(int port): - TCPServer(port) { +Server::~Server(void) { #ifdef DEBUG - std::cerr << __FILE__ << ": port = " << port << std::endl; + cerr << __FILE__ << "(" << __LINE__ << ")" + << ": destructor." << endl; #endif // DEBUG + // Mando a terminar todas las plantas. + plants_mutex.lock(); + for (PlantList::iterator i = plants.begin(); i != plants.end(); i++) { + i->second->finish(); + } + PlantList::size_type count = plants.size(); + plants_mutex.unlock(); + // Espero que terminen realmente. + while (count) { + Glib::usleep(10000); // 10 milisegundos + plants_mutex.lock(); + count = plants.size(); + plants_mutex.unlock(); + } } -/// \todo Implementar. -bool PlaQui::Server::Server::start_transmission(std::string host, int port) { +Server::Server(const string& plant_filename, const Connection::Port& port) + throw(sockerr): TCPServer(port) { #ifdef DEBUG - std::cerr << __FILE__ << ": start_transmission(host = " << host - << " | port = " << port << ")" << std::endl; + cerr << __FILE__ << "(" << __LINE__ << ")" + << ": port = " << port << endl; #endif // DEBUG - // TODO - return false; + // FIXME - hacer que se puedan cargar mas plantas bien. + Glib::Mutex::Lock lock(plants_mutex); + plants["default"] = new Plant(plant_filename); + plants["default"]->signal_finished().connect(SigC::bind( + SigC::slot_class(*this, &Server::on_plant_finished), + "default")); + plants["default"]->run(); } - -PlaQui::Server::Connection* PlaQui::Server::Server::new_connection( - const sockbuf::sockdesc& sd) { + +Connection* Server::new_connection(const sockbuf::sockdesc& sd) { #ifdef DEBUG - std::cerr << __FILE__ << ": new_connection(sd = " << sd.sock << ")" - << std::endl; + cerr << __FILE__ << "(" << __LINE__ << ")" + << ": new_connection(sd = " << sd.sock << ")" + << endl; #endif // DEBUG ControlServer* connection = new ControlServer(sd); // TODO verificar si el new se hace bien? no creo. - connection->signal_command_received().connect( - SigC::slot_class(*this, &Server::on_control_command_received)); + connection->signal_command_received().connect(SigC::bind( + SigC::slot_class(*this, &Server::on_control_command_received), + connection)); // TODO: return connection; } -/// \todo Implementar. -bool PlaQui::Server::Server::stop_transmission(std::string host, int port) { +void Server::on_plant_finished(const char* plant) { #ifdef DEBUG - std::cerr << __FILE__ << ": stop_transmission(host = " << host - << " | port = " << port << ")" << std::endl; + cerr << __FILE__ << "(" << __LINE__ << ")" + << ": on_plant_finished(plant_name = " << plant << endl; #endif // DEBUG - // TODO - return false; + Glib::Mutex::Lock lock(plants_mutex); + plants.erase(plant); } -/// \todo Implementar. -void PlaQui::Server::Server::on_control_command_received(void* command) { +/// \todo Terminar de implementar. +void Server::on_control_command_received(const Command& command, + ControlServer* controlserver) { #ifdef DEBUG - std::cerr << __FILE__ << ": on_control_command_received(command = " - << command << ")" << std::endl; + cerr << __FILE__ << "(" << __LINE__ << ")" + << ": on_control_command_received(target = " + << command.get_target() << ", command = " << command.get_command() + << ", args = [" << String::join(command.get_args(), ", ") << "])" + << endl; #endif // DEBUG + Response* response; + if (command.get_target() == "server") { + if (command.get_command() == "info") { + response = cmd_server_info(); + } else if (command.get_command() == "stop") { + response = new Response(Response::OK, + "El server se cerrará en instantes"); + // XXX - Sin mandar la respuesta enseguida podría ser que el server + // cierre la conexión antes de mandar la respuesta. + //response->headers["Content-Type"] = "text/xml; charset=iso-8859-1"; + //controlserver->send(*response); + //delete response; + finish(); + //return; + } else { + response = new Response(Response::INVALID_COMMAND, + command.get_command() + " es un comando inválido para " + + "el destino 'server'"); + } + } else if (command.get_target() == "connection") { + if (command.get_command() == "list") { + response = cmd_connection_list(); + } else if (command.get_command() == "stop") { + response = cmd_connection_stop(command); + } else { + response = new Response(Response::INVALID_COMMAND, + command.get_command() + " es un comando inválido para " + + "el destino 'connection'"); + } + } else if (command.get_target() == "transmission") { + if (command.get_command() == "list") { + response = cmd_transmission_list(); + } else if (command.get_command() == "start") { + response = cmd_transmission_start(command); + } else if (command.get_command() == "stop") { + response = cmd_transmission_stop(command); + } else { + response = new Response(Response::INVALID_COMMAND, + command.get_command() + " es un comando inválido para " + + "el destino 'transmission'"); + } + } else if (command.get_target() == "plant") { + if (command.get_command() == "list") { + response = cmd_plant_list(); + } else if (command.get_command() == "get") { + response = cmd_plant_get(command); + } else if (command.get_command() == "set") { + response = cmd_plant_set(command); + } else if (command.get_command() == "set_frequency") { + response = cmd_plant_set_frequency(command); + } else if (command.get_command() == "start") { + response = cmd_plant_start(command); + } else if (command.get_command() == "stop") { + response = cmd_plant_stop(command); + } else if (command.get_command() == "remove") { + response = cmd_plant_remove(command); + } else { + response = new Response(Response::INVALID_COMMAND, + command.get_command() + " es un comando inválido para " + + "el destino 'plant'"); + } + } else { + response = new Response(Response::INVALID_TARGET, command.get_target() + + " es un destino inválido"); + } + // FIXME + //response->headers["Connection"] = "close"; + controlserver->send(*response); + delete response; + // FIXME con timeout no debería ser necesario. Verificar cabecera Connection + // para saber si hay que finish()earlo o no. + //if (stop_controlserver) { + // controlserver->finish(); + //} +} + +Response* Server::cmd_server_info(void) const { + // FIXME + stringstream xml; + xml << "" << endl; + xml << "\t" VERSION "" << endl; + xml << "\t" << endl; + xml << "\t\tNicolás Dimov" << endl; + xml << "\t\tLeandro Lucarella" << endl; + xml << "\t\tRicardo Markiewicz" << endl; + xml << "\t" << endl; + xml << "" << endl; + return new Response(xml.str()); +} + +Response* Server::cmd_connection_list(void) { + // FIXME + TCPServer::ConnectionInfoList cil = get_connected(); + stringstream xml; + xml << "" << endl; + for (TCPServer::ConnectionInfoList::const_iterator i = cil.begin(); + i != cil.end(); i++) { + xml << "\t" << endl; + xml << "\t\t" << i->host << "" << endl; + xml << "\t\t" << i->port << "" << endl; + xml << "\t" << endl; + } + xml << "" << endl; + return new Response(xml.str()); +} + +Response* Server::cmd_connection_stop(const Command& command) { + const Command::Arguments& args = command.get_args(); + Connection::Port port; + if (args.size() < 2) { + return new Response(Response::ARGUMENT_MISSING, "Faltan argumentos " + " para el comando 'stop' del destino 'connection'"); + } else if (disconnect(args[0], to(args[1], port))) { + return new Response(Response::OK, string("La conexión a ") + args[0] + + ":" + args[1] + " se cerrará en instantes"); + } else { + return new Response(Response::CONNECTION_NOT_FOUND, + string("No existe una conexión a ") + args[0] + ":" + args[1]); + } +} + +Response* Server::cmd_transmission_list(void) { + // FIXME + stringstream xml; + xml << "" << endl; +/*TODO plants_mutex.lock(); + for (PlantList::const_iterator i = plants.begin(); + i != plants.end(); i++) { + trans + xml << "
  • " << (*i)->get_host() << ":" + << (*i)->get_port() << " [get_host() << "/" << (*i)->get_port() + << "\">desconectar]
    • " << endl; + } + transmissions_mutex.unlock();*/ + xml << "    " << endl; + return new Response(xml.str()); +} + +Response* Server::cmd_transmission_start(const Command& command) { + const Command::Arguments& args = command.get_args(); + if (args.size() < 3) { + return new Response(Response::ARGUMENT_MISSING, "Faltan argumentos " + " para el comando 'start' del destino 'transmission'"); + } else { + string plant = args[0]; + string host = args[1]; + Connection::Port port = to(args[2], port); + Glib::Mutex::Lock lock(plants_mutex); + PlantList::iterator p = plants.find(plant); + if (p == plants.end()) { + return new Response(Response::PLANT_NOT_FOUND, + string("No existe la planta '") + plant + "'"); + // FIXME - agregar chequeo de que la transmision a ese host:port no exista. + // que use respuesta ALLREADY_EXISTS + } else if (plants[plant]->transmission_start(host, port)) { + return new Response(Response::OK, + string("Se empieza a transmitir la planta '") + plant + + "' a " + host + ":" + String().from(port)); + } else { + return new Response(Response::ERROR_STARTING_TRANSMISSION, + string("Error al crear la transmisión a de la planta '") + + plant + "' a " + host + ":" + args[2]); + } + } +} + +Response* Server::cmd_transmission_stop(const Command& command) { + const Command::Arguments& args = command.get_args(); + if (args.size() < 2) { + return new Response(Response::ARGUMENT_MISSING, "Faltan argumentos " + " para el comando 'stop' del destino 'transmission'"); + } else { + const string& host = args[0]; + Connection::Port port = to(args[1], port); + for (PlantList::iterator i = plants.begin(); i != plants.end(); i++) { + // TODO - agregar chequeo para saber si existe una conexion (para + // tirar error de que no hay conexion o de que no se pudo + // desconectar. + if (i->second->transmission_stop(host, port)) { + return new Response(Response::OK, + string("La transmisión de la planta '") + i->first + + "' a " + host + ":" + args[1] + + " se cerrará en instantes"); + } + } + return new Response(Response::TRANSMISSION_NOT_FOUND, + string("No existe una transmisión a ") + host + ":" + args[1]); + } +} + +Response* Server::cmd_plant_list(void) { + // FIXME hacer con ResponseList + stringstream xml; + xml << "" << endl; + plants_mutex.lock(); + for (PlantList::const_iterator i = plants.begin(); + i != plants.end(); i++) { + xml << "\t" << endl; + xml << "\t\t" << i->first << "" << endl; + xml << "\t" << endl; + } + plants_mutex.unlock(); + xml << "" << endl; + return new Response(xml.str()); +} + +Response* Server::cmd_plant_get(const Command& command) { + if (!command.get_args().size()) { + return new Response(Response::ARGUMENT_MISSING, "Faltan argumentos " + " para el comando 'get' del destino 'plant'"); + } + Glib::Mutex::Lock lock(plants_mutex); + string plant = command.get_args()[0]; + if (plants.find(plant) == plants.end()) { + return new Response(Response::PLANT_NOT_FOUND, + string("No existe la planta '") + plant + "'"); + } + // TODO try/catch? + string xml = plants[plant]->get_xml(); + if (xml.length()) { + return new Response(xml); + } else { + return new Response(Response::ERROR_GETING_PLANT_XML, + ("No se pudo obtener el XML de la planta '") + plant + "'"); + } +} + +Response* Server::cmd_plant_set(const Command& command) { + const Command::Arguments& args = command.get_args(); + if (args.size() < 4) { + return new Response(Response::ARGUMENT_MISSING, "Faltan argumentos " + " para el comando 'set' del destino 'plant'"); + } + string plant = args[0]; + string element = args[1]; + string input = args[2]; + if (input != "open") { + return new Response(Response::ELEMENT_INPUT_NOT_FOUND, + string("El elemento '") + element + "' de la planta '" + plant + + "' no tiene una entrada '" + input + "'"); + } + string value = args[3]; + Glib::Mutex::Lock lock(plants_mutex); + PlantList::iterator p = plants.find(plant); + if (p == plants.end()) { + return new Response(Response::PLANT_NOT_FOUND, + string("No existe la planta '") + plant + "'"); + } + bool open = true; + if ((value == "false") || (value == "0") || (value == "off") + || (value == "no")) { + open = false; + } + if (!plants[plant]->set_open(element, open)) { + return new Response(Response::ERROR_CHANGING_ELEMENT_INPUT, + string("No se pudo cambiar la entrada '") + input + + "' del elemento '" + element + "' de la planta '" + + plant + "'"); + } + return new Response(Response::OK, + string("Se cambió la entrada '") + input + "' del elemento '" + + element + "' de la planta '" + plant + "' a '" + value + "'"); +} + +Response* Server::cmd_plant_set_frequency(const Command& command) { + if (command.get_args().size() < 2) { + return new Response(Response::ARGUMENT_MISSING, "Faltan argumentos " + " para el comando 'set_frequency' del destino 'plant'"); + } + Glib::Mutex::Lock lock(plants_mutex); + const string name = command.get_args()[0]; + if (plants.find(name) == plants.end()) { + return new Response(Response::PLANT_NOT_FOUND, + string("No existe la planta '") + name + "'"); + } + unsigned hz; + to(command.get_args()[1], hz); + /* TODO poner cantidad real que tomó: hz = */plants[name]->set_frequency(hz); + String shz; + shz.from(hz); + return new Response(Response::OK, + string("Se cambió la frecuencia de refresco de la planta '") + name + + "' a '" + shz + "' veces por segundo"); } +Response* Server::cmd_plant_start(const Command& command) { + if (!command.get_args().size()) { + return new Response(Response::ARGUMENT_MISSING, "Faltan argumentos " + " para el comando 'start' del destino 'plant'"); + } + Glib::Mutex::Lock lock(plants_mutex); + const string name = command.get_args()[0]; + if (plants.find(name) == plants.end()) { + return new Response(Response::PLANT_NOT_FOUND, + string("No existe la planta '") + name + "'"); + } + plants[name]->set_paused(false); + return new Response(Response::OK, + string("La planta '") + name + "' fue reanudada"); +} + +Response* Server::cmd_plant_stop(const Command& command) { + if (!command.get_args().size()) { + return new Response(Response::ARGUMENT_MISSING, "Faltan argumentos " + " para el comando 'stop' del destino 'plant'"); + } + Glib::Mutex::Lock lock(plants_mutex); + const string name = command.get_args()[0]; + if (plants.find(name) == plants.end()) { + return new Response(Response::PLANT_NOT_FOUND, + string("No existe la planta '") + name + "'"); + } + plants[name]->set_paused(true); + return new Response(Response::OK, + string("La planta '") + name + "' fue pausada"); +} + +Response* Server::cmd_plant_remove(const Command& command) { + if (!command.get_args().size()) { + return new Response(Response::ARGUMENT_MISSING, "Faltan argumentos " + " para el comando 'remove' del destino 'plant'"); + } + Glib::Mutex::Lock lock(plants_mutex); + const string name = command.get_args()[0]; + if (plants.find(name) == plants.end()) { + return new Response(Response::PLANT_NOT_FOUND, + string("No existe la planta '") + name + "'"); + } + plants[name]->finish(); + return new Response(Response::OK, + string("La planta '") + name + "' fue será removida del servidor " + "en instantes"); +} + +} // namespace Server + +} // namespace PlaQui +