lliendo/Radar

#
msgid ""
msgstr ""
"Project-Id-Version: Radar 0.0.1b\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2015-09-11 17:19-0300\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: LANGUAGE <LL@li.org>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"

#: ../../internals.rst:2
msgid "Radar internals"
msgstr "Funcionamiento interno"

#: ../../internals.rst:4
msgid ""
"Radar has been carefully designed to its keep base code clean and "
"understandable, so everyone can take a look at its internals (and hopefully "
"play with the code)."
msgstr ""
"Radar ha sido cuidadosamente diseñado para mantener su código prolijo y "
"entendible, para que cualquiera pueda echar un vistazo a su funcionamiento. "

#: ../../internals.rst:8
msgid ""
"This section of the documentation tries to expose the main ideas that were "
"implemented to make this project possible. We'll not describe every single "
"detail because that would take a huge amount of time and you'll get bored. "
"Instead I've decided to describe few things as possible and try to reflect "
"why a decision was taken that way. Also consider that like everybody else, I"
" make mistakes and no perfect software design exists and Radar is a long way"
" from achieving that."
msgstr ""
"Esta sección de la documentación intenta exponer las ideas principales que "
"se utilizaron para que este proyecto sea posible. No describiremos cada "
"detalle particular porque esto demandaría bastante tiempo y posiblemente te "
"aburras. He decidido describir la menor cantidad de cosas posibles e "
"intentar explicar porque cierta decisión ha sido tomada en lugar de otra. "
"Considera también que como cualquier otra persona cometo errores y los "
"diseños de software perfectos no existen y Radar esta muy muy lejos de "
"alcanzar esto."

#: ../../internals.rst:18
msgid "Overview"
msgstr "Introducción"

#: ../../internals.rst:20
msgid ""
"Radar is designed to be a small tool, its core isn't intended to grow "
"indefinitely besides some currently lacking features. The reason behind this"
" is that a tool that is small and controlled in its size and its objectives "
"is easier to understand and does its work better than an all-problem-solving"
" solution. This also has a downside : a small tool may not offer advanced or"
" complex features. Radar's main goal is to be a simple and easy to use tool "
"hence the reason why you might not find as many features as other solutions "
"may offer."
msgstr ""
"Radar ha sido diseñado para ser una herramienta pequeña, su núcleo no esta "
"pensado para crecer indefinidamente dejando de lado algunas características "
"que actualmente no estan disponibles. La razón detrás de esto es que una "
"herramienta pequeña y controlada en su tamaño y objetivos es más fácil de "
"entender y concreta mejor sus objetivos que una super-solución que lo "
"intenta resolver todo. Esto también tiene una desventaja : una herramienta "
"pequeña puede no ofrecer características avanzadas o complejas. El objetivo "
"principal de Radar es que sea un software de monitoreo simple y sencillo de "
"utilizar, de ahi la razón por la cual podrías no encontrar todas las "
"características que otras soluciones similares ofrecen."

#: ../../internals.rst:29
msgid ""
"Radar makes use of object oriented programming, every component is modeled "
"using a class. Some few classes make use of mixins and all errors are "
"handled through exceptions. Radar also makes heavy use of list "
"comprehensions across the project."
msgstr ""
"Radar hace uso de programación orientada a objetos, cada componente esta "
"modelado mediante una clase. Algunas clases hacen uso de mixins y todos los "
"errores son manejados mediante excepciones. Radar también hace uso intensivo"
" de listas por comprensión a lo largo de todo el proyecto."

#: ../../internals.rst:34
msgid ""
"If you take a fast look to the code you'll realize that almost every method "
"is only a few lines long. Every class is intended to perform a specific task"
" and each method solves a concrete piece of that task. The result is that "
"you won't find complex or twisted code and reading any piece of code and get"
" the idea of what is doing should take little time. The code mostly lacks "
"comments, the reason for this is that the code intends to be self-describing"
" (care has been taken to make classes and methods describe and reflect their"
" intentions). Radar tries to stick to this rule."
msgstr ""
"Si echas un vistazo al código te darás cuenta de que casi todo método posee "
"solamente unas pocas líneas de código. Cada clase esta diseñada para "
"resolver una tarea en particular y cada método resuelve una parte concreta "
"de dicha tarea. Esto hace que no encuentres código complejo o rebuscado y "
"comprender la idea de un fragmento de código debería llevar poco tiempo. La "
"gran mayoría del código carece de comentarios, la razón de esto es que el "
"código intenta auto-describirse (se tomaron ciertos cuidados para que las "
"clases y métodos describan y reflejen sus intenciones). Radar intenta "
"ajustarse a esta regla."

#: ../../internals.rst:46
msgid "Project layout"
msgstr "Organización del proyecto"

#: ../../internals.rst:48
msgid "Radar has the following project structure :"
msgstr "Radar posee la siguiente estructura :"

#: ../../internals.rst:102
msgid "Initialization"
msgstr "Inicialización"

#: ../../internals.rst:104
msgid ""
"Both Radar client and server go through almost the same steps before going "
"into operational mode. When Radar (client or server) is fired up it "
"instantiates a launcher (RadarClientLauncher for the client and "
"RadarServerLauncher for the server) and immediately calls its run() method."
msgstr ""
"Tanto el servidor como cliente de Radar pasan casi por los mismos pasos "
"antes de entrar en modo operacional. Cuando Radar (cliente o servidor) es "
"arrancado instancia un lanzador (RadarClientLauncher en el cliente y "
"RadarServerLauncher en el servidor) e inmediatamente invoca al método run()."

#: ../../internals.rst:109
msgid "From that point a three phase initialization takes place :"
msgstr ""
"De ahí en adelante una fase de inicializacion de tres etapas toma lugar :"

#: ../../internals.rst:111
msgid ""
"First the command line is processed. This is done in the RadarLauncher "
"class. After this, objects and configurations are read from the main "
"configuration file and alternate files in the case of the server are parsed "
"and processed."
msgstr ""
"En primer lugar la línea de comandos en procesada. Esto se realiza en la "
"clase RadarLauncher. Luego de esto, otras configuraciones son procesadas y "
"varios objetos son creados (en el caso del servidor). "

#: ../../internals.rst:115
msgid "Client and server proceed to define, create and configure threads."
msgstr ""
"Tanto el cliente como el servidor definen, crean y configuran algunos "
"threads."

#: ../../internals.rst:116
msgid "Finally threads are launched."
msgstr "Se ejecutan cada uno de los threads."

#: ../../internals.rst:118
msgid ""
"After all threads are successfully launched client and server break away and"
" start performing completely different tasks."
msgstr ""
"Una vez que se han ejecutado los threads, cliente y servidor dejan de tener "
"similitud y comienzan a realizar tareas completamente distintas."

#: ../../internals.rst:123
msgid "Operational overview"
msgstr "Funcionamiento general"

#: ../../internals.rst:125
msgid ""
"Both Radar client and server operate in an event triggered fashion and make "
"use of threads to distribute the workload. If you look at the code of the "
"RadarServer and RadarClient classes you'll find methods called "
"'on_something'. Every time a network event occurs it is reflected in any of "
"those methods. The heart of Radar is two abstract classes : Client and "
"Server which can be found under the network module. The Client and Server "
"classes operate in a very similar way despite being different from the way "
"they handle network sockets."
msgstr ""
"Tanto cliente como servidor operan de una manera gobernada por eventos y se "
"hace uso de threads para distribuir el trabajo. Si miras el código de las "
"clases RadarServer y RadarClient encontrarás métodos denominados 'on_algo'. "
"Cada vez que un evento de red ocurre es reflejado en alguno de esos métodos."
" El núcleo de Radar se encuentra en dos clases abstractas : Client y Server "
"que se encuentran en el módulo network. El cliente y servidor operan de "
"manera muy similar a pesar de manejar sockets de manera diferente."

#: ../../internals.rst:134
msgid ""
"The network module also provides some network monitors that are platform "
"dependent. Before Radar server goes into operational mode it tries to select"
" the best multiplex i/o method available. In any case if the platform can't "
"be detected or an efficient multiplexing method cannot be found Radar will "
"fall back to the SelectMonitor (which relies on the select system call). The"
" currently supported multiplexing strategies are : select, poll, epoll and "
"kqueue."
msgstr ""
"El módulo network también incluye algunos monitores de red que son "
"dependientes de la plataforma. Antes de que Radar entre en modo operacional "
"intenta elegir el mejor mecanismo de multiplexing disponible. En cualquier "
"caso si la plataforma no se puede detectar o un modo de multiplexing "
"eficiente no puede encontrarse Radar continuará utilizando el monitor "
"SelectMonitor (que se basa en la llamada a sistema select). Los mecanismos "
"de multiplexing de los cuales Radar dispone actualmente son : select, poll, "
"epoll y kqueue."

#: ../../internals.rst:142
msgid ""
"Radar's client and server also operate in a non-blocking way. Its main "
"threads loops are iterated constantly every 200 milliseconds. This prevents "
"any single client from blocking the server indefinitely due to a malformed "
"or incomplete network message. Also this mechanism is used as an easy "
"workaround to gracefully terminate threads : one thread Event is shared "
"among all defined threads, when this thread event is stopped the condition "
"of the loop does not hold and the threads successfully end."
msgstr ""
"Tanto cliente como servidor también operan de manera no bloqueante. Sus "
"threads principales son iterados constantemente cada 200 milisegundos. Esto "
"previene que algún cliente bloquee al servidor de manera indefinida debido a"
" un mensaje incompleto o incorrecto. También este mecanismo es utilizado "
"como una solución sencilla para finalizar los threads de forma adecuada : un"
" Event es compartido entre todos los threads definidos y cuando este evento "
"es detenido la condición de iteración deja de cumplirse y los threads "
"terminan exitosamente."

#: ../../internals.rst:152
msgid "Server operation"
msgstr "Funcionamiento del servidor"

#: ../../internals.rst:154
msgid "The main work of the server is split across three main threads :"
msgstr "El servidor distribuye el trabajo en tres threads principales :"

#: ../../internals.rst:156
msgid "RadarServer."
msgstr "RadarServer."

#: ../../internals.rst:157
msgid "RadarServerPoller."
msgstr "RadarServerPoller."

#: ../../internals.rst:158
msgid "PluginManager."
msgstr "PluginManager."

#: ../../internals.rst:161
msgid "RadarServer :"
msgstr "RadarServer :"

#: ../../internals.rst:163
msgid ""
"This thread is responsible for accepting clients and receiving replies from "
"them. A client is only accepted if it is defined in at least one monitor and"
" is not duplicated (that is, if the same client isn't already connected)."
msgstr ""
"Este thread es responsable de aceptar clientes y las respuestas de los "
"mismos. Un cliente es solo aceptado si fue definido en al menos un monitor y"
" no esta duplicado (esto es, si el cliente no se encuentra ya conectado)."

#: ../../internals.rst:167
msgid ""
"Once a client is accepted it is registered within the ClientManager. The "
"ClientManager acts as proxy that talks directly to all defined monitors. "
"Every monitor internally knows if it has to accept a client when it "
"connects, if it is indeed accepted then a copy of the checks and contacts is"
" stored along with the instance of that client. This copy is needed because "
"more than one client may match against the same monitor."
msgstr ""
"Una vez que el cliente es aceptado se lo registra en el ClientManager. El "
"ClientManager actua como proxy y habla directamente con todos los monitores "
"que fueron definidos. Cada monitor internamente sabe si tiene o no que "
"aceptar a un cliente cuando se conecta, si es aceptado entonces una copia de"
" los chequeos y contactos relacionados a dicho cliente se genera y se "
"almancena con una instancia de dicho cliente. Esta copia es necesaria ya que"
" más de un cliente puede coincidir con un mismo monitor. "

#: ../../internals.rst:174
msgid ""
"The reverse process applies when a client disconnects, the RadarServer "
"unregisters that client and the connection is closed."
msgstr ""
"El proceso inverso se da cuando un cliente se desconecta, RadarServer borra "
"el cliente y su conexión se cierra."

#: ../../internals.rst:177
msgid ""
"When a client sends a reply is it also initially processed by the "
"ClientManager. The reason for this is that we need to get a list of checks "
"and contacts that are affected by such reply. These two lists of objects are"
" later on transferred to the PluginManager to be processed by any defined "
"plugins."
msgstr ""
"Cuando un cliente envía una respuesta la misma también es procesada por el "
"ClientManager. Esto sucede porque es necesario obtener una lista de chequeos"
" y contactos que estan relacionados con dicha respuesta. Estas dos listas de"
" objetos (chequeos y contactos) son más tarde transferidas al PluginManager "
"para que puedan procesarse por algún plugin."

#: ../../internals.rst:183
msgid "RadarServerPoller :"
msgstr "RadarServerPoller :"

#: ../../internals.rst:185
msgid ""
"This is the simplest thread. Every N seconds it simply asks the "
"ClientManager to poll all of its monitors. The existence of this thread is "
"that it makes sense to have a different abstraction that decides when its "
"time to poll the clients. If this work would have been done in the "
"RadarServer we would be mixing asynchronous (network activity) and "
"synchronous (wait a certain amount of time) events making the overall design"
" more complex to both understand and work with."
msgstr ""
"Este es el thread más sencillo. Cada N segundos simplemente le pide al "
"ClientManager que consulte a todos sus monitores. La existencia de este "
"thread se debe a que tiene sentido tener otra abstracción que decide cuando "
"es hora de consultar a los clientes. Si esta funcionalidad hubiese sido "
"incluida en el thread RadarServer entonces mezclaríamos actividades "
"asincrónicas (eventos de red) y sincrónicas (esperar una cierta cantidad de "
"tiempo) llevandonos a un diseño más rebuscado tanto para trabajar como para "
"comprender."

#: ../../internals.rst:194
msgid "PluginManager :"
msgstr "PluginManager :"

#: ../../internals.rst:196
msgid ""
"As its name indicates, this is the place where all plugins are executed and "
"controlled. Whenever the RadarServer receives a reply from a client and "
"after little processing a dictionary containing all relevant plugin data is "
"written by the RadarServer to a  queue that both RadarServer and "
"PluginManager share, this is the mechanism of communication between those "
"objects. The PluginManager quietly waits for a new dictionary to arrive from"
" this queue, when it does it disassembles all parameters and performs object"
" id dereferencing of two lists that contain the affected checks and the "
"related contacts. This dereferencing is possible because threads share the "
"same address space. This solution seems more elegant and effective than re-"
"instantiating those objects from their states. After this pre-processing "
"every plugin's run method is called with appropiate arguments. If a plugin "
"does not work properly all exceptions are caught and registered in the "
"Radar's log file."
msgstr ""
"Como su nombre lo indica este es el lugar en donde todos los plugins son "
"ejecutados y controlados. Cuando RadarServer recibe una respuesta de un "
"cliente, un diccionario que contiene toda la información relevante para un "
"plugin es escrito a una cola que tanto RadarServer como PluginManager "
"comparten, este es el mecanismo de comunicación entre estos objetos. El "
"PluginManager espera hasta que recibe un diccionario proveniente de dicha "
"cola, al ingresar se lo desensambla y se utiliza un desreferenciamiento de "
"los ids de los chequeos y contactos afectados por la respuesta original. "
"Este desreferenciamiento es posible ya que se comparte el mismo espacio de "
"direcciones del proceso. Esta solución parece más elegante y efectiva que "
"re-instanciar estos objetos a partir de sus estados. Luego de este pre-"
"procesamiento se invoca al método run de cada plugin con los argumentos "
"apropiados. En caso de que un plugin no funcione correctamente todas sus "
"excepciones son atrapadas y volcadas al archivo de log de Radar."

#: ../../internals.rst:213
msgid "Client operation"
msgstr "Funcionamiento del cliente"

#: ../../internals.rst:215
msgid "The client relies on two threads :"
msgstr "El cliente se basa en dos threads :"

#: ../../internals.rst:217
msgid "RadarClient."
msgstr "RadarClient."

#: ../../internals.rst:218
msgid "CheckManager."
msgstr "CheckManager."

#: ../../internals.rst:220
msgid "RadarClient :"
msgstr "RadarClient :"

#: ../../internals.rst:222
msgid ""
"This thread is responsible for receiving and replying messages from the "
"Radar server. For every message received the message is desearialized and "
"written to a queue (that is shared with the CheckManager). Both RadarClient "
"and CheckManager actually share two queues to support bidirectional "
"communication between threads. One queue is used to write checks that need "
"to be executed, the other is used to read the results of those executions."
msgstr ""
"Este thread es responsable de recibir y responder mensajes que provienen del"
" servidor Radar. Cada mensaje recibido es deserializado y escrito a una cola"
" que comparte con el CheckManager. En realidad RadarClient y CheckManager "
"comparten dos colas para permitir comunicación bidireccional entre dichos "
"threads. Una cola es utilizada para escribir los chequeos que se necesitan "
"ejecutar, la otra es usada para leer los resultados de dichas ejecuciones."

#: ../../internals.rst:229
msgid ""
"In case the Radar client is unable to connect to the Radar server it will "
"wait a certain amount of time and try to reconnect again. This is repeated "
"indefinitely if the reconnect option is set to True. It will try to connect "
"after 5, 15 and 60 seconds (cyclically). This option is useful because after"
" updating the Radar's server configuration you need to restart it and all "
"connections are lost. Radar currently does not provide a reload mechanism."
msgstr ""
"En caso de que el cliente no pueda conectarse al servidor, el mismo esperará"
" una cierta cantidad de tiempo e intentará reconectarse nuevamente. Esto es "
"repetido indefinidamente si la opción reconnect tiene un valor True. "
"Internamente se intentará conectarse cada 5, 15 y 60 segundos "
"(ciclicamente). Esta opción es útil ya que si el servidor de Radar es "
"reconfigurado es necesario reiniciarlo y todas las conexiones actuales se "
"pierden. Radar no provee un mecanismo de recarga de configuración."

#: ../../internals.rst:237
msgid "CheckManager :"
msgstr "CheckManager :"

#: ../../internals.rst:239
msgid ""
"Whenever a CHECK message is received by the RadarClient thread and after "
"little processing is immediately sent to the CheckManager. When the check "
"information is received the CheckManager proceeds to instantiate a bunch of "
"Checks (depending on the platform running it may instantiate a UnixCheck or "
"a WindowsCheck) and finally executes them sequentially. Every check's output"
" is collected and verified (the CheckManager makes sure that the Check "
"didn't blow up and that a valid status was returned). It also discards all "
"fields that are not relevant (it will only keep the status, details and data"
" fields of the returned JSON)."
msgstr ""
"Cuando un mensaje de tipo CHECK es recibido por el thread RadarClient y "
"luego de ser procesado mínimamente, se lo envía al CheckManager. Cuando el "
"CheckManager recibe esta información se procede a instanciar un conjunto de "
"chequeos (dependiento la plataforma en donde el cliente este ejecutando "
"podría instanciar un UnixCheck o un WindowsCheck) y finalmente se los "
"ejecuta. Cada una de las salidas de los chequeos es recolectada y verificada"
" (el CheckManager se asegura que un chequeo no ha reventado y que un estado "
"válido ha sido devuelto). Adicionalmente descartará todos aquellos campos "
"que no son relevantes (solo se quedará con los campos status, details y data"
" del JSON devuelto por el chequeo). "

#: ../../internals.rst:249
msgid ""
"Once the outputs have been collected they're sent back to the RadarClient "
"through the other queue and RadarClient sends those results back to the "
"RadarServer."
msgstr ""
"Una vez que todas las salidas fueron recolectadas, se las envía de vuelta al"
" RadarClient mediante la otra cola y RadarClient enviará estos resultados de"
" vuelta al servidor. "

#: ../../internals.rst:255
msgid "Network protocol"
msgstr "Protocolo de red"

#: ../../internals.rst:257
msgid ""
"Radar client and server use TCP for all of its communications. Here is the "
"network protocol that is used by Radar :"
msgstr ""
"El cliente y servidor de Radar utilizan TCP para todas sus comunicaciones. "
"Este el protocolo de red que usa Radar : "

#: ../../internals.rst:261
msgid "TYPE"
msgstr "TYPE"

#: ../../internals.rst:261
msgid "OPTIONS"
msgstr "OPTIONS"

#: ../../internals.rst:261
msgid "PAYLOAD SIZE"
msgstr "PAYLOAD SIZE"

#: ../../internals.rst:261
msgid "PAYLOAD"
msgstr "PAYLOAD"

#: ../../internals.rst:264
msgid ""
"TYPE (1 byte) : Current message types are TEST, TEST REPLY, CHECK and CHECK "
"REPLY."
msgstr ""
"TYPE (1 byte) : Los tipos actuales de mensajes son TEST, TEST REPLY, CHECK y"
" CHECK REPLY. "

#: ../../internals.rst:267
msgid "OPTIONS (1 byte) : Current options are NONE and COMPRESS."
msgstr "OPTIONS (1 byte) : Las opciones actuales son NONE y COMPRESS."

#: ../../internals.rst:269
msgid "PAYLOAD SIZE (2 bytes) : Indicates the size (in bytes) of the payload."
msgstr "PAYLOAD SIZE (2 bytes) : Indica el tamaño (en bytes) del payload."

#: ../../internals.rst:271
msgid ""
"PAYLOAD (variable) : N bytes make up the payload. The payload's maximum size"
" is 64 KiB."
msgstr ""
"PAYLOAD (variable) : Formada por N bytes. El tamaño máximo del payload es de"
" 64 KiB. "

#: ../../internals.rst:274
msgid ""
"Every time the poller needs to query its clients a CHECK message is built "
"and broadcasted to all clients that are managed by any monitor. When the "
"client receives this CHECK message it proceeds to run all checks that the "
"server instructs it to run. After all checks are executed their outputs are "
"collected and a CHECK REPLY message is built and sent to the server."
msgstr ""
"Cada vez que el poller necesita consultar a sus clientes un mensaje de tipo "
"CHECK es construido y emitido a todos los clientes que son administrados por"
" algún monitor. Cuando el cliente recibe este mesaje CHECK, procede a "
"ejecutar todos los chequeos que el servidor le ordena ejecutar. Luego de que"
" los chequeos han sido ejecutados, sus salidas son recolectadas y un mensaje"
" de tipo CHECK REPLY con los resultados es contruido y enviado de vuelta al "
"servidor. "

#: ../../internals.rst:280
msgid ""
"The TEST and TEST REPLY messages are not yet implemented (just defined). The"
" idea is to have a user-controlled way to explicitly force the run of "
"specific checks. This is useful because if a check is not working as "
"expected and a developer or sysadmin fixes it, then it doesn't not make "
"sense to wait until the next poll round to verify that check performs as "
"expected or fails again. This feature will be implemented in a next release "
"along with a small console that allows the user to have more control of the "
"running server."
msgstr ""
"Los mensajes de tipo TEST y TEST REPLY no han sido todavía implementados "
"(solamente definidos). La idea es tener un modo controlado por el usuario "
"que le permita explícitamente forzar la ejecución de un chequeo en ciertos "
"clientes. Esto es útil ya que si un chequeo no esta funcionando "
"adecuadamente y un desarrollador o sysadmin lo arregla entonces no tiene "
"sentido esperar a la siguiente ronda de consulta para verificar si el "
"chequeo funciona como se espera o sigue fallando. Esta característica será "
"implementada en un próximo release en conjunto con una pequeña consola de "
"administración que le permita al usuario un mejor control del servidor. "

#: ../../internals.rst:288
msgid ""
"The payload is always a JSON. The decision behind using JSON is that "
"provides flexibility and an easy way to validate and convert data that comes"
" from the other side of the network. Besides that it also allows the final "
"user to layout the data field of checks as she or he wishes. This also has "
"downsides : more bytes are sent through the network and an extra overhead is"
" payed every time we serialize and deserialize a JSON string."
msgstr ""
"El payload es siempre un JSON. La decisión de utilizar JSON es que provee "
"flexibilidad y una forma fácil de verificar y transformar los datos que "
"vienen del otro lado de la red. Dejando de lado esto, también le permite al "
"usuario final organizar el campo de datos como ella o el quiera. Esto "
"también tiene desventajas : más bytes son enviados por la red y un overhead "
"adicional es agregado cada vez que serializamos y deserializamos un JSON."

#: ../../internals.rst:296
msgid ""
"Currently messages are not being compressed at all. This feature makes sense"
" only if the client replies a message longer than 64 KiB. This feature will "
"be certainly included in a future release."
msgstr ""
"Por el momento los mensajes no son comprimidos. Esta característica solo "
"tiene sentido si la respuesta de un cliente supera los 64 KiB. Esto será "
"definitivamente implementado en un próximo release. "

#: ../../internals.rst:302
msgid "Class diagrams"
msgstr "Diagramas de clase"

#: ../../internals.rst:304
msgid ""
"Sometimes class diagrams help you see the big picture of a design and also "
"act as useful documentation. Here are some diagrams that may help you to to "
"understand what words make cumbersome to describe."
msgstr ""
"A veces los diagramas de clase ayudan a tener un pantallazo general de un "
"diseño y también actuan como documentación adicional. Aquí hay algunos "
"diagramas que pueden ayudarte a entender un poco mejor lo que las palabras a"
" veces no logran describir adecuadamente. "

#: ../../internals.rst:308
msgid ""
"The diagrams contain the most relevant classes of both Radar server and "
"client. Only the most important methods of every class are mentioned. You "
"should follow these diagrams along with the code to have a detailed "
"understanding about what's happening on a certain part of the project."
msgstr ""
"Los diagramas contienen las clases más relevantes del servidor Radar y su "
"cliente. Solo los métodos más importantes son mencionados. Deberías seguir "
"la lectura de estos diagramas con el código fuente para entender "
"detalladamente lo que sucede en cierta parte del proyecto."

#: ../../internals.rst:313
msgid "Radar client :"
msgstr "Cliente :"

#: ../../internals.rst:322
msgid "Radar server :"
msgstr "Servidor :"

#: ../../internals.rst:316
msgid "RadarClient"
msgstr ""

#: ../../internals.rst:316
msgid "RadarClientLauncher"
msgstr ""

#: ../../internals.rst:318
msgid "|radar-client|"
msgstr ""

#: ../../internals.rst:318
msgid "|radar-client-launcher|"
msgstr ""

#: ../../internals.rst:325
msgid "RadarServer"
msgstr ""

#: ../../internals.rst:325
msgid "Server"
msgstr ""

#: ../../internals.rst:327
msgid "|radar-server|"
msgstr ""

#: ../../internals.rst:327
msgid "|server|"
msgstr ""

#: ../../internals.rst:333
msgid "Monitor"
msgstr ""

#: ../../internals.rst:333
msgid "ServerConfig"
msgstr ""

#: ../../internals.rst:335
msgid "|monitor|"
msgstr ""

#: ../../internals.rst:335
msgid "|server-config|"
msgstr ""

#: ../../internals.rst:339
msgid "Notes :"
msgstr "Notas :"

#: ../../internals.rst:341
msgid "RadarServerLauncher is analogous to RadarClientLauncher."
msgstr "La clase RadarServerLauncher es análoga a RadarClientLauncher."