irgat 0.0.1 → 0.0.2

data/lib/irgat/console.rb

@@ -82,4 +82,4 @@ if @console.config_module[:load_modules] == "all"
   }
 end
 
-puts "** Console enable modules => #{ enable_modules.join(', ') }"
+puts "** Console enable modules => #{ enable_modules.join(', ') }"

data/lib/irgat/dependencies.rb

@@ -17,9 +17,9 @@ module Irgat
       @programs = Hash.new
       programs.each { |p|
         # locate program
-        program_path = %x[ which #{p} ]
-        if program_path
-          @programs[p.to_sym] = program_path.strip
+        program_path = execute_command("which #{ p }","Where is #{ p } program", { :debug => 3 })
+        if program_path[:output]
+          @programs[p.to_sym] = program_path[:output].strip
         else
           exit_with_error("Irgat couldn't find the program #{ p } needed by #{ self.class } module")
         end
@@ -45,20 +45,25 @@ module Irgat
     end
 
     def check_mounted_folder(folder)
-      mount_points = execute_command("mount","Getting mount points")
-      if mount_points.include?(folder)
+      mount_points = execute_command("mount", 
+                                     "Getting mount points",
+                                     { :debug => 3 })
+      if mount_points[:output].include?(folder)
         log("text","OK. #{folder} already mounted")
       else
         # we try to mount
-        log("text","Warning. #{folder} not mounted. Triying to mount")
+        log("text", "Warning. #{folder} not mounted. Triying to mount", 2)
         execute_command("mount #{folder}", 
                         "Mounting working directory #{folder}",
-                        {:fatal_error => true})
+                        {:fatal_error => true, :debug => 3 })
       end
     end
 
     def check_egid(user)
-      if user != execute_command("whoami", "Getting irgat launcher user", 3).strip
+      command = execute_command("whoami",
+                                "Getting irgat launcher user",
+                                { :debug => 3 })
+      if user != command[:output].strip
         exit_with_error("#{ @config_module[:subsystem_name] } Irgat module must run as #{ user } User")
       end
     end
@@ -67,7 +72,7 @@ module Irgat
     def exist_or_create_folder(folder_absolute_path)
       if ! test(?d,folder_absolute_path)
         Dir.mkdir(folder_absolute_path)
-        log("text", "Creating folder #{ folder_absolute_path }", 2)
+        log("text", "Creating folder #{ folder_absolute_path }", 3)
       end
     end
 

data/lib/irgat/execs.rb

@@ -4,66 +4,63 @@ module Irgat
   module Execs
 
     def execute_command(command, command_description, options = {})
-      @commands_launched ||= Hash.new
+      @commands_launched ||= Array.new
 
-      command_exec     = command.to_s
-      pre_command_time = Time.now
-      command_output   = %x[ #{command_exec} 2> /tmp/error_out ]
-      finish_status    = $?
-      pos_command_time = Time.now
-      error_output     = File.new("/tmp/error_out").read
+      command_data     = Hash.new
+
+      command_data[:info]     = command_description
+      command_data[:exec]     = command.to_s
+      command_data[:pre_time] = Time.now
+      command_data[:output]   = %x[ #{command_data[:exec]} 2> /tmp/error_out ]
+      command_data[:status]   = $?
+      command_data[:pos_time] = Time.now
+      command_data[:errors]   = File.new("/tmp/error_out").read
+
+      # add to commands launched
+      @commands_launched << { command_data[:info] => command_data[:status] }
 
       # exit?
-      if finish_status != 0 && options[:fatal_error]
+      if command_data[:status] != 0 && options[:fatal_error]
         debug_mode = "\n"
-        debug_mode << "\n [ Command Syntax ] => #{ command_exec }"
-        debug_mode << "\n [ Command Output ] => #{ command_output }"
-        debug_mode << "\n [ Command Errors ] => #{ error_output }"
+        debug_mode << "\n [ Command Syntax ] => #{ command_data[:exec]   }"
+        debug_mode << "\n [ Command Output ] => #{ command_data[:output] }"
+        debug_mode << "\n [ Command Errors ] => #{ command_data[:errors] }"
 
-        exit_with_error("Command '#{ command_description }' exit with a #{ finish_status } status. Error is reported as FATAL, then, exit Irgat process. #{ debug_mode if @config[:debug_level] == 3 }")
+
+        exit_with_error("Command '#{ command_data[:info] }' exit with a #{ command_data[:status] } status. Error is reported as FATAL, then, exit Irgat process. #{ debug_mode if @config[:debug_level] == 3 }", { :exit_level => 6 })
       end
 
       # Log the outputs || debug 1
-      log("command", "* [#{ (finish_status == 0 ? "   OK   " : " WARNING") }: #{Time.now.strftime("%H:%M:%S")}] -> #{ command_description }", 1)
+      log("command", "* [#{ (command_data[:status] == 0 ? "   OK   " : " WARNING") }: #{Time.now.strftime("%H:%M:%S")}] -> #{ command_data[:info] }", 1) unless options[:debug] == 2 || options[:debug] == 3
 
       # Log warning level
-      if finish_status != 0
-        log("warning", "Command #{ command_description } exited with a #{ finish_status } status.", 2)
+      if command_data[:status] != 0
+        log("warning", "  ** Command #{ command_data[:info] } exited with a #{ command_data[:status] } status.", 2)
       end
 
       # Log 3 level... commands launched and reports
-      text_to_log =  "\n   ** [COMMAND LOG]"
-      text_to_log << "\n       [ Command Syntax ] => #{ command_exec   }"
-      text_to_log << "\n       [ Command Status ] => #{ finish_status  }"
-      text_to_log << "\n       [ Command Output ] => #{ command_output }"
-      text_to_log << "\n       [ Command Errors ] => #{ error_output   }"
-      text_to_log << "\n       [ Command P.Time ] => #{ pos_command_time - pre_command_time }\n\n"
+      text_to_log =  "\n   *** [COMMAND LOG]"
+      text_to_log << "\n        [ Command Syntax ] => #{ command_data[:exec]   }"
+      text_to_log << "\n        [ Command Status ] => #{ command_data[:status]  }"
+      text_to_log << "\n        [ Command Output ] => #{ command_data[:output] }"
+      text_to_log << "\n        [ Command Errors ] => #{ command_data[:errors]   }"
+      text_to_log << "\n        [ Command P.Time ] => #{ command_data[:pos_time] - command_data[:pre_time] }\n\n"
 
       log("text", text_to_log, 3)
 
-      # add the command to the commands_launched hash
-      @commands_launched[command_description] = finish_status
-
-      return command_output
+      return command_data
     end
 
-    # method to end irgat process and report
-    def finish_process(options = {})
-      output_options = Hash.new
-      output_options[:fatal]    = options[:fatal]   || false
-      output_options[:main_msj] = options[:msj] || "Finish Process"
-      # output the logs
-      output_log({ :fatal => output_options[:fatal], 
-                   :main_msj => output_options[:main_msj] })
-    end
 
     # Exit irgat process with error and optional exit status
     def exit_with_error(msj, options = {})
-      
-      log("text", msj, 1)
-      
-      finish_process( { :fatal => true, :msj => "Exit with error #{ msj }" } ) unless options[:no_finish_process]
-      
+      log("error", msj, 1)
+
+
+      output_log(self,
+                { :main_msj => "[IRGAT] [#{ self.config_module[:subsystem_name].capitalize }] [ERROR] #{ self.action } process in #{ @config[:server_name] }",
+                  :fatal => true })
+
       exit (options[:exit_level] ? options[:exit_level] : 1)
     end
 

data/lib/irgat/log.rb

@@ -3,47 +3,49 @@
 module Irgat
   module Log
 
+    # Store the output messages in a class array variable
     def log(output_type, message, debug = nil)
-      # create @log_process if not exist or use it
       @log_process ||= Array.new
       # add new hash to point variable
       log_point = Hash.new
       log_point[:type]  = output_type
       log_point[:msj]   = message
-      log_point[:debug] = debug || 3
+      log_point[:debug] = debug.to_i || 3  # highter level if not marked
       @log_process << log_point
-      # need to puts
 
-      if @log_to_stdout && @config[:debug_level] >= log_point[:debug]
-        puts "[#{ log_point[:type] }] \n  #{ log_point[:msj] }"
+      # to stodout
+      unless @config[:debug_level].to_i < log_point[:debug]
+        puts colorize(log_point)
       end
     end
 
-    def output_log(options = {})
+    def output_log(module_process, options = {})
+
       fatal = options[:fatal] || false
 
       # build report
-      report = build_report
-      resume = build_resume(fatal)
+      report = build_report(module_process.log_process)
+      resume = build_resume(fatal, module_process)
 
-      if @config_module[:output_log]
-        # add a extend header to the log report
-        report_to_log(report)
+      # output to email or log file
+      if module_process.config_module[:log_file_actions].include?(module_process.action)
+        report_to_log(report, module_process)
       end
 
-      if @config_module[:output_email]
+      if module_process.config_module[:log_file_actions].include?(module_process.action)
         report_to_email(resume, report, options[:main_msj] )
       end
+
     end
 
-    def report_to_log(report)
+    def report_to_log(report, module_process)
       exist_or_create_folder(@config[:log_path])
 
-      log_file_folder = "#{ @config[:log_path] }/#{ @config_module[:subsystem_name] }"
+      log_file_folder = "#{ @config[:log_path] }/#{ module_process.config_module[:subsystem_name] }"
 
       exist_or_create_folder(log_file_folder)
 
-      log_file = "#{ log_file_folder }/#{ Time.now.strftime("%Y-%m-%d") }_#{ @config[:server_name] }.log"
+      log_file = "#{ log_file_folder }/#{ Time.now.strftime("%Y-%m-%d") }_#{ module_process.action }_in_#{ @config[:server_name] }.log"
 
       if log_out = File.new(log_file,"w+")
         log_out.puts report
@@ -62,15 +64,16 @@ module Irgat
       send_email({ :subject => subject, :body => resume })
     end
 
-    def build_report
+    private
+    def build_report(log_process)
       report = ''
       
-      @log_process.each { |log_entry|
+      log_process.each { |log_entry|
         case log_entry[:type]
           when "point"
             @point ||= 0
             underscroll_caracter = "="
-            report << "\n #{ @point } #{ log_entry[:msj] } \n"
+            report << "\n\n #{ @point } #{ log_entry[:msj] } \n"
             report << ' ' + (underscroll_caracter * @point.to_s.length) + underscroll_caracter + (underscroll_caracter * log_entry[:msj].length) + "\n"
             @point += 1
           when "text"
@@ -79,7 +82,7 @@ module Irgat
             end
           when "command"
             if @config[:debug_level] >= log_entry[:debug]
-              report << "\n\n  #{ log_entry[:msj] }" 
+              report << "\n  #{ log_entry[:msj] }" 
             end
         end
       }
@@ -87,11 +90,9 @@ module Irgat
     end
 
     # method to report a info of the irgat process
-    def build_resume(fatal)
-
-
+    def build_resume(fatal,module_process)
       total_time     = Time.now - @init_time
-      total_time_log = "#{ total_time.to_s.slice(0,5) } sec., #{ (total_time / 60).to_s.slice(0,5) } min., #{ ((total_time / 60) / 60).to_s.slice(0,5) } hours."
+      total_time_log = "#{ total_time.to_s.slice(0,5) } sec., #{ (total_time / 60).to_s.slice(0,5) } min., #{ ((total_time / 60) / 60).to_int.to_s.slice(0,5) } hours."
       fatal_log      = (fatal ? "ERROR" : "OK")
 
       report_resume =  "\n"
@@ -100,17 +101,49 @@ module Irgat
       report_resume << "\n"
       report_resume << " * Resume info \n"
       report_resume << "  [ Serv Host ]  -> #{ @config[:server_name] } \n"
-      report_resume << "  [ Module    ]  -> #{ self.class.to_s } \n"
+      report_resume << "  [ Module    ]  -> #{ module_process.config_module[:subsystem_name].capitalize } \n"
       report_resume << "  [ Init Time ]  -> #{ @init_time } \n"
       report_resume << "  [ End  Time ]  -> #{ Time.now } \n"
       report_resume << "  [ TotalTime ]  -> #{ total_time_log } \n"
-      if @commands_launched
-        report_resume << "  [ CmdsExecs ]  -> #{ @commands_launched.values.select { |v| v == 0 }.size } \n"
-        report_resume << "  [ Warnings  ]  -> #{ @commands_launched.values.select { |v| v != 0 }.size} \n"
+      if module_process.commands_launched
+        report_resume << "  [ CmdsExecs ]  -> #{ module_process.commands_launched.select { |v| v.values.to_s == "0" }.size } \n"
+        report_resume << "  [ Warnings  ]  -> #{ module_process.commands_launched.select { |v| v.values.to_s != "0" }.size} \n"
+      end
+
+      if fatal
+        report_resume << "\n  [ **FATAL** ]   -> Irgat Process ended in command: '#{ module_process.commands_launched.last.keys.to_s }'"
       end
 
       return report_resume
     end
 
+    def colorize(log_entry)
+      case log_entry[:type]
+        when "text"
+          return_msj = "\x1b[#{ 38 };5;#{ 244 }m#{ log_entry[:msj] }\x1b[0m"
+        when "error"
+          return_msj = "\n \x1b[#{ 38 };5;#{ 160 }m#{ "ERROR!!" }  \x1b[0m" + log_entry[:msj].gsub(/#{ "FATAL" }/, "\x1b[#{38};5;#{ 160 }m#{ "*FATAL*" }\x1b[0m")
+        when "warning"
+          return_msj = "\x1b[#{ 38 };5;#{ 240 }m#{ log_entry[:msj] }\x1b[0m"
+        when "point"
+          return_msj = "\n\x1b[#{ 48 };5;#{ 252 }m#{ log_entry[:msj] }\x1b[0m \n"
+        when "command"
+          if log_entry[:msj]["OK"]
+            color = 2
+            text  = "OK"
+          elsif log_entry[:msj]["WARNING"]
+            color = 220
+            text = "WARNING"
+          elsif log_entry[:msj]["ERROR"]
+            color = 160
+            text  = "ERROR"
+          elsif log_entry[:msj]["FATAL"]
+            color = 160
+            text  = "FATAL"
+          end
+          return_msj = log_entry[:msj].gsub(/#{ text }/, "\x1b[#{38};5;#{ color }m#{ text }\x1b[0m")
+      end
+      return_msj
+    end
   end
 end

data/lib/irgat/utils.rb

@@ -7,6 +7,7 @@
 begin
   # require all the irgat utils
   # FIXME atd wants includes in irgat.
+  require 'irgat/help'
   require 'irgat/log'
   require 'irgat/mail'
   require 'irgat/execs'

data/lib/irgat/version.rb

@@ -1,10 +1,15 @@
 module Irgat
-  module VERSION #:nodoc:
+  module Version #:nodoc:
     MAJOR = 0
     MINOR = 0
-    TINY  = 1
+    TINY  = 2
 
     STRING = [MAJOR, MINOR, TINY].join('.')
-    self
+
+    class << self
+      def to_s
+        STRING
+      end
+    end
   end
 end

data/lib/modules/backup.rb

@@ -17,7 +17,8 @@ module Irgat
   class Backup < Irgat
 
     # initialize the Class... make default operations
-    def initialize
+    def initialize(values = {})
+      @action = values[:action]
       # Create and irgat process
       irgat_process = Irgat.new()
       # Get the instance variables
@@ -37,23 +38,66 @@ module Irgat
                                                     @config_module[:folders_tree] ],
                          :check_egid           => @config_module[:run_as_user]
                           )
-
     end
 
     def default(args =  {})
-      # no default action in backup module, show help
-      puts 'FIXME * action needed'
+      exit_with_error("\n ** [ ERROR ] No default action for Backup Module. Avaible methods: \n    list, search, restore, launch", { :exit_level => 7 })
     end
 
     def list(args =  [])
-      puts list_catalog
+      log("text", list_catalog[:output])
+    end
+
+    def search(args = [])
+      if args.include?('-c')
+        args.delete('-c')
+        result = search_complete(args.first)
+        if !result.empty?
+          text =  "\n * The pattern match in: \n\n"
+          text << "#{ result }"
+          text << "\n * Restore the file with $ irgat backup restore <number backup> <file name>\n   File will be restored in #{ @folders[:restore] }/<file name> }"
+          log("text", text, 1)
+        else
+          exit_with_error(" ** [ ERROR ] not pattern found.\n Exit", { :exit_level => 3} )
+        end
+      else
+        result = search_file(args.first)
+        if result[:status] == 0
+          text =  "\n * The file exist in these backups \n\n"
+          text << "#{ result[:output] }"
+          text << "\n * Restore the file with $ irgat backup restore <number backup> <file>\n   File will be restored in #{ @folders[:restore] }/<file> }"
+          log("text", text, 1)
+
+        else
+          exit_with_error("  ** [ ERROR ] not file found.\n Use $ irgat backup search <file> with -c option for a complete search", { :exit_level => 3} )
+        end
+      end
+    end
+
+    def restore(args = [])
+      backup_number = args[0] || nil
+      restore_file  = args[1] || nil
+      if !backup_number or !restore_file
+        exit_with_error(" ** [ ERROR] Not Backup or restore file passed. Syntax is $ irgat backup restore <number of backup> <file to restore>", { :exit_level => 7 })
+      else
+        # identify backup file
+        if ( !backup_data = get_backup_data(backup_number))
+          exit_with_error("  ** [ ERROR ] Backup '#{ backup_number }' not found in catalog", { :exit_level => 3 })
+        else
+          # try to restore
+          restore_command = "#{ @programs[:dar] } -x #{ backup_data[:file] } -R #{ @folders[:restore] } -K '#{ @config_module[:dar]["decrypt_passwd"] }' -v -g '#{ restore_file }'"
+          result = execute_command(
+              restore_command,
+              "Restoring file",
+              { :fatal_error => true })
+          log("text"," Files were succesfull restored", 1)
+        end
+      end
     end
 
     def launch(args =  [])
-      # @backup.set_log_output_to_file
       log("point", "Init Irgat Backup Launch")
 
-      # mysql dumps? FIXME to bbdd_dumps?
       if @config_module[:dump_mysql]
         log("point","Doing MySQL database Dumping")
         do_mysql_dumps
@@ -62,8 +106,8 @@ module Irgat
       # use the specific backup program
       self.send("do_backup_with_" + @config_module[:backup_program])
 
-      # finish process
-      finish_process({ :msj => "[IRGAT] [BACKUP] [OK] Backup Launch in #{ @config[:server_name] } server" })
+      # finish process || return STRING
+      return "[IRGAT] [BACKUP] [OK] Backup Launch in #{ @config[:server_name] } server"
       
     end
 
@@ -83,7 +127,7 @@ module Irgat
       end
 
       # Each db, make dump and compress with gzip
-      dbs.each { |db|
+      dbs[:output].each { |db|
           dump_file = "mysqldump_#{ Date.today }_#{db.chop}.sql"
           execute_command(
               "#{ @programs[:mysqldump] } -u #{ @config_module[:mysql_user] } -p#{ @config_module[:mysql_pass] } #{db.chop} -r #{dump_file}",
@@ -117,7 +161,7 @@ module Irgat
       dar_command = build_dar_command("do_backup", { "backup_type" => backup_type })
 
       # exec backup
-      log("point", "Doing backup")
+      log("point", "Doing #{ backup_type.capitalize } Backup")
       execute_command(dar_command, "Doing #{ backup_type.capitalize } Backup")
 
       # test backup
@@ -245,8 +289,13 @@ module Irgat
       execute_command(
           command_list_catalog,
           "Listing backup in catalog")
+      execute_command(
+          "ls /tmpdede",
+          "Listing the kaka",
+          {:fatal_error => true })
     end
 
+
     def identifies_backups_in_catalog(pattern)
       ids_backups = []
       backups_in_catalog = list_catalog
@@ -257,33 +306,15 @@ module Irgat
       }
       return ids_backups
     end
-  
-    # end backups process... report state and send emails if is configured for
-    def do_finish_backup(fatal = nil)
-      # take a report for the backup process
-      report = self.process_report
-      
-      # if email reporting is avaible, we have to send an email
-      if @config_module[:report_email]
-        #build subjetc
-        if fatal
-          subject_email="[IRGAT Backup] Fatal error in #{self.config[:server_name]}"
-        else
-          subject_email="[IRGAT Backup] Succesfull in #{self.config[:server_name]}"
-        end
 
-        # FIXME, wrap to litura... not good hear
-        if self.config[:server_name]=='litura'
-          self.send_email(:body=>report,:subject => subject_email, :in_chroot => true )
-        else
-          self.send_email(:body=>report,:subject => subject_email)
-        end
-      
+    def get_backup_data(num_backup)
+      backups = get_all_backups_in_catalog
+      for backup in backups
+        select_backup = backup if backup[:id] == num_backup
       end
-      # write the report also to the file
-      self.log("text",report,1)
+      select_backup
     end
-
+  
     def create_catalog(catalog_file_name)
      create_catalog_command = @programs[:dar_manager] + ' -C ' + catalog_file_name
      execute_command(
@@ -292,6 +323,54 @@ module Irgat
           { :fatal_error => true })
     end
 
+    def search_complete(pattern)
+      backups = get_all_backups_in_catalog
+      catalog = @folders[:catalog] + '/catalog_' + @config[:server_name]
+
+      result = ""
+      for backup in backups
+        log("point", "Searching #{ pattern } in backup #{ backup[:file] }")
+        search_complete_command = "#{ @programs[:dar_manager] } -B #{ catalog } -u #{ backup[:id] }"
+        command = execute_command(
+                  search_complete_command,
+                  "Listing files in backup #{ backup[:file] }")
+        command[:output].each_line { |backup_lines|
+          if backup_lines.include?(pattern)
+            result << "  - Backup number: #{ backup[:id] } (#{ backup[:file] }) -- File name: '#{ backup_lines.split(' ')[2] }'\n"
+          end
+        }
+      end
+      result
+    end
+
+
+    def search_file(pattern)
+      if !pattern
+        exit_with_error("\n ** Can't search without name file. Please type a file to search", { :exit_level => 7 })
+      end
+
+      catalog = @folders[:catalog] + '/catalog_' + @config[:server_name]
+      command_search_file = "#{ @programs[:dar_manager] } -B #{ catalog } -f '#{ pattern }'"
+      execute_command(
+          command_search_file,
+          "Searching file")
+    end
+
+    def get_all_backups_in_catalog()
+      backups = Array.new
+      # get all the backups in catalog and build variable
+      list_backups = list_catalog[:output]
+      list_backups.each_line { |backup_in_catalog|
+        if backup_in_catalog.strip =~ /^[0-9]/
+          backup = Hash.new
+          backup[:id]   = backup_in_catalog.split(' ')[0] 
+          backup[:file] = "#{ backup_in_catalog.split(' ')[1] }/#{ backup_in_catalog.split(' ')[2] }"
+          backups << backup
+        end
+      }
+      backups
+    end
+
     # FIXME
     def build_dar_command(for_what, options = {})
       # merge options with default
@@ -320,6 +399,9 @@ module Irgat
       for folder in @config_module[:exclude_folders]
         dar_command[:exclude_folders] << "-P #{folder} " 
       end
+      ## add exclude data and restore folder
+      dar_command[:exclude_folders] << "-P #{ @folders[:restore][1..-1] } -P #{ @folders[:data][1..-1] } "
+
       dar_command[:exclude_files] = ''
       for extension in @config_module[:exclude_files]
         dar_command[:exclude_files] << "-X '*#{extension}' "