teuton 0.0.1

data/lib/teuton/project/laboratory/show.rb

@@ -0,0 +1,161 @@
+require 'terminal-table'
+require 'rainbow'
+
+require_relative '../../application'
+require_relative '../configfile_reader'
+
+# Laboratory
+# * show_dsl
+# * show_stats
+# * show_config
+class Laboratory
+  def show_dsl
+    @verbose = true
+    process_content
+    show_stats
+    show_config
+  end
+
+  def show_stats
+    @stats[:hosts] = 0
+    @hosts.each_pair { |_k, v| @stats[:hosts] += v }
+
+    my_screen_table = Terminal::Table.new do |st|
+      st.add_row ['DSL Stats', 'Count']
+      st.add_separator
+      st.add_row ['Groups', @stats[:groups]]
+      st.add_row ['Targets', @stats[:targets]]
+      st.add_row ['Goto', @stats[:hosts]]
+      @hosts.each_pair { |k, v| st.add_row [" * #{k}", v] }
+      st.add_row ['Uniques', @stats[:uniques]]
+      st.add_row ['Logs', @stats[:uniques]]
+      st.add_row [' ', ' ']
+
+      st.add_row ['Gets', @stats[:gets]]
+      if @gets.count > 0
+        list = @gets.sort_by { |_k, v| v }
+        list.reverse_each { |item| st.add_row [" * #{item[0]}", item[1].to_s] }
+      end
+
+      st.add_row ['Sets', @stats[:sets]]
+      if @sets.count > 0
+        @sets.each_pair { |k, v| st.add_row [" * #{k}", v.to_s] }
+      end
+    end
+    verboseln my_screen_table.to_s + "\n"
+  end
+
+  def show_config
+    @verbose = false
+    process_content
+    @verbose = true
+    revise_config_content
+  end
+
+  def show_requests
+    @verbose = false
+    process_content
+    @verbose = true
+    my_screen_table = Terminal::Table.new do |st|
+      st.add_row ['Lines', 'REQUEST description']
+      st.add_separator
+      @requests.each_with_index do |line, index|
+        st.add_row ['%03d' % index, line]
+      end
+    end
+    verboseln my_screen_table
+  end
+
+  private
+
+  def verbose(text)
+    print text if @verbose
+  end
+
+  def verboseln(text)
+    puts text if @verbose
+  end
+
+  def process_content
+    groups = Application.instance.groups
+    verboseln ''
+    groups.each do |t|
+      @stats[:groups] += 1
+
+      msg = "GROUP: #{t[:name]}"
+      my_screen_table = Terminal::Table.new { |st| st.add_row [msg] }
+      verboseln my_screen_table
+
+      instance_eval(&t[:block])
+    end
+  end
+
+  def find_script_vars
+    script_vars = [:tt_members]
+    @hosts.each_key do |k|
+      next if k == :localhost
+
+      if k.class == Symbol
+        script_vars << (k.to_s + '_ip').to_sym
+        script_vars << (k.to_s + '_username').to_sym
+        script_vars << (k.to_s + '_password').to_sym
+      else
+        script_vars << k.to_s + '_ip'
+        script_vars << k.to_s + '_username'
+        script_vars << k.to_s + '_password'
+      end
+    end
+    @gets.each_key { |k| script_vars << k }
+    script_vars
+  end
+
+  def recomended_config_content
+    verbose Rainbow('[WARN] File ').yellow
+    verbose Rainbow(@path[:config]).yellow.bright
+    verboseln Rainbow(' not found!').yellow
+    verboseln '[INFO] Recomended content:'
+    output = { global: nil, cases: [] }
+    output[:cases][0] = {}
+    script_vars = find_script_vars
+    script_vars.each { |i| output[:cases][0][i] = 'VALUE' }
+    verboseln YAML.dump(output)
+  end
+
+  def revise_config_content
+    @verbose = true
+    my_screen_table = Terminal::Table.new do |st|
+      st.add_row ['Revising CONFIG file']
+    end
+    verboseln my_screen_table
+
+    unless File.exist?(@path[:config])
+      recomended_config_content
+      return
+    end
+
+    script_vars = find_script_vars
+    config_vars = ConfigFileReader.read(@path[:config])
+    unless config_vars[:global].nil?
+      config_vars[:global].each_key { |k| script_vars.delete(k) }
+    end
+    unless config_vars[:alias].nil?
+      config_vars[:alias].each_key { |k| script_vars.delete(k) }
+    end
+
+    config_vars[:cases].each_with_index do |item, index|
+      next if item[:tt_skip] == true
+
+      script_vars.each do |value|
+        next unless item[value].nil?
+
+        next unless @sets[':' + value.to_s].nil?
+
+        verbose Rainbow('  * Define ').red
+        verbose Rainbow(value).red.bright
+        verbose Rainbow(' value for Case[').red
+        verbose Rainbow(index).red.bright
+        verboseln Rainbow('] or set tt_skip = true').red
+      end
+    end
+  end
+end

data/lib/teuton/project/name_file_finder.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require 'rainbow'
+require_relative '../application'
+
+# Project:
+# * find_filenames_for, verbose, verboseln
+module NameFileFinder
+  def self.find_filenames_for(relpathtofile)
+    pathtofile = File.absolute_path(relpathtofile)
+
+    # Define:
+    #   script_path, must contain fullpath to DSL script file
+    #   config_path, must contain fullpath to YAML config file
+    if File.directory?(pathtofile)
+      # COMPLEX MODE: We use start.rb as main RB file
+      find_filenames_from_directory(pathtofile)
+    else
+      # SIMPLE MODE: We use pathtofile as main RB file
+      find_filenames_from_rb(pathtofile)
+    end
+    true
+  end
+
+  def self.find_filenames_from_directory(pathtodir)
+    # COMPLEX MODE: We use start.rb as main RB file
+    script_path = File.join(pathtodir, 'start.rb')
+    unless File.exist? script_path
+      print Rainbow('[ERROR] File ').red
+      print Rainbow(script_path).bright.red
+      puts Rainbow(' not found!').red
+      exit 1
+    end
+
+    app = Application.instance
+    app.project_path = pathtodir
+    app.script_path = script_path
+    app.test_name = pathtodir.split(File::SEPARATOR)[-1]
+
+    find_configfilename_from_directory(pathtodir)
+  end
+
+  def self.find_configfilename_from_directory(pathtodir)
+    # COMPLEX MODE: We use config.yaml by default
+    app = Application.instance
+
+    config_path = ''
+    if app.options['cpath'].nil?
+      config_name = 'config'
+      # Config name file is introduced by cname arg option from teuton command
+      config_name = app.options['cname'] unless app.options['cname'].nil?
+      config_path = File.join(pathtodir, "#{config_name}.json")
+      unless File.exist? config_path
+        config_path = File.join(pathtodir, "#{config_name}.yaml")
+      end
+    else
+      # Config path file is introduced by cpath arg option from teuton command
+      config_path = app.options['cpath']
+    end
+    app.config_path = config_path
+  end
+
+  def self.find_filenames_from_rb(script_path)
+    # SIMPLE MODE: We use script_path as main RB file
+    # This must be fullpath to DSL script file
+    if File.extname(script_path) != '.rb'
+      print Rainbow('[ERROR] Script ').red
+      print Rainbow(script_path).bright.red
+      puts Rainbow(' must have rb extension').red
+      exit 1
+    end
+
+    app = Application.instance
+    app.project_path = File.dirname(script_path)
+    app.script_path = script_path
+    app.test_name = File.basename(script_path, '.rb')
+
+    find_configfilenames_from_rb(script_path)
+  end
+
+  def self.find_configfilenames_from_rb(script_path)
+    # SIMPLE MODE: We use script_path as main RB file
+    # This must be fullpath to DSL script file
+    app = Application.instance
+
+    config_path = ''
+    if app.options['cpath'].nil?
+      config_name = File.basename(script_path, '.rb')
+      # Config name file is introduced by cname arg option from teuton command
+      config_name = app.options['cname'] unless app.options['cname'].nil?
+
+      config_path = File.join(app.project_path, config_name + '.json')
+      unless File.exist? config_path
+        config_path = File.join(app.project_path, config_name + '.yaml')
+      end
+    else
+      # Config path file is introduced by cpath arg option from teuton command
+      config_path = app.options['cpath']
+    end
+    app.config_path = config_path
+  end
+
+  def self.puts_input_info_on_screen
+    app = Application.instance
+
+    verbose Rainbow('[INFO] ScriptPath => ').blue
+    verboseln Rainbow(trim(app.script_path)).blue.bright
+    verbose Rainbow('[INFO] ConfigPath => ').blue
+    verboseln Rainbow(trim(app.config_path)).blue.bright
+    verbose Rainbow('[INFO] TestName   => ').blue
+    verboseln Rainbow(trim(app.test_name)).blue.bright
+  end
+
+  def self.trim(input)
+    output = input.to_s
+    output = "...#{input[input.size - 50, input.size]}" if output.size > 65
+    output.to_s
+  end
+
+  def self.verboseln(text)
+    verbose(text + "\n")
+  end
+
+  def self.verbose(text)
+    return unless Application.instance.verbose
+    return if Application.instance.options['quiet']
+    print text
+  end
+end

data/lib/teuton/project/project.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative '../application'
+require_relative 'name_file_finder'
+
+# Project functions invoked by CLI project tool
+# * test
+# * play
+# * process_input_case_option
+# * readme
+# * require_dsl_and_script
+module Project
+  def self.test(pathtofile, options)
+    Application.instance.options.merge! options
+    NameFileFinder.find_filenames_for(pathtofile)
+    NameFileFinder.puts_input_info_on_screen
+    require_dsl_and_script('laboratory/laboratory') # Define DSL keywords
+
+    app = Application.instance
+    lab = Laboratory.new(app.script_path, app.config_path)
+    # lab.show_requests if options[:r]
+    lab.show_config if options[:c]
+    lab.show_dsl unless options[:r] || options[:c]
+  end
+
+  def self.play(pathtofile, options)
+    Application.instance.options.merge! options
+    process_input_case_option
+    NameFileFinder.find_filenames_for(pathtofile)
+    NameFileFinder.puts_input_info_on_screen
+    require_dsl_and_script('../case_manager/dsl') # Define DSL keywords
+  end
+
+  def self.process_input_case_option
+    options = Application.instance.options
+    unless options['case'].nil?
+      a = options['case'].split(',')
+      options['case'] = a.collect! { |i| i.to_i }
+    end
+  end
+
+  def self.readme(pathtofile, options)
+    Application.instance.options.merge! options
+    NameFileFinder.find_filenames_for(pathtofile)
+    require_dsl_and_script('readme/readme') # Define DSL keywords
+
+    app = Application.instance
+    readme = Readme.new(app.script_path, app.config_path)
+    readme.show
+  end
+
+  def self.require_dsl_and_script(dslpath)
+    app = Application.instance
+    require_relative dslpath
+    begin
+      require_relative app.script_path
+    rescue SyntaxError => e
+      puts e.to_s
+      puts Rainbow.new("[ERROR] SyntaxError into file #{app.script_path}").red
+    end
+  end
+end

data/lib/teuton/project/project_creator.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'rainbow'
+
+# Project#create
+# * create
+# * create_main_dir_and_files
+# * create_assets_dir_and_files
+# * create_dir
+# * create_dirs
+# * copyfile
+module ProjectCreator
+  def self.create(project_dir)
+    project_name = File.basename(project_dir)
+    puts "\n[INFO] Creating #{Rainbow(project_name).bright} project skeleton"
+
+    source_basedir = File.join(File.dirname(__FILE__), '../..')
+    create_dir project_dir
+
+    create_main_dir_and_files(project_dir, source_basedir)
+    create_assets_dir_and_files(project_dir, source_basedir)
+  end
+
+  def self.create_main_dir_and_files(project_dir, source_basedir)
+    # Directory and files: Ruby script, Configfile, gitignore
+    items = [
+      { source: 'lib/files/config.yaml', target: 'config.yaml' },
+      { source: 'lib/files/start.rb', target: 'start.rb' },
+      { source: 'lib/files/README.md', target: 'README.md' },
+      { source: 'lib/files/gitignore', target: '.gitignore' }
+    ]
+    items.each do |item|
+      source = File.join(source_basedir, item[:source])
+      target = File.join(project_dir, item[:target])
+      copyfile(source, target)
+    end
+  end
+
+  def self.create_assets_dir_and_files(project_dir, source_basedir)
+    # Assets Directory and files
+    project_assets_dir = File.join(project_dir, 'assets')
+    create_dir project_assets_dir
+#    source = File.join(source_basedir, 'lib/files/README.md')
+#    target = File.join(project_dir, 'README.md')
+#    copyfile(source, target) # README.md
+    puts ''
+  end
+
+  def self.create_dir(dirpath)
+    if Dir.exist? dirpath
+      puts "* Exists dir!       => #{Rainbow(dirpath).yellow}"
+    else
+      begin
+        FileUtils.mkdir_p(dirpath)
+        puts "* Create dir        => #{Rainbow(dirpath).green}"
+      rescue StandarError
+        puts "* Create dir  ERROR => #{Rainbow(dirpath).red}"
+      end
+    end
+  end
+
+  def self.create_dirs(*args)
+    args.each { |arg| create_dir arg }
+  end
+
+  def self.copyfile(target, dest)
+    if File.exist? dest
+      puts "* Exists file!      => #{Rainbow(dest).yellow}"
+    else
+      begin
+        FileUtils.cp(target, dest)
+        puts "* Create file       => #{Rainbow(dest).green}"
+      rescue StandarError
+        puts "* Create file ERROR => #{Rainbow(dest).red}"
+      end
+    end
+  end
+end

data/lib/teuton/project/readme/dsl.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+# Readme
+# * target
+# * goto
+# * run
+# * expect
+# * unique
+# * log
+class Readme
+  def readme(text)
+    if @action[:target].nil?
+      # It's a group readme
+      @current[:readme] << text
+    else
+      # It's a target readme
+      @action[:readme] << text
+    end
+  end
+
+  def target(desc, args = {})
+    previous_host = @action[:host]
+    @action = { target: desc, host: previous_host, readme: [] }
+    weight = 1.0
+    weight = args[:weight].to_f if args[:weight]
+    @action[:weight] = weight
+  end
+  alias goal target
+
+  def goto(host = :localhost, args = {})
+    unless host == :localhost
+      b = {}
+      a = "#{host}_ip".to_sym
+      if @config[:global][a].nil? && (not @setted_params.include?(a))
+        @cases_params << a
+      end
+      b[:ip] = @config[:global][a] if @config[:global][a]
+      b[:ip] = @setted_params[a] if @setted_params[a]
+
+      a = "#{host}_username".to_sym
+      if @config[:global][a].nil? && (not @setted_params.include?(a))
+        @cases_params << a
+      end
+      b[:username] = @config[:global][a] if @config[:global][a]
+      b[:username] = @setted_params[a] if @setted_params[a]
+
+      a = "#{host}_password".to_sym
+      if @config[:global][a].nil? && (not @setted_params.include?(a))
+        @cases_params << a
+      end
+      b[:password] = @config[:global][a] if @config[:global][a]
+      b[:password] = @setted_params[a] if @setted_params[a]
+
+      @required_hosts[host.to_s] = b
+    end
+    @action[:host] = host
+    @action[:exec] = args[:exec] || 'noexec'
+  end
+
+  def run(command, args = {})
+    args[:exec] = command
+    goto(:localhost, args)
+  end
+
+  def expect(_cond, args = {})
+    @current[:actions] << @action
+    result.reset
+  end
+  alias expect_any expect
+  alias expect_none expect
+  alias expect_one expect
+
+  def get(value)
+    unless @config[:global][value].nil?
+      @global_params[value] = @config[:global][value]
+      return @config[:global][value]
+    end
+
+    return value.to_s.upcase if @setted_params.include? value
+
+    @cases_params << value
+    value.to_s.upcase
+  end
+
+  # If a method call is missing, then delegate to concept parent.
+  def method_missing(method)
+    a = method.to_s
+    instance_eval("get(:#{a[0, a.size - 1]})") if a[a.size - 1] == '?'
+  end
+
+  def gett(value)
+    a = get(value)
+    return "[#{value}](\#required-params)" if @cases_params.include? value
+    return "[#{value}](\#created-params)" if @setted_params[value]
+    "[#{a}](\#global-params)" if @global_params.include? value
+  end
+
+  def set(key, value)
+    @setted_params[key] = value
+  end
+
+  def unique(_key, _value)
+    # don't do nothing
+  end
+
+  def log(text = '', type = :info)
+    @data[:logs] << "[#{type}]: " + text.to_s
+  end
+end

data/lib/teuton/project/readme/lang.rb

@@ -0,0 +1,30 @@
+
+require_relative '../../application'
+
+module Lang
+  def self.get(key)
+    lang = {}
+    lang['en'] = {
+      version:  'Teuton version : %s',
+      testname: 'Challenge name : %s',
+      date:     'Date           : %s',
+      hosts:    "\n\#\#\# Required hosts\n",
+      params:   "\n\#\#\# Required params\n",
+      goto:     "\nGo to [%s](\#required-hosts) host, and do next:\n",
+      global:   "\nGlobal parameters that can be modified:\n",
+      created:  "\nParams created during challenge execution:\n"
+    }
+    lang['es'] = {
+      version:  'Versión de Teuton : %s',
+      testname: 'Nombre del reto   : %s',
+      date:     'Fecha             : %s',
+      hosts:    "\n\#\#\# Máquinas que se necesitan\n",
+      params:   "\n\#\#\# Parámetros de necesarios\n",
+      goto:     "\nIr a la máquina [%s](\#required-hosts), y hacer lo siguiente:\n",
+      global:   "\nParámetros globales que pueden ser modificados:\n",
+      created:  "\nParámetros creados durante la ejecución del reto:\n"
+    }
+    locale = Application.instance.options['lang'].downcase
+    lang[locale][key]
+  end
+end