liri 0.3.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '08834308c81302f447468f042b36e8a4afca8fb69cf3b68b0e7abbc93e437588'
-  data.tar.gz: 2bf7d19f01d159ac4824032b746c0e9ea5c630beae920f9facb917578a626f3e
+  metadata.gz: 6a9d3148572b163bc3f6cc5ad627b47bcc27ea976c4ca020e945cdfdbbbb941f
+  data.tar.gz: d7c73dea139fa130a2dbfcd770b2b07f7dc1c113c609e891c2d351b88a10fd04
 SHA512:
-  metadata.gz: c8005779860f0fa0cb1023db745cb8cb8ee5926382484997c1ca5b5ee7c34fbd7edeecfa4bc8583bece964f249dfc3b4cd18bda2c13989ad91df32f97030f064
-  data.tar.gz: 58705bc1314667e09b7dbc9701505ac24256d0776360b21c8db551274e44a71245b6d66aabb12ec864ef51b70ebd6309540918f4b45d47bbcc6610bc36248387
+  metadata.gz: e4189307cce67d58828440a1692e1be0e9bf006718e980a9465244f48b757031ed88a8ba106cec9eaaf3621a9abb1fcd500c1ecba19bded99878388a5503cfbe
+  data.tar.gz: 4f26eb422e762be63962a7685f5f7a7194ad7c9d28762af146e3e519fe9b00b376dbcbab88bb8da9ef181fd41fb534287e9ac93fdc320eced15e5e5f45125528

data/.gitignore

@@ -1,11 +1,13 @@
 /.idea
 /coverage
 /liri
+/logs
+/tmp
 
 *.log
-*.gem
 .rspec_status
 
 *.odt#
 
-spec_credentials.yml
+spec_credentials.yml
+*.gem

data/.rubocop.yml

@@ -12,4 +12,8 @@ Metrics/BlockLength:
   Exclude:
     - 'Rakefile'
     - '**/*.rake'
-    - 'spec/**/*.rb'
+    - 'spec/**/*.rb'
+Layout/LineLength:
+  Max: 120
+Style/StringLiterals:
+  EnforcedStyle: double_quotes

data/Gemfile

@@ -27,6 +27,9 @@ group :development do
   # Ruby static code analyzer and formatter, based on the community Ruby style guide. https://github.com/rubocop-hq/rubocop
   gem 'rubocop', '~>1', require: false
 
+  # RubyCritic is a gem that wraps around static analysis gems such as Reek, Flay and Flog to provide a quality report of your Ruby code.
+  gem 'rubycritic', '~>4', require: false
+
   # A Ruby Documentation Tool. https://github.com/lsegal/yard
   gem 'yard', '~>0'
 end

data/Gemfile.lock

@@ -1,37 +1,68 @@
 PATH
   remote: .
   specs:
-    liri (0.3.0)
+    liri (0.4.1)
+      chronic_duration (~> 0)
       commander (~> 4)
       highline (~> 2)
-      i18n (~> 1)
       net-scp (~> 3)
       ruby-progressbar (~> 1)
       rubyzip (~> 2)
       terminal-table (~> 3)
-      to_duration (~> 1)
+      tty-progressbar (~> 0)
 
 GEM
   remote: https://rubygems.org/
   specs:
+    addressable (2.8.0)
+      public_suffix (>= 2.0.2, < 5.0)
     ast (2.4.2)
+    axiom-types (0.1.1)
+      descendants_tracker (~> 0.0.4)
+      ice_nine (~> 0.11.0)
+      thread_safe (~> 0.3, >= 0.3.1)
+    chronic_duration (0.10.6)
+      numerizer (~> 0.1.1)
     coderay (1.1.3)
+    coercible (1.0.0)
+      descendants_tracker (~> 0.0.1)
     commander (4.6.0)
       highline (~> 2.0.0)
-    concurrent-ruby (1.1.9)
+    descendants_tracker (0.0.4)
+      thread_safe (~> 0.3, >= 0.3.1)
     diff-lcs (1.4.4)
     docile (1.4.0)
+    equalizer (0.0.11)
+    erubi (1.10.0)
+    flay (2.13.0)
+      erubi (~> 1.10)
+      path_expander (~> 1.0)
+      ruby_parser (~> 3.0)
+      sexp_processor (~> 4.0)
+    flog (4.6.5)
+      path_expander (~> 1.0)
+      ruby_parser (~> 3.1, > 3.1.0)
+      sexp_processor (~> 4.8)
     highline (2.0.3)
-    i18n (1.10.0)
-      concurrent-ruby (~> 1.0)
+    ice_nine (0.11.2)
+    kwalify (0.7.2)
+    launchy (2.5.0)
+      addressable (~> 2.7)
     net-scp (3.0.0)
       net-ssh (>= 2.6.5, < 7.0.0)
     net-ssh (6.1.0)
+    numerizer (0.1.1)
     parallel (1.22.1)
     parser (3.1.2.0)
       ast (~> 2.4.1)
+    path_expander (1.1.0)
+    public_suffix (4.0.7)
     rainbow (3.1.1)
     rake (13.0.6)
+    reek (6.1.1)
+      kwalify (~> 0.7.0)
+      parser (~> 3.1.0)
+      rainbow (>= 2.0, < 4.0)
     regexp_parser (2.4.0)
     rexml (3.2.5)
     rspec (3.10.0)
@@ -59,17 +90,45 @@ GEM
     rubocop-ast (1.17.0)
       parser (>= 3.1.1.0)
     ruby-progressbar (1.11.0)
+    ruby_parser (3.19.1)
+      sexp_processor (~> 4.16)
+    rubycritic (4.7.0)
+      flay (~> 2.8)
+      flog (~> 4.4)
+      launchy (>= 2.0.0)
+      parser (>= 2.6.0)
+      rainbow (~> 3.0)
+      reek (~> 6.0, < 7.0)
+      ruby_parser (~> 3.8)
+      simplecov (>= 0.17.0)
+      tty-which (~> 0.4.0)
+      virtus (~> 1.0)
     rubyzip (2.3.2)
+    sexp_processor (4.16.1)
     simplecov (0.21.2)
       docile (~> 1.1)
       simplecov-html (~> 0.11)
       simplecov_json_formatter (~> 0.1)
     simplecov-html (0.12.3)
     simplecov_json_formatter (0.1.4)
+    strings-ansi (0.2.0)
     terminal-table (3.0.2)
       unicode-display_width (>= 1.1.1, < 3)
-    to_duration (1.2.1)
+    thread_safe (0.3.6)
+    tty-cursor (0.7.1)
+    tty-progressbar (0.18.2)
+      strings-ansi (~> 0.2)
+      tty-cursor (~> 0.7)
+      tty-screen (~> 0.8)
+      unicode-display_width (>= 1.6, < 3.0)
+    tty-screen (0.8.1)
+    tty-which (0.4.2)
     unicode-display_width (2.1.0)
+    virtus (1.0.5)
+      axiom-types (~> 0.1)
+      coercible (~> 1.0)
+      descendants_tracker (~> 0.0, >= 0.0.3)
+      equalizer (~> 0.0, >= 0.0.9)
     yard (0.9.26)
 
 PLATFORMS
@@ -81,6 +140,7 @@ DEPENDENCIES
   rake (~> 13)
   rspec (~> 3.10.0)
   rubocop (~> 1)
+  rubycritic (~> 4)
   simplecov (~> 0)
   yard (~> 0)
 

data/README.md

@@ -59,6 +59,9 @@ unitarias de una gema X, si esta gema X requiere una versión específica de Rub
 de cosas deben configurarse de manera manual.
 
 ## Desarrollo
+La rama master siempre debe ser estable.
+Se debe crear un release cada vez que se llega a una versión estable de algún agregado nuevo.
+Agregar fixes y mejoras en ramas.
 
 ### Pruebas Unitarias
 

data/Rakefile

@@ -47,6 +47,11 @@ task :install => [:build, :update_agent_installer, :compress_agent_installer] do
   system "gem install " + Liri::NAME + "-" + Liri::VERSION + ".gem"
 end
 
+# Borra la gema despues de llamar a la tarea install
+Rake::Task[:install].enhance do
+  Rake::Task[:clean].invoke
+end
+
 # Publica la gema después de compilar.
 # > rake publish
 task :publish => :build do

data/bash_script_examples.sh

@@ -1 +1,3 @@
-scp "installers/liriagent.zip" "liri@192.168.0.31:~/"
+scp "installers/liriagent.zip" "magali@192.168.0.4:~/"
+scp "installers/liriagent.zip" "rofaccess@192.168.0.5:~/"
+scp "installers/liriagent.zip" "leslie@192.168.0.9:~/"

data/exe/liri

@@ -26,8 +26,8 @@ command :manager do |c|
   c.option '-o', '--output [filename]', String, 'Especifica donde guardar los resultados de la ejecución de pruebas unitarias'
   c.action do |args, options|
     current_folder = Dir.pwd
-    Liri.set_setup(current_folder)
-    Liri::Common::Benchmarking.start(end_msg: "\nFinalizado en: ", stdout: true) do
+    Liri.set_setup(current_folder, :manager)
+    Liri::Common::Benchmarking.start(end_msg: "\nFinished in: ", stdout: true) do
       # Metodo que se ejecuta al llamar al comando manager
       Liri::Manager.run(current_folder)
     end
@@ -57,22 +57,41 @@ end
 # Define el alias m para el comando agent
 alias_command :a, :agent
 
+# Define el comando y los parámetros para obtener los archivos de tests
+command :tests_files do |c|
+  c.syntax = 'Liri tests_files [options]'
+  c.summary = 'Retorna los archivos de tests'
+  c.description = 'Ejecuta el comando para obtener la cantidad total de tests del proyecto'
+  c.example 'Ejecuta el comando tests', 'liri tf'
+  c.example 'Ejecuta el comando tests', 'liri tests_files'
+  c.action do |args, options|
+    # Método que se ejecuta al llamar al comando tests
+    current_folder = Dir.pwd
+    Liri.set_setup(current_folder, :manager)
+    tests_count = Liri::Task.tests_files(current_folder)
+    puts tests_count
+  end
+end
+
+# Define el alias t para el comando tests
+alias_command :tf, :tests_files
+
 # Define el comando y los parámetros para obtener la cantidad de tests
-command :tests do |c|
-  c.syntax = 'Liri tests [options]'
+command :tests_count do |c|
+  c.syntax = 'Liri tests_count [options]'
   c.summary = 'Retorna la cantidad total de tests'
   c.description = 'Ejecuta el comando para obtener la cantidad total de tests del proyecto'
-  c.example 'Ejecuta el comando tests', 'liri t'
-  c.example 'Ejecuta el comando tests', 'liri tests'
+  c.example 'Ejecuta el comando tests', 'liri tc'
+  c.example 'Ejecuta el comando tests', 'liri tests_count'
   c.action do |args, options|
     # Método que se ejecuta al llamar al comando tests
     current_folder = Dir.pwd
-    Liri.set_setup(current_folder)
+    Liri.set_setup(current_folder, :manager)
     tests_count = Liri::Task.tests_count(current_folder)
     puts tests_count
   end
 end
 
 # Define el alias t para el comando tests
-alias_command :t, :tests
+alias_command :tc, :tests_count
 

data/lib/agent/agent.rb

@@ -12,43 +12,43 @@ module Liri
       # Inicia la ejecución del Agent
       # @param stop [Boolean] el valor true es para que no se ejecute infinitamente el método en el test unitario.
       def run(work_folder_path, stop = false)
-        setup_manager = Liri.set_setup(work_folder_path)
+        setup_manager = Liri.set_setup(work_folder_path, :agent)
         agent_folder_path = setup_manager.agent_folder_path
 
-        Liri.set_logger(setup_manager.logs_folder_path, 'liri-agent.log')
-        Liri.logger.info("Proceso Agent iniciado")
-        Liri.logger.info("Presione Ctrl + c para terminar el proceso Agent manualmente\n", true)
+        Liri.set_logger(setup_manager.logs_folder_path, 'liriagent.log')
+        Liri.logger.info("Agent process started", true)
+        Liri.logger.info("Press Ctrl + c to finish Agent process manually\n", true)
 
-        decompressed_source_code_path = File.join(agent_folder_path, '/', Common::SourceCode::DECOMPRESSED_FOLDER_NAME)
-        source_code = Common::SourceCode.new(decompressed_source_code_path, agent_folder_path, Liri.compression_class, Liri.unit_test_class)
-        runner = Agent::Runner.new(Liri.unit_test_class, source_code.decompressed_file_folder_path)
-        tests_result = Common::TestsResult.new(agent_folder_path)
-        agent = Agent.new(Liri.udp_port, Liri.tcp_port, source_code, runner, tests_result, agent_folder_path)
+        agent = Agent.new(Liri.udp_port, Liri.tcp_port, agent_folder_path)
         threads = []
         threads << agent.start_server_socket_to_process_manager_connection_request # Esperar y procesar la petición de conexión del Manager
 
-        Liri.init_exit(stop, threads, 'Agent')
-        Liri.logger.info("Proceso Agent terminado")
-      rescue SignalException => e
-        Liri.logger.info("Exception(#{e}) Proceso Agent terminado manualmente")
-        Liri.kill(threads)
+        Liri.init_exit(stop, threads)
+      rescue SignalException
+        Liri.logger.info("Agent process finished manually", true)
+      rescue InxiCommandNotFoundError => e
+        Liri.logger.error("Exception(#{e}) Please, install inxi in your operating system", true)
+      ensure
+        # Siempre se ejecutan estos comandos, haya o no excepción
+        Liri.kill(threads) if threads && threads.any?
+        Liri.logger.info("Agent process finished", true)
       end
     end
 
-    def initialize(udp_port, tcp_port, source_code, runner, tests_result, agent_folder_path)
+    def initialize(udp_port, tcp_port, agent_folder_path)
       @udp_port = udp_port
       @udp_socket = UDPSocket.new
       @tcp_port = tcp_port
 
-      @source_code = source_code
-      @runner = runner
-      @tests_result = tests_result
-
       @all_tests = {}
 
       @managers = {}
 
       @agent_folder_path = agent_folder_path
+
+      @processing = true
+
+      @hardware_specs = hardware_specs
     end
 
     # Inicia un servidor udp que se mantiene en espera de la primera petición de conexión del Manager
@@ -60,17 +60,17 @@ module Liri
         begin
           @udp_socket.bind('0.0.0.0', @udp_port)
         rescue Errno::EADDRINUSE => e
-          Liri.logger.error("Exception(#{e}) Puerto UDP #{@udp_port} ocupado")
+          Liri.logger.error("Exception(#{e}) Busy UDP port #{@udp_port}", true)
           Thread.exit
         end
-        Liri.logger.info("En espera de peticiones de Managers en el puerto UDP #{@udp_port}
-                                     (Se espera que algún Manager se contacte por primera vez para establecer una conexión TCP)
-        ")
+        Liri.logger.info("Waiting managers request in UDP port #{@udp_port}")
 
-        loop do
+        while @processing
           @manager_request = @udp_socket.recvfrom(1024)
           manager_ip_address = @manager_request.last.last
           manager_data = get_manager_data(JSON.parse(@manager_request.first))
+          # TODO: El cliente TCP debería inicicarse en otro hilo, de este modo se tendrá un cliente TCP para cada Manager
+          # y se evita que un mismo cliente procese la ejecución de varios Manager
           process_manager_connection_request(manager_ip_address, manager_data)
         end
       end
@@ -79,56 +79,61 @@ module Liri
     # Inicia un cliente tcp para responder a la petición broadcast del Manager para que éste sepa donde enviar las pruebas
     def start_client_socket_to_process_tests(manager_ip_address, manager_data)
       tcp_socket = TCPSocket.open(manager_ip_address, @tcp_port)
-
       agent_ip_address = tcp_socket.addr[2]
+      tcp_socket.puts({ msg: 'get_source_code', hardware_specs: @hardware_specs }.to_json)
 
-      tcp_socket.puts({ msg: 'Listo' }) # Se envía un mensaje inicial al Manager
-
-      Liri.logger.info("Se inicia una conexión para procesar pruebas con el Manager: #{manager_ip_address} en el puerto TCP: #{@tcp_port}")
-      Liri.logger.info("\nConexión iniciada con el Manager: #{manager_ip_address}", true)
-
-      # En la siguiente línea se espera un puts desde el Manager, pero el Manager no lo hace
-      response = JSON.parse(tcp_socket.gets)
-      return unless response['exist_tests']
-
-      get_source_code(manager_ip_address, manager_data)
+      # Las siguientes variables se usan para guardar momentaneamente los resultados mientras se hace un chequeo de que
+      # el Manager siga ejecutandose o que ya no haya procesado los mismos tests ya ejecutados por otro agente
+      tests_result_file_name = ""
+      tests_result_file_path = ""
+      tests_result = {}
 
-      # Se procesan las pruebas enviadas por el Manager
       while line = tcp_socket.gets
-        response = line.chop
-        break if response == 'exit'
+        tcp_socket_data = JSON.parse(line.chop)
+        msg = tcp_socket_data['msg']
 
-        tests_batch = JSON.parse(response)
-        tests = get_tests(tests_batch, manager_ip_address)
-
-        raw_tests_result = @runner.run_tests(tests)
+        if msg == 'already_connected' || msg == 'no_exist_tests' || msg == 'finish_agent'
+          break
+        end
 
-        tests_batch_number = tests_batch['tests_batch_number']
-        tests_result_file_name = @tests_result.build_file_name(agent_ip_address, tests_batch_number)
-        tests_result_file_path = @tests_result.save(tests_result_file_name, raw_tests_result)
+        if msg == 'proceed_get_source_code'
+          init_work_folders(manager_ip_address)
+          result = get_source_code(manager_ip_address, manager_data)
+          tcp_socket.puts({ msg: result }.to_json)
+        end
 
-        send_tests_results_file(manager_ip_address, manager_data, tests_result_file_path)
-        result = { tests_batch_number: tests_batch_number, tests_result_file_name: tests_result_file_name, tests_batch_keys_size: tests_batch['tests_batch_keys'].size}
-        tcp_socket.puts(result.to_json) # Envía el número de lote y el nombre del archivo de resultados.
+        if msg == 'process_tests'
+          tests_batch = tcp_socket_data
+          tests = get_tests(tests_batch, manager_ip_address)
+
+          compressed_file_folder_path = @managers[manager_ip_address][:compressed_file_folder_path]
+          decompressed_file_folder_path = @managers[manager_ip_address][:decompressed_file_folder_path]
+
+          runner = Agent::Runner.new(Liri.unit_test_class, decompressed_file_folder_path)
+          raw_tests_result = runner.run_tests(tests)
+          batch_num = tests_batch['batch_num']
+          tests_result = Common::TestsResult.new(compressed_file_folder_path)
+          tests_result_file_name = tests_result.build_file_name(agent_ip_address, batch_num)
+          tests_result_file_path = tests_result.save(tests_result_file_name, raw_tests_result)
+          # TODO No se debería enviar el resultado si otro agente ya lo procesó, porque osinó reemplazaría el archivo de resultados
+          # ya procesado. ACTUALIZACION: Puede que esto ya se haya arreglado
+          send_tests_results_file(manager_ip_address, manager_data, tests_result_file_path)
+          tests_result = { msg: 'processed_tests', batch_num: batch_num, tests_result_file_name: tests_result_file_name}
+          tcp_socket.puts(tests_result.to_json) # Envía el número de lote y el nombre del archivo de resultados.
+        end
       end
 
       tcp_socket.close
-      Liri.logger.info("Se termina la conexión con el Manager #{manager_ip_address} en el puerto TCP: #{@tcp_port}")
-
-      Liri.clean_folder_content(@agent_folder_path)
-
-      start_client_to_close_manager_server(manager_ip_address, 'Conexión Terminada')
       unregister_manager(manager_ip_address)
     rescue Errno::EADDRINUSE => e
-      Liri.logger.error("Exception(#{e}) Puerto TCP #{@tcp_port} ocupado")
+      Liri.logger.error("Exception(#{e}) Busy UDP port #{@udp_port}")
+      @processing = false
     rescue Errno::ECONNRESET => e
       tcp_socket.close
-      Liri.logger.error("Exception(#{e}) Conexión cerrada en el puerto TCP #{@tcp_port}")
-      Liri.logger.info("Se termina la conexión con el Manager #{manager_ip_address} en el puerto TCP: #{@tcp_port}")
+      Liri.logger.error("Exception(#{e}) Closed connection in TCP port #{@tcp_port}", true)
       unregister_manager(manager_ip_address)
     rescue Errno::ECONNREFUSED => e
-      Liri.logger.error("Exception(#{e}) Conexión rechazada en el puerto TCP #{@tcp_port}")
-      Liri.logger.info("Se termina la conexión con el Manager #{manager_ip_address} en el puerto TCP: #{@tcp_port}")
+      Liri.logger.error("Exception(#{e}) Rejected connection in TCP port #{@tcp_port}", true)
       unregister_manager(manager_ip_address)
     end
 
@@ -140,46 +145,36 @@ module Liri
     def process_manager_connection_request(manager_ip_address, manager_data)
       unless registered_manager?(manager_ip_address)
         register_manager(manager_ip_address)
-        Liri.logger.info("Petición broadcast UDP recibida del Manager: #{manager_ip_address} en el puerto UDP: #{@udp_port}")
-        #if get_source_code(manager_ip_address, manager_data)
-          start_client_socket_to_process_tests(manager_ip_address, manager_data)
-        #else
-          #unregister_manager(manager_ip_address)
-        #end
+        Liri.logger.info("Broadcast request received from Manager: #{manager_ip_address} in UDP port: #{@udp_port}")
+        start_client_socket_to_process_tests(manager_ip_address, manager_data)
       end
     end
 
-    # Se establece una nueva comunicación con el servidor TCP del Manager con el único objetivo de cerrar el servidor
-    # Esta conexión permitirá al Manager cerrar sus hilos pendientes con servidores TCP en espera y terminar el proceso
-    def start_client_to_close_manager_server(manager_ip_address, msg)
-      tcp_socket = TCPSocket.open(manager_ip_address, @tcp_port)
-      Liri.logger.info("Se termina cualquier proceso pendiente con el Manager #{manager_ip_address} en el puerto TCP: #{@tcp_port}")
-      tcp_socket.print({ msg: msg }.to_json)
-      tcp_socket.close
-    end
-
     def get_source_code(manager_ip_address, manager_data)
-      #puts "#{manager_data.to_h}"
       puts ''
-      Liri::Common::Benchmarking.start(start_msg: "Obteniendo código fuente. Espere... ", stdout: true) do
+      compressed_file_folder_path = @managers[manager_ip_address][:compressed_file_folder_path]
+      decompressed_file_folder_path = @managers[manager_ip_address][:decompressed_file_folder_path]
+      source_code = Liri::Common::SourceCode.new(decompressed_file_folder_path,compressed_file_folder_path, "", Liri.compression_class, Liri.unit_test_class)
+
+      Liri::Common::Benchmarking.start(start_msg: "Getting source code. Wait... ", stdout: true) do
         puts ''
         Net::SCP.start(manager_ip_address, manager_data.user, password: manager_data.password) do |scp|
-          scp.download!(manager_data.compressed_file_path, @source_code.compressed_file_folder_path)
+          scp.download!(manager_data.compressed_file_path, compressed_file_folder_path)
         end
       end
       puts ''
 
       downloaded_file_name = manager_data.compressed_file_path.split('/').last
-      downloaded_file_path = File.join(@source_code.compressed_file_folder_path, '/', downloaded_file_name)
+      downloaded_file_path = File.join(compressed_file_folder_path, '/', downloaded_file_name)
 
-      Liri::Common::Benchmarking.start(start_msg: "Descomprimiendo código fuente. Espere... ", stdout: true) do
-        @source_code.decompress_file(downloaded_file_path)
-        @all_tests = @source_code.all_tests
+      Liri::Common::Benchmarking.start(start_msg: "Uncompressing source code. Wait... ", stdout: true) do
+        source_code.decompress_file(downloaded_file_path)
+        @all_tests = source_code.all_tests
       end
       puts ''
 
       # Se cambia temporalmente la carpeta de trabajo a la carpeta de código fuente descomprimida
-      Dir.chdir(@source_code.decompressed_file_folder_path) do
+      Dir.chdir(decompressed_file_folder_path) do
         # Se borra el directorio .git para evitar el siguiente error al ejecutar las pruebas: fatal: not a git repository (or any of the parent directories): .git
         # Una mejor alternativa es no traer siquiera esa carpeta junto al código fuente excluyendo la carpeta .git al comprimir el código fuente.
         # Por cuestiones de tiempo se procede a borrar la carpeta .git por ahora, aunque al parecer el error mostrado no afecta la ejecución del Agent
@@ -193,49 +188,44 @@ module Liri
         # Se setea la versión de ruby y el gemset para el código fuente descomprimido
         # Se especifica el Gemfile del cual se van a instalar los requerimientos
         # Esto se hace porque por defecto se usa la versión de Ruby de Liri y su Gemset y por ello hay que cambiarlos explicitamente aquí
-        Liri::Common::Benchmarking.start(start_msg: "Ejecutando bundle install. Espere... ", end_msg: "Ejecución de bundle install. Duración: ", stdout: true) do
+        Liri::Common::Benchmarking.start(start_msg: "Running bundle install. Wait... ", end_msg: "Running bundle install. Duration: ", stdout: true) do
           puts ''
           system("bash -lc 'rvm use #{Liri.current_folder_ruby_and_gemset}; BUNDLE_GEMFILE=Gemfile bundle install'")
         end
         puts ''
 
-        Liri::Common::Benchmarking.start(start_msg: "Ejecutando rake db:migrate RAILS_ENV=test. Espere... ", end_msg: "Ejecución de rake db:migrate RAILS_ENV=test. Duración: ", stdout: true) do
+        Liri::Common::Benchmarking.start(start_msg: "Running rake db:migrate RAILS_ENV=test. Wait... ", end_msg: "Running rake db:migrate RAILS_ENV=test. Duration: ", stdout: true) do
           puts ''
           system("bash -lc 'rvm use #{Liri.current_folder_ruby_and_gemset}; rake db:migrate RAILS_ENV=test'")
         end
         puts ''
-
-        #Liri::Common::Benchmarking.start(start_msg: "Ejecutando rake db:migrate:reset RAILS_ENV=test. Espere... ", end_msg: "Ejecución de rake db:migrate:reset RAILS_ENV=test. Duración: ", stdout: true) do
-        # puts ''
-        # system("bash -lc 'rvm use #{Liri.current_folder_ruby_and_gemset}; rake db:migrate:reset RAILS_ENV=test'")
-        #end
-        #puts ''
       end
-      true
+      'get_tests_files'
+    rescue Liri::FileNotFoundError => e
+      Liri.logger.error("Exception(#{e}) Not found file to decompress in Agent")
+      'get_source_code_fail'
     rescue Errno::ECONNREFUSED => e
-      Liri.logger.error("Exception(#{e}) Conexión rechazada por #{manager_ip_address}. Posiblemente ssh no esté ejecutandose en #{manager_ip_address}")
-      false
+      Liri.logger.error("Exception(#{e}) Rejected connection by #{manager_ip_address}. Maybe ssh is not running in #{manager_ip_address}")
+      'get_source_code_fail'
     rescue Errno::ENOTTY => e
       # Este rescue es temporal, hay que ver una mejor manera de detectar si la contraseña es incorrecta
-      Liri.logger.error("Exception(#{e}) Contraseña incorrecta recibida de #{manager_ip_address} para la conexión ssh")
-      start_client_to_close_manager_server(manager_ip_address, "No se puede obtener el archivo de código fuente. Posiblemente se envío una contraseña incorrencta desde #{manager_ip_address}")
-      false
+      Liri.logger.error("Exception(#{e}) Invalid password received in #{manager_ip_address} for ssh connection")
+      'get_source_code_fail'
     rescue Net::SSH::AuthenticationFailed => e
       # Este rescue es temporal, hay que ver una mejor manera de detectar si la contraseña es incorrecta
-      Liri.logger.error("Exception(#{e}) Contraseña incorrecta recibida de #{manager_ip_address} para la conexión ssh")
-      start_client_to_close_manager_server(manager_ip_address, "No se puede obtener el archivo de código fuente. Posiblemente se envío una contraseña incorrencta desde #{manager_ip_address}")
-      false
+      Liri.logger.error("Exception(#{e}) Invalid password received in #{manager_ip_address} for ssh connection")
+      'get_source_code_fail'
     rescue Net::SCP::Error => e
-      Liri.logger.warn("Exception(#{e}) Archivo no encontrado en #{manager_ip_address} a través de scp")
-      false
+      Liri.logger.warn("Exception(#{e}) File not found in #{manager_ip_address} through scp")
+      'get_source_code_fail'
     rescue TypeError => e
-      Liri.logger.warn("Exception(#{e}) Error indeterminado")
-      false
+      Liri.logger.warn("Exception(#{e}) Undetermined error")
+      'get_source_code_fail'
     end
 
     def get_manager_data(manager_data_hash)
       Common::ManagerData.new(
-        folder_path: manager_data_hash['folder_path'],
+        tests_results_folder_path: manager_data_hash['tests_results_folder_path'],
         compressed_file_path: manager_data_hash['compressed_file_path'],
         user: manager_data_hash['user'],
         password: manager_data_hash['password']
@@ -244,9 +234,9 @@ module Liri
 
     def send_tests_results_file(manager_ip_address, manager_data, tests_result_file_path)
       puts ''
-      Liri::Common::Benchmarking.start(start_msg: "Enviando archivo de resultados. Espere... ", stdout: true) do
+      Liri::Common::Benchmarking.start(start_msg: "Sending test files results. Wait... ", stdout: true) do
         Net::SCP.start(manager_ip_address, manager_data.user, password: manager_data.password) do |scp|
-          scp.upload!(tests_result_file_path, manager_data.folder_path)
+          scp.upload!(tests_result_file_path, manager_data.tests_results_folder_path)
         end
       end
       puts ''
@@ -255,22 +245,44 @@ module Liri
     def get_tests(tests_batch, manager_ip_address)
       # Se convierte "[5, 9, 13, 1]" a un arreglo [5, 9, 13, 1]
       tests_keys = tests_batch['tests_batch_keys']
-      Liri.logger.debug("Claves de pruebas recibidas del Manager #{manager_ip_address}: #{tests_keys}")
+      Liri.logger.debug("Tests keys received from Manager #{manager_ip_address}: #{tests_keys}")
       # Se buscan obtienen los tests que coincidan con las claves recibidas de @all_tests = {1=>"spec/hash_spec.rb:2", 2=>"spec/hash_spec.rb:13", 3=>"spec/hash_spec.rb:24", ..., 29=>"spec/liri_spec.rb:62"}
       # Se retorna un arreglo con los tests a ejecutar ["spec/liri_spec.rb:4", "spec/hash_spec.rb:5", "spec/hash_spec.rb:59", ..., "spec/hash_spec.rb:37"]
       tests_keys.map { |test_key| @all_tests[test_key] }
     end
 
+    def hardware_specs
+      "#{Common::Hardware.cpu} #{Common::Hardware.memory}GB"
+    end
+
     def registered_manager?(manager_ip_address)
       @managers[manager_ip_address]
     end
 
     def register_manager(manager_ip_address)
-      @managers[manager_ip_address] = manager_ip_address
+      unless registered_manager?(manager_ip_address)
+        @managers[manager_ip_address] = {
+          manager_ip_address: @managers[manager_ip_address]
+        }
+      end
     end
 
     def unregister_manager(manager_ip_address)
       @managers.remove!(manager_ip_address)
+      Liri.logger.info("Finish connection with Manager #{manager_ip_address} in TCP port: #{@tcp_port}")
+    end
+
+    def init_work_folders(manager_ip_address)
+      return if @managers[manager_ip_address][:compressed_file_folder_path]
+
+      compressed_file_folder_path = File.join(@agent_folder_path, '/', "#{DateTime.now.strftime("%d_%m_%y_%H_%M_%S")}_work")
+      Dir.mkdir(compressed_file_folder_path) unless Dir.exist?(compressed_file_folder_path)
+      decompressed_file_folder_path = File.join(compressed_file_folder_path, '/', Common::SourceCode::DECOMPRESSED_FOLDER_NAME)
+
+      @managers[manager_ip_address] = {
+        compressed_file_folder_path: compressed_file_folder_path,
+        decompressed_file_folder_path: decompressed_file_folder_path
+      }
     end
   end
-end
+end