tools 0.0.1 → 0.0.5

data/lib/lib/console.rb

@@ -0,0 +1,147 @@
+require 'singleton'
+class ToolsConsole
+  include Singleton
+
+
+  def self.create_console
+
+      extend Prompt::DSL
+
+      group "Console commands"
+
+      desc "configure"
+      param :config_type , "Config type search for roots locations...", %(location show)
+      command "config :config_type" do |config_type|
+
+        Prompt.application.prompt = "#{Tools.configuration.console_prompt} console > ".light_blue
+        puts "Choise yuor config action .:".yellow
+
+      end
+
+      desc "history"
+      command "history" do
+        File.open(@history_file, 'r') do |f|
+          while line = f.gets
+            puts line
+          end
+        end
+      end
+
+      desc "test"
+      command "test" do
+        puts 'Im a test.!'.yellow
+      end
+
+  end
+
+  def self.my_method_missing
+    ap "my_method_missing"
+  end
+
+  def self.run_console
+      Prompt.application.prompt = "#{Tools.configuration.console_prompt} console > ".light_green
+      @history_file = File.join(File.expand_path(File.dirname(__FILE__)).to_s, ".workin-history")
+      Prompt::Console.start @history_file
+  end
+
+end
+
+
+
+
+
+
+
+
+# class Console
+
+# 	def initialize(options = {})
+# 		commands
+# 	end
+
+#   def commands
+
+#   	extend Prompt::DSL 
+
+# 		group "Commands"
+
+# 		desc "config"
+# 		command "config" do ||
+# 			Prompt.application.prompt = " tools > ".light_blue
+# 		end
+
+# 		desc "show"
+# 		command "show :param" do |param|
+# 			case param
+# 			when 'config'
+# 				puts "ROOT      .: #{Tools.root}"
+# 				puts "USER      .: #{Tools.configuration.user}"
+# 				puts "HOME      .: #{Tools.configuration.home}"
+# 				puts "PWD       .: #{Tools.configuration.pwd}"
+# 				puts "ldap_user .: #{Tools.configuration.ldap_user}"
+# 				puts "ldap_pass .: #{Tools.configuration.ldap_pass}"
+# 				Tools.configuration.info.each do |k,v|
+# 					ap k
+# 					ap v
+# 				end
+# 			else 
+# 				ap Tools.get_variable param
+# 			end
+# 		end
+
+# 		desc "rsync"
+# 		command "rsync :from :to" do |from, to|
+
+# ap Tools.configuration.info[:directorys_to][from].nil?
+
+# 			unless Tools.configuration.info[:directorys_to][from].nil?
+# 			 from = Tools.configuration.info[:directorys_to][from]
+# 			 from += ask("?? ") 
+# 			else
+# 				sourcefiles = File.join("**", from)
+# 				Dir.glob(sourcefiles).each do |source|
+# 					ap source
+# 				end
+# 			end
+
+# ap from
+
+# 					# if File.file?(source)
+# 					# 	result = Rsync.run(source, dest)
+# 					# 	ap result
+# 					# end
+
+# 		end
+
+# 		desc "connect"
+# 		command "connect :host" do |host|
+# 			if host.split('@').size == 2
+# 				user = host.split('@')[0]
+# 				host = host.split('@')[1]
+# 			else
+# 				unless Tools.configuration.info[:servers][host].nil?
+# 					user = Tools.configuration.info[:servers][host].split('@')[0]
+# 					host = Tools.configuration.info[:servers][host].split('@')[1]
+# 				else
+# 					ap "No hosts selected! Exiting..."
+# 				end
+# 			end
+# 			ssh = Tools.ssh_connect_knowhost host, user
+# 			Tools.set_variable 'ssh', ssh
+# 		end
+
+
+# 		desc "cmd"
+# 		command "cmd :variable :command " do |variable, command|
+# 			ssh = Tools.get_variable 'ssh'
+# 			Tools.set_variable variable, (Tools.ssh_cmd ssh, command).split("\n")
+# 		end
+
+
+# 		Prompt.application.prompt = " tools > ".light_red
+# 		history_file = ".tools-history"  
+# 		Prompt::Console.start history_file
+
+#   end
+
+# end

data/lib/lib/display.rb

@@ -0,0 +1,41 @@
+require 'singleton'
+class ToolsDisplay
+  include Singleton
+
+  # Tools to awesome prints
+  #
+  # ToolsDisplay.show "teste"
+  # ToolsDisplay.show "TEXT SAMELINE sem cor ", :sameline
+  # ToolsDisplay.show "TEXT GREEN", :green
+  # ToolsDisplay.show "TEXT YELLOW", :yellow
+  #
+  # @param arguments
+  # @return [String] printed
+  def self.show *arguments
+    post = arguments[0]
+    unless (post.class == String)
+      return post.class.to_s
+    end
+
+    color     = arguments.extract_color
+    sameline  = arguments.extract_symbol :sameline
+    nocolor   = arguments.extract_symbol :nocolor
+    colorized = arguments.extract_symbol :colorized
+
+    unless sameline
+      post += "\n"
+    end
+    unless nocolor
+      printf "#{post}".colorize(color)
+    else
+      if colorized
+        ap post
+      else
+        printf "#{post}"
+      end
+    end
+
+  end
+
+
+end

data/lib/lib/files.rb

@@ -0,0 +1,51 @@
+require 'singleton'
+class ToolsFiles
+  include Singleton
+
+  def initialize(options = {})
+  end
+
+
+  # Create a directory in work area
+  #
+  #  Sample
+  # ToolsFiles.create_dir Tools.home + '/2018/xykotools/tools/home', 'tools_home'
+  # home = (ToolsUtil.get_variable 'tools_home') => ~/2018/xykotools/tools/home
+  #
+  # @param directory
+  # @param directory_name
+  # @return
+  def self.create_dir directory, directory_name
+    unless directory.end_with? '/'
+      directory += '/'
+    end
+    complete_file = (directory + '/').gsub('//','/')
+    unless File.exists? complete_file
+      Dir.mkdir(complete_file)
+    end
+    ToolsUtil.set_variable directory_name, complete_file
+  end
+
+  # Create a file in work area
+  #
+  #  Sample
+  #
+  #  ToolsFiles.create_file home, 'xyko_file.txt', 'xyko_file'
+  #  xyko = (ToolsUtil.get_variable 'xyko_file') => ~/2018/xykotools/tools/home/xyko_file.txt
+  #
+  # @param directory
+  # @param file_name
+  # @param file_name_set
+  # @return
+  def self.create_file directory, file_name, file_name_set
+    complete_file = (directory + '/' + file_name).gsub('//','/')
+    unless File.exists? complete_file
+      file = File.open( complete_file , 'w')
+    end
+    ToolsUtil.set_variable file_name_set, complete_file
+  end
+
+
+
+
+end

data/lib/lib/log.rb

@@ -0,0 +1,66 @@
+require 'singleton'
+class ToolsLog
+  include Singleton
+
+  def initialize(options = {})
+
+  end
+
+
+  # Create a Log file in work area
+  #
+  #  Sample
+  #
+  #  ToolsLog.create_log_file 'sample', '/myhome/tools/sample.log'
+  #  log = ToolsUtil.get_variable "sample_logger" => Logger Object
+  #
+  #  ToolsLog.create_log_file 'xyko', '/home/francisco/2018/xykotools/tools/xyko.log'
+  #  ToolsLog.xyko_info 'teste do methodo1', :light_yellow
+  #  ToolsLog.xyko_warn 'teste do methodo2'
+  #  ToolsLog.xyko_error 'teste do methodo3'
+  #  ToolsLog.xyko_debug 'teste do methodo4'
+  #
+  # @param logname
+  # @param logfile
+  # @return
+  def self.create_log_file log_name, log_file
+    if File.exists? log_file
+      unless File.ctime(log_file).to_date == Time.now.to_date
+        File.delete(log_file)
+      end
+    end
+    ToolsUtil.set_variable "#{log_name}_log_file", log_file
+    ToolsUtil.set_variable "#{log_name}_logger", Logger.new(log_file, 'daily')
+    (ToolsUtil.get_variable "#{log_name}_logger").formatter = proc do |severity, datetime, progname, msg|
+      "#{severity.chars.first} #{datetime.strftime "%H:%M:%S"}: #{msg}\n"
+    end
+    #ToolsUtil.purge_files Tools.home+'/.tools/backup', '*', 14*24*60*60
+  end
+
+  def self.method_missing(method, *args, &block)
+    #expected call format =>    STRING_LOGGER_TYPE + '_' + LOGGER_TYPE
+    # Ex.:  tools_info
+    logger_name   = method.to_s.split('_').first
+    logger_method = method.to_s.split('_').last
+    logger        = ToolsUtil.get_variable "#{logger_name}_logger"
+    color         = args.extract_color
+    if color.eql? :default
+      case logger_method
+        when 'info'
+          color = :cyan
+        when 'warn'
+          color = :yellow
+        when 'debug'
+          color = :green
+        when 'error'
+          color = :light_red
+        when 'exit'
+          log_file =  ToolsUtil.get_variable "#{logger_name}_log_file"
+          ToolsDisplay.show "\tError in ToolsUtil. See details in '#{log_file}'", :light_yellow
+          exit
+      end
+    end
+    logger.method(logger_method).call args.first.colorize(color)
+  end
+
+end

data/lib/lib/net.rb

@@ -0,0 +1,141 @@
+require 'singleton'
+class ToolsNet
+  include Singleton
+
+
+  # Resolv a ip to a dns.
+  #
+  # @param           ip variable ip to resolv
+  # @return [String] Dns name resolved
+  def self.resolv_ip_name ip
+    s = ''
+    begin
+      ret = Resolv.new.getname(ip)
+      return ret.instance_variable_get('@labels').join('.')
+    rescue Exception => e
+      s = 'edi error: ' + e.message
+    end
+    return s.strip
+  end
+
+
+  # Resolv a dns to a ip.
+  #
+  # @param domain variable ip to resolv
+  # @return [String] Dns address resolved
+  def self.resolv_dns domain
+    begin
+      dns = Dnsruby::DNS.new()
+      ret = dns.getaddress(domain).to_s
+    rescue Exception => e
+      case e.message
+        when "Dnsruby::NXDomain"
+          ret = nil
+        else
+          ret = e.message
+      end
+    end
+    return ret
+  end
+
+
+  # Do the request, validate and decode response and do the retries if needed
+  #
+  # - restclient_obj: initialized RestClient object
+  # - path: URL path to request
+  # - method: symbol for HTTP Method to request
+  # - method_opts: options as passed to a RestClient call
+  # - validate_opts: options for response validation as used with
+  # validate_decode_response()
+  # - retry_opts: when_res: [nil, [], {}, 'str'], when_code: [404, 500],
+  # conditionals to retry even if no exceptions were catched
+  # @param restclient_obj Rest Object
+  # @param path           path
+  # @param method         method
+  # @param caller         caller
+  # @param method_opts    method opts
+  # @param validate_opts  validate opts
+  # @param retry_opts     retry opts
+  # @param show_progress  default false
+  def self.doreq( restclient_obj, path, method, caller, method_opts: {},validate_opts: {}, retry_opts: {}, show_progress: false)
+    res = nil
+    code = nil
+    data = method_opts.fetch(:data, nil)
+    method_opts.delete(:data)
+
+    # Retry loop due to:
+    # - 404 from Router API right after applying patch over a target
+    # - Intermittent connection reset from Manager API (HTTPS)
+    retries = retry_opts.fetch(:attempts, 10)
+    1.upto(retries) do |try|
+      flag_error = false
+      # The request
+      begin
+        restclient_obj[path].send(method, *data, **method_opts) do |response, request, result|
+          res  = validate_decode_response(response, request, result, validate_opts)
+          code = result.code.to_i
+        end
+      rescue Exception => error
+        ap error
+        flag_error = true
+      end
+      # Other conditionals to retry
+      unless retry_opts.empty?
+        if retry_opts.has_key?(:when_res)
+          flag_error = true if retry_opts[:when_res].include?(res)
+        end
+        if retry_opts.has_key?(:when_code)
+          flag_error = true if retry_opts[:when_code].include?(code)
+        end
+      end
+      return res unless flag_error # got response, break the loop
+      doReqMSG = sprintf "%d/%d", try, retries
+      if show_progress
+         ap doReqMSG
+      end
+      if try >= retries
+        ap doreq_code
+        return nil
+      else
+        sleep 1 # wait before next
+      end
+    end
+  end
+
+
+  # Return a valid decode response.
+  #
+  # @param   response
+  # @param   request
+  # @param   result
+  # @param   validate_opts
+  # @return [Object type] Array or Proc or String or Error
+  def self.validate_decode_response response, request, result, validate_opts
+    if validate_opts.has_key? :expected
+      expected = validate_opts[:expected]
+      case expected.class.name
+      when 'Array'
+        if validate_opts[:expected].include? response
+          return true
+        else
+          return false
+        end
+      when 'Proc'
+        response = expected.call(response, request, result)
+        return response
+      when 'String'
+        return result   if validate_opts[:expected].eql? 'result'
+        return request  if validate_opts[:expected].eql? 'request'
+        return response if validate_opts[:expected].eql? 'response'
+      else
+        ap expected.class.name
+        return response
+      end
+    else
+      return response
+    end
+    return true
+  end
+
+
+end