liri 0.1.0

data/lib/agent/runner.rb

@@ -0,0 +1,19 @@
+=begin
+  Esta clase se encarga de ejecutar las pruebas unitarias recibidas del Manager
+=end
+
+module Liri
+  class Agent
+    class Runner
+      def initialize(unit_test_class, source_code_folder_path)
+        @unit_test = Object.const_get(unit_test_class).new(source_code_folder_path)
+      end
+
+      def run_tests(tests)
+        result_hash = @unit_test.run_tests(tests.values)
+        result_hash[:test_keys] = tests.keys
+        result_hash
+      end
+    end
+  end
+end

data/lib/all_libraries.rb

@@ -0,0 +1,30 @@
+# = all_libraries.rb
+#
+# Autor::   Rodrigo Fernández
+# Web::     http://www.something.com
+#
+# Este archivo se encarga de importar todas las librerías a utilizar
+
+# Se utiliza la librería *socket* de Ruby para realizar una conexión udp
+require 'socket'
+require 'net/ssh'
+require 'net/scp'
+
+# El archivo *hash_extend* extiende la clase Hash de Ruby para agregarle más funcionalidades
+require 'hash_extend'
+
+require 'task'
+
+require 'agent/agent'
+require 'agent/runner'
+
+require 'common/benchmarking'
+require 'common/log'
+require 'common/source_code'
+require 'common/compressor/zip'
+require 'common/unit_test/rspec'
+
+require 'manager/manager'
+require 'manager/setup'
+require 'manager/credential'
+require 'manager/test_result'

data/lib/common/benchmarking.rb

@@ -0,0 +1,36 @@
+# = benchmarking.rb
+#
+# @author Rodrigo Fernández
+#
+# == Módulo Benchmarking
+# Este módulo se encarga de medir el tiempo de ejecución de algunos bloques de código
+
+require 'benchmark'
+require 'i18n' # requirimiento de la gema to_duration
+require 'to_duration'
+
+# Se configura la ubicación del archivo de internacionalización de la gema to_duration
+I18n.load_path << Dir[File.join(File.dirname(File.dirname(File.dirname(__FILE__))), 'config/locales') + "/*.yml"]
+I18n.default_locale = :es
+
+module Liri
+  module Common
+    module Benchmarking
+      class << self
+        def start(start_msg: nil, end_msg: 'Duración: ')
+          print start_msg
+          seconds = Benchmark.realtime do
+            yield
+          end
+          print_result(end_msg, seconds)
+        end
+
+        private
+
+        def print_result(msg, seconds)
+          print "#{msg}#{seconds.to_duration}"
+        end
+      end
+    end
+  end
+end

data/lib/common/compressor/zip.rb

@@ -0,0 +1,70 @@
+=begin
+  Esta clase se encarga de comprimir y descomprimir archivos
+=end
+require 'zip'
+
+module Liri
+  module Common
+    module Compressor
+      class Zip
+        # Inicializa la carpeta a comprimir y la ubicación en donde se guardará el archivo comprimido
+        def initialize(input_dir, output_file)
+          @input_dir = input_dir
+          @output_file = output_file
+        end
+
+        # Comprime el directorio de entrada @input_dir en un archivo con extensión zip.
+        def compress
+          clear_output_file
+          entries = Dir.entries(@input_dir) - %w[. ..]
+
+          ::Zip::File.open(@output_file, ::Zip::File::CREATE) do |zipfile|
+            write_entries(entries, '', zipfile)
+          end
+          true
+        end
+
+        def decompress(zip_dir, dir_destination)
+          FileUtils.mkdir_p(dir_destination)
+          ::Zip::File.open(File.expand_path(zip_dir)) do |zip_file|
+            zip_file.each do |f|
+              fpath = File.join(dir_destination, f.name)
+              FileUtils.mkdir_p(File.dirname(fpath))
+              zip_file.extract(f, fpath) unless File.exist?(fpath)
+            end
+          end
+        end
+
+        private
+
+        def clear_output_file
+          File.delete(@output_file) if File.exist?(@output_file)
+        end
+
+        # Un método de ayuda que hace que la recursión funcione
+        def write_entries(entries, path, zipfile)
+          entries.each do |e|
+            zipfile_path = path == '' ? e : File.join(path, e)
+            disk_file_path = File.join(@input_dir, zipfile_path)
+
+            if File.directory? disk_file_path
+              recursively_deflate_directory(disk_file_path, zipfile, zipfile_path)
+            else
+              put_into_archive(disk_file_path, zipfile, zipfile_path)
+            end
+          end
+        end
+
+        def recursively_deflate_directory(disk_file_path, zipfile, zipfile_path)
+          zipfile.mkdir(zipfile_path)
+          subdir = Dir.entries(disk_file_path) - %w[. ..]
+          write_entries(subdir, zipfile_path, zipfile)
+        end
+
+        def put_into_archive(disk_file_path, zipfile, zipfile_path)
+          zipfile.add(zipfile_path, disk_file_path)
+        end
+      end
+    end
+  end
+end

data/lib/common/log.rb

@@ -0,0 +1,121 @@
+# = log.rb
+#
+# @author Rodrigo Fernández
+#
+# == Clase Log
+# Esta clase se encarga de manejar el logging
+
+require 'logger'
+
+module Liri
+  module Common
+    class Log
+      FOLDER_NAME = 'logs'
+      FOLDER_PATH = File.join(Dir.pwd, "/#{FOLDER_NAME}")
+      FILE_NAME = 'liri.log'
+
+      def initialize(shift_age, folder_path:, file_name:, stdout: true)
+        @stdout = stdout
+        @shift_age = shift_age
+        @folder_path = folder_path || FOLDER_PATH
+        @file_name = file_name || FILE_NAME
+        @file_path = File.join(@folder_path, '/', @file_name)
+
+        create_stdout_logger if @stdout
+        create_log_folder
+        create_file_logger
+      end
+
+      def debug(text)
+        @stdout_logger.debug(text) if @stdout
+        @file_logger.debug(text)
+      end
+
+      def info(text)
+        @stdout_logger.info(text) if @stdout
+        @file_logger.info(text)
+      end
+
+      def warn(text)
+        @stdout_logger.warn(text) if @stdout
+        @file_logger.warn(text)
+      end
+
+      def error(text)
+        @stdout_logger.error(text) if @stdout
+        @file_logger.error(text)
+      end
+
+      def fatal(text)
+        @stdout_logger.fatal(text) if @stdout
+        @file_logger.fatal(text)
+      end
+
+      def unknown(text)
+        @stdout_logger.unknown(text) if @stdout
+        @file_logger.unknown(text)
+      end
+
+      private
+      def create_stdout_logger
+        @stdout_logger = Logger.new(STDOUT, @shift_age)
+        @stdout_logger.formatter = Liri::Common::LogFormatter.colorize(Liri.setup.log.stdout.colorize)
+      end
+
+      def create_file_logger
+        @file_logger = Logger.new(@file_path, @shift_age)
+        @file_logger.formatter = Liri::Common::LogFormatter.colorize(Liri.setup.log.file.colorize)
+      end
+
+      def create_log_folder
+        Dir.mkdir(@folder_path) unless Dir.exist?(@folder_path)
+      end
+    end
+
+    class LogFormatter
+      DATETIME_FORMAT = "%d-%m-%Y %H:%M"
+
+      SEVERITY_COLORS = {
+          DEBUG: '0;36',  # cyan
+          ERROR: '0;31',  # red
+          INFO: '0;32',   # green
+          WARN: '0;33',   # orange
+          FATAL: '0;35',  # pink
+          ANY: '0;36',    # cyan
+          DEFAULT: '1;0'  # white
+      }
+
+      class << self
+        def colorize(type)
+          proc do |severity, datetime, progname, msg|
+            formatted_date = datetime.strftime(DATETIME_FORMAT)
+            severity_abb_block = "#{severity.slice(0)}"
+            date_block = "[#{formatted_date}##{Process.pid}]"
+            severity_block = "#{severity} -- :"
+            msg_block = "#{msg}\n"
+
+            case type
+            when 'severity' then
+              info_block = "#{colorize_according_severity(severity, severity_abb_block)} #{date_block} #{colorize_according_severity(severity, severity_block)}"
+            when 'severity_date' then
+              info_block = colorize_according_severity(severity, "#{severity_abb_block} #{date_block} #{severity_block}")
+            when 'full' then
+              info_block = colorize_according_severity(severity, "#{severity_abb_block} #{date_block} #{severity_block}")
+              msg_block = colorize_according_severity(severity, msg_block)
+            else
+              info_block = "#{severity_abb_block} #{date_block} #{severity_block}"
+            end
+
+            "#{info_block} #{msg_block}"
+          end
+        end
+
+        private
+        def colorize_according_severity(severity, line)
+          color = SEVERITY_COLORS[severity.to_sym] || SEVERITY_COLORS[:DEFAULT]
+          "\e[#{color}m#{line}\e[0m"
+        end
+      end
+    end
+  end
+end

data/lib/common/source_code.rb

@@ -0,0 +1,53 @@
+=begin
+  Este clase se encarga de manejar lo relativo al código fuente
+=end
+
+module Liri
+  module Common
+    class SourceCode
+      FOLDER_PATH = Dir.pwd
+      FOLDER_NAME = FOLDER_PATH.split('/').last
+      DECOMPRESSED_FOLDER_NAME = 'decompressed'
+      attr_reader :compressed_file_folder_path, :compressed_file_path, :decompressed_file_folder_path
+
+      def initialize(compressed_file_folder_path, compression_class, unit_test_class)
+        @compressed_file_folder_path = compressed_file_folder_path
+        @decompressed_file_folder_path = File.join(@compressed_file_folder_path, '/', DECOMPRESSED_FOLDER_NAME)
+        @compressed_file_path = File.join(@compressed_file_folder_path, '/', "#{FOLDER_NAME}.zip")
+        # Inicializa un compresor acorde a compression_class, la siguiente línea en realidad hace lo siguiente:
+        # @compressor = Liri::Common::Compressor::Zip.new(input_dir, output_file)
+        # compression_class en este caso es Zip pero podría ser otro si existiera la implementación, por ejemplo Rar
+        @compressor = Object.const_get(compression_class).new(FOLDER_PATH, @compressed_file_path)
+        # Inicializa un ejecutor de pruebas acorde a unit_test_class, la siguiente línea en realidad hace lo siguiente:
+        # @unit_test = Liri::Common::UnitTest::Rspec.new(source_code_folder_path)
+        # unit_test_class en este caso es Rspec pero podría ser otro si existiera la implementación, por ejemplo UnitTest
+        @unit_test = Object.const_get(unit_test_class).new(FOLDER_PATH)
+      end
+
+      def compress_folder
+        @compressor.compress
+      end
+
+      def decompress_file(compressed_file_path = @compressed_file_path)
+        @compressor.decompress(compressed_file_path, @decompressed_file_folder_path)
+      end
+
+      def delete_compressed_file
+        if File.exist?(@compressed_file_path)
+          File.delete(@compressed_file_path)
+          true
+        else
+          false
+        end
+      end
+
+      def all_tests
+        @unit_test.all_tests
+      end
+
+      def folder_path
+        FOLDER_PATH
+      end
+    end
+  end
+end

data/lib/common/unit_test/rspec.rb

@@ -0,0 +1,91 @@
+module Liri
+  module Common
+    module UnitTest
+      class Rspec
+        TESTS_FOLDER_NAME = 'spec'
+        attr_reader :tests_folder_path
+
+        def initialize(source_code_folder_path)
+          @source_code_folder_path = source_code_folder_path
+          @tests_folder_path = File.join(source_code_folder_path, TESTS_FOLDER_NAME)
+        end
+
+        # Retorna un hash con todos los tests. Ex.: {1=>"spec/hash_spec.rb:2", 2=>"spec/hash_spec.rb:13", 3=>"spec/hash_spec.rb:24", ..., 29=>"spec/liri_spec.rb:62"}
+        def all_tests
+          tests_count = 1
+          tests_hash = {}
+          test_files.each do |test_file|
+            File.open(test_file) do |file|
+              file.each_with_index do |line, index|
+                if line.strip.start_with?('it')
+                  absolute_file_path = file.to_path
+                  relative_file_path = absolute_file_path.sub(@source_code_folder_path + '/', '')
+
+                  test_line = relative_file_path + ":#{index + 1}"
+                  tests_hash[tests_count] = test_line
+                  tests_count += 1
+                end
+              end
+            end
+          end
+          tests_hash
+        end
+
+        # Recibe un arreglo de rutas a las pruebas unitarias
+        # Ejecuta las pruebas unitarias y retorna el resultado como un hash
+        def run_tests(tests)
+          # Se puede ejecutar comandos en líneas de comandos usando system(cli_command) o %x|cli_command|
+          # system devuelve true, false o nil, %x devuelve la salida del comando ejecutado
+          # From:
+          #      https://www.rubyguides.com/2018/12/ruby-system/
+
+          #system("bundle exec rspec #{tests_paths} --format progress --out rspec_result.txt --no-color")
+          # El comando chdir hace que el directorio de trabajo se mueva a la carpeta en donde se descomprimió el código fuente para poder ejecutar las pruebas
+          Dir.chdir(@source_code_folder_path) do
+            # Descomentar para la depuración en entorno de desarrollo (Creo que aún así no se puede depurar)
+            # raw_tests_result = %x|bundle exec rspec #{tests.join(' ')} --format progress|
+            # Descomentar para el entorno de producción
+            raw_tests_result = ''
+            Liri::Common::Benchmarking.start(start_msg: "Ejecutando conjunto de pruebas. Espere... ") do
+              raw_tests_result = %x|bash -lc 'rvm use #{Liri.current_folder_ruby_and_gemset}; rspec #{tests.join(' ')} --format progress'|
+            end
+
+            hash_tests_result = process_tests_result(raw_tests_result)
+            hash_tests_result
+          end
+        end
+
+        private
+        def test_files
+          Dir[@tests_folder_path + "/**/*spec.rb"]
+        end
+
+        # Recibe el resultado crudo de las pruebas unitarias
+        # Procesa el resultado y lo devuelve en formato hash manejable
+        # Ejemplo del hash retornado:
+        # {example_quantity: 2, failure_quantity: 1}
+        def process_tests_result(raw_test_results)
+          result_hash = {example_quantity: 0, failure_quantity: 0}
+          flag = ''
+          raw_test_results.each_line do |line|
+            if line.strip.start_with?('Finished')
+              flag = 'Finished'
+              next
+            end
+
+            if flag == 'Finished'
+              puts ''
+              Liri.logger.info(line)
+              values = line.to_s.match(/([\d]+) example.?, ([\d]+) failure.?/)
+              result_hash[:example_quantity] = values[1].to_i
+              result_hash[:failure_quantity] = values[2].to_i
+              flag = ''
+            end
+          end
+
+          result_hash
+        end
+      end
+    end
+  end
+end

data/lib/exe/agent.rb

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+# Este archivo se usa para probar la ejecución del Agent
+require 'bundler/setup'
+require 'all_libraries'
+Liri::Agent.run()

data/lib/exe/manager.rb

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+# Este archivo se usa para probar la ejecución del Manager
+require 'bundler/setup'
+require 'all_libraries'
+Liri::Manager.run()

data/lib/hash_extend.rb

@@ -0,0 +1,57 @@
+# = hash_extend.rb
+#
+# @author Rodrigo Fernández
+#
+# == Clase Hash
+# Esta clase extiende las funcionalidades de la clase Hash de Ruby
+class Hash
+  # Retorna un hash con elementos aleatorios del hash original.
+  # @param quantity [Integer] la cantidad de elementos del nuevo hash retornado.
+  # @return [Hash] un hash con elementos aleatorios del hash original.
+  # @example
+  #   hash = {uno: 'uno', dos: 'dos', tres: 'tres'}
+  #   hash.sample
+  #     => {dos: 'dos'}
+  #   hash.sample(2)
+  #     => {uno: 'uno', tres: 'tres'}
+  def sample(quantity=1)
+    sample_keys = self.keys.sample(quantity)
+    sample_values = {}
+    sample_keys.each do |sample_key|
+      sample_values[sample_key] = self[sample_key]
+    end
+    sample_values
+  end
+
+  # Retorna un hash con elementos aleatorios del hash original y borra estos elementos del hash.
+  # @param quantity [Integer] la cantidad de elementos del nuevo hash retornado.
+  # @return [Hash] un hash con elementos aleatorios del hash original.
+  # @example
+  #   hash = {uno: 'uno', dos: 'dos', tres: 'tres'}
+  #   hash.sample
+  #     => {dos: 'dos'}
+  #   hash.sample(2)
+  #     => {uno: 'uno', tres: 'tres'}
+  def sample!(quantity=1)
+    samples = self.sample(quantity)
+    remove!(samples.keys)
+    samples
+  end
+
+  # Borra elementos del hash.
+  # @note Los elementos son borrados del hash original
+  # @param keys [Array] las claves a remover separadas por comas o en un arreglo.
+  # @return [Hash] un hash sin los elementos indicados.
+  # @example
+  #   hash = {uno: 'uno', dos: 'dos', tres: 'tres'}
+  #   hash.remove!(:uno)
+  #     => {:dos=>"dos", :tres=>"tres"}
+  #   hash.remove!(:uno, :dos, :tres)
+  #     => {}
+  #   hash
+  #     => {}
+  def remove!(*keys)
+    keys.flatten.each{|key| self.delete(key) }
+    self
+  end
+end

data/lib/liri.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+# Este modulo contiene datos del programa que son reutilizados en otras partes de la aplicacion
+module Liri
+  NAME = 'liri' # El gemspec requiere que el nombre este en minusculas
+  VERSION = '0.1.0'
+  SETUP_FOLDER_NAME = 'liri'
+  SETUP_FOLDER_PATH = File.join(Dir.pwd, '/', SETUP_FOLDER_NAME)
+  LOGS_FOLDER_NAME = 'logs'
+  MANAGER_LOGS_FOLDER_PATH = File.join(SETUP_FOLDER_PATH, '/', LOGS_FOLDER_NAME)
+  AGENT_LOGS_FOLDER_PATH = MANAGER_LOGS_FOLDER_PATH
+  AGENT_FOLDER_NAME = 'agent'
+  AGENT_FOLDER_PATH = File.join(SETUP_FOLDER_PATH, '/', AGENT_FOLDER_NAME)
+  MANAGER_FOLDER_NAME = 'manager'
+  MANAGER_FOLDER_PATH = File.join(SETUP_FOLDER_PATH, '/', MANAGER_FOLDER_NAME)
+
+  class << self
+    def setup
+      @setup ||= load_setup
+    end
+
+    def logger
+      @logger ||= load_logger
+    end
+
+    def set_logger(folder_path, file_name)
+      @logger = load_logger(folder_path, file_name)
+    end
+
+    def clear_setup
+      if @setup
+        @setup = nil
+        true
+      else
+        false
+      end
+    end
+
+    def create_folders(program)
+      Dir.mkdir(SETUP_FOLDER_PATH) unless Dir.exist?(SETUP_FOLDER_PATH)
+
+      case program
+      when 'manager'
+        Dir.mkdir(MANAGER_LOGS_FOLDER_PATH) unless Dir.exist?(MANAGER_LOGS_FOLDER_PATH)
+        Dir.mkdir(MANAGER_FOLDER_PATH) unless Dir.exist?(MANAGER_FOLDER_PATH)
+      when 'agent'
+        Dir.mkdir(AGENT_FOLDER_PATH) unless Dir.exist?(AGENT_FOLDER_PATH)
+        Dir.mkdir(AGENT_LOGS_FOLDER_PATH) unless Dir.exist?(AGENT_LOGS_FOLDER_PATH)
+      end
+    end
+
+    def clean_folder(folder_path)
+      FileUtils.rm_rf(Dir.glob(folder_path + '/*')) if Dir.exist?(folder_path)
+    end
+
+    def reload_setup
+      @setup = load_setup
+    end
+
+    def delete_setup
+      liri_setup = Liri::Manager::Setup.new(SETUP_FOLDER_PATH)
+      liri_setup.delete
+    end
+
+    def init_exit(stop, threads, program)
+      threads = threads.compact
+      kill(threads) if stop
+
+      # Con la siguiente línea se asegura que los hilos no mueran antes de que finalize el programa principal
+      # Fuente: https://underc0de.org/foro/ruby/hilos-en-ruby/
+      threads.each{|thread| thread.join}
+      #rescue SignalException => e
+      #puts "\nEjecución del #{program} terminada manualmente\n"
+      #kill(threads)
+    end
+
+    def kill(threads)
+      threads.each{|thread| Thread.kill(thread)}
+    end
+
+    def current_host_ip_address
+      addr = Socket.ip_address_list.select(&:ipv4?).detect{|addr| addr.ip_address != '127.0.0.1'}
+      addr.ip_address
+    end
+
+    def compression_class
+      "Liri::Common::Compressor::#{setup.library.compression}"
+    end
+
+    def unit_test_class
+      "Liri::Common::UnitTest::#{setup.library.unit_test}"
+    end
+
+    def udp_port
+      setup.ports.udp
+    end
+
+    def tcp_port
+      setup.ports.tcp
+    end
+
+    def current_folder_ruby_and_gemset
+      "#{File.read('.ruby-version').strip}@#{File.read('.ruby-gemset').strip}"
+    end
+
+    private
+
+    # Carga las configuraciones en memoria desde un archivo de configuracion
+    def load_setup
+      liri_setup = Liri::Manager::Setup.new(SETUP_FOLDER_PATH)
+      liri_setup.create unless File.exist?(liri_setup.path)
+      liri_setup.load
+    end
+
+    # Inicializa y configura la librería encargada de loguear
+    def load_logger(folder_path = nil, file_name = nil)
+      log = Liri::Common::Log.new('daily', folder_path: folder_path, file_name: file_name, stdout: Liri.setup.log.stdout.show)
+      log
+    end
+  end
+
+  # EXCEPTIONS
+  class FileNotFoundError < StandardError
+    def initialize(file_path)
+      msg = "No se encuentra el archivo #{file_path}"
+      super(msg)
+    end
+  end
+end

data/lib/manager/credential.rb

@@ -0,0 +1,47 @@
+require 'highline/import'
+
+module Liri
+  class Manager
+    class Credential
+      FILE_NAME = 'liri-credentials.yml'
+      def initialize(folder_path)
+        @folder_path = folder_path
+        @file_path = File.join(@folder_path, '/', FILE_NAME)
+      end
+
+      # Obtiene ususario y contraseña del sistema en el que se ejecuta el programa
+      def get
+        user, password = get_credentials
+        unless user || password
+          user, password = ask_credentials
+          save_credentials(user, password)
+        end
+        return user, password
+      end
+
+      private
+      def get_local_user
+        %x[whoami].delete!("\n")
+      end
+
+      def get_credentials
+        if File.exist?(@file_path)
+          data = YAML.load(File.read(@file_path))
+          return data['user'], data['password']
+        else
+          return nil, nil
+        end
+      end
+
+      def ask_credentials
+        local_user = get_local_user
+        password = ask("Ingrese contraseña del usuario #{local_user}: ") { |q| q.echo = "*" }
+        return local_user, password
+      end
+
+      def save_credentials(user, password)
+        File.write(@file_path, "user: #{user}\npassword: #{password}")
+      end
+    end
+  end
+end