irgat 0.0.1

data/lib/irgat/console.rb

@@ -0,0 +1,85 @@
+# extend the IRB commands
+module IRB
+  module ExtendCommandBundle
+    # irgat_help. Load a file with help about command
+    def irgat_help(what=nil)
+      # TODO check paths
+      help_file=IRGAT_LANG+"/help_cmd_#{@config[:lang]}.rb"
+      # control if exist file
+      if ! test(?d,help_file)
+        puts "Help file #{help_file} not found. Check the install or choose another language in your irgat config file"
+      end
+      #get comments in file
+      comment = File.open(help_file) do |file|
+        RDoc.find_comment(file)
+      end
+
+      # parse it, and create needed objects
+      comment = comment.gsub(/^\s*#/, '')
+      markup = SM::SimpleMarkup.new
+      flow_convertor = SM::ToFlow.new
+      flow = markup.convert(comment, flow_convertor)
+
+      #define output format
+      format = "plain"
+
+      #index help if nothing was wrotten
+      what='index' if what==nil
+
+      #i don't want output in these...
+      $stdout=File.new('/dev/null',"w+")
+      searched_flow = RDoc.extract_sections(flow, what.to_a)
+      #retake output
+      $stdout=STDOUT
+
+      # i don't like the rdoc way to return the things... it is assumed, that if you don't found your desired section, you want to see all!! O_o
+      if flow==searched_flow
+        puts '[ Error ] No section founded for your petition '+what
+        puts 'Try a diffent pattern search or try irgat_help without search pattern to view a list of avaibles sections'
+      else
+        #we have found, render it
+        options = RI::Options.instance
+        if args = ENV["RI"]
+          options.parse(args.split)
+        end
+        formatter = options.formatter.new(options, "")
+        formatter.display_flow(searched_flow)
+      end
+    end
+  end
+end
+
+
+
+
+# define irgat promt
+IRB.conf[:PROMPT][:IRGAT] = {           # name of prompt mode
+  :PROMPT_I => "irgat:$> ",             # normal prompt
+  :PROMPT_S => "irgat:$> ",             # prompt for continuing strings
+  :PROMPT_C => "irgat:$> ",             # prompt for continuing statement
+  :RETURN => "    irgat_return =>  %s \n\n"      # format to return value
+  
+}
+
+# set promt
+IRB.conf[:PROMPT_MODE] = :IRGAT
+
+
+# create console irgat
+require 'modules/console'
+@console = Irgat::Console.new
+
+enable_modules = []
+
+if @console.config_module[:load_modules] == "all"
+  @console.config[:enable_subsystem].each_pair {| mod, enable |
+    if mod != "console" && enable != false
+      require 'modules/' + mod
+      mod_enable =  Object.module_eval("Irgat::#{ mod.capitalize }").new
+      instance_variable_set "@#{ mod }", mod_enable
+      enable_modules << mod
+    end
+  }
+end
+
+puts "** Console enable modules => #{ enable_modules.join(', ') }"

data/lib/irgat/dependencies.rb

@@ -0,0 +1,75 @@
+module Irgat
+  module Dependencies
+
+    def check_dependencies(dependencies = {})
+      # check programs
+      @programs = check_programs(dependencies[:check_programs]) if dependencies[:check_programs]
+      # check folders
+      @folders = check_folders(dependencies[:check_folders]) if dependencies[:check_folders]
+      # check mounted folder
+      @mounted_folder = check_mounted_folder(dependencies[:check_mounted_folder]) if dependencies[:check_mounted_folder]
+      # check egid
+      check_egid(dependencies[:check_egid]) if dependencies[:check_egid]  
+    end
+
+    private
+    def check_programs(programs)
+      @programs = Hash.new
+      programs.each { |p|
+        # locate program
+        program_path = %x[ which #{p} ]
+        if program_path
+          @programs[p.to_sym] = program_path.strip
+        else
+          exit_with_error("Irgat couldn't find the program #{ p } needed by #{ self.class } module")
+        end
+      }
+      @programs
+      
+    end
+
+    def check_folders(folders_array = [])
+      # first is root folder
+      root_folder = folders_array.shift
+      @folders = Hash.new
+      # check the root_folder
+      exist_or_create_folder(root_folder)
+      @folders[:root] = root_folder
+      # check the others
+      folders_array.shift.each { |f|
+        folder = root_folder + "/" + f
+        exist_or_create_folder(folder)
+        @folders[f.gsub('/', '_').to_sym] = folder
+      }
+      @folders
+    end
+
+    def check_mounted_folder(folder)
+      mount_points = execute_command("mount","Getting mount points")
+      if mount_points.include?(folder)
+        log("text","OK. #{folder} already mounted")
+      else
+        # we try to mount
+        log("text","Warning. #{folder} not mounted. Triying to mount")
+        execute_command("mount #{folder}", 
+                        "Mounting working directory #{folder}",
+                        {:fatal_error => true})
+      end
+    end
+
+    def check_egid(user)
+      if user != execute_command("whoami", "Getting irgat launcher user", 3).strip
+        exit_with_error("#{ @config_module[:subsystem_name] } Irgat module must run as #{ user } User")
+      end
+    end
+
+    # create if not exist the folder
+    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)
+      end
+    end
+
+  end
+end

data/lib/irgat/execs.rb

@@ -0,0 +1,73 @@
+# add utils to irgat::irgat class
+
+module Irgat
+  module Execs
+
+    def execute_command(command, command_description, options = {})
+      @commands_launched ||= Hash.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
+
+      # exit?
+      if finish_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 }"
+
+        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 }")
+      end
+
+      # Log the outputs || debug 1
+      log("command", "* [#{ (finish_status == 0 ? "   OK   " : " WARNING") }: #{Time.now.strftime("%H:%M:%S")}] -> #{ command_description }", 1)
+
+      # Log warning level
+      if finish_status != 0
+        log("warning", "Command #{ command_description } exited with a #{ finish_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"
+
+      log("text", text_to_log, 3)
+
+      # add the command to the commands_launched hash
+      @commands_launched[command_description] = finish_status
+
+      return command_output
+    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]
+      
+      exit (options[:exit_level] ? options[:exit_level] : 1)
+    end
+
+
+  end
+end
+

data/lib/irgat/log.rb

@@ -0,0 +1,116 @@
+# add utils to irgat::irgat class
+
+module Irgat
+  module Log
+
+    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_process << log_point
+      # need to puts
+
+      if @log_to_stdout && @config[:debug_level] >= log_point[:debug]
+        puts "[#{ log_point[:type] }] \n  #{ log_point[:msj] }"
+      end
+    end
+
+    def output_log(options = {})
+      fatal = options[:fatal] || false
+
+      # build report
+      report = build_report
+      resume = build_resume(fatal)
+
+      if @config_module[:output_log]
+        # add a extend header to the log report
+        report_to_log(report)
+      end
+
+      if @config_module[:output_email]
+        report_to_email(resume, report, options[:main_msj] )
+      end
+    end
+
+    def report_to_log(report)
+      exist_or_create_folder(@config[:log_path])
+
+      log_file_folder = "#{ @config[:log_path] }/#{ @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"
+
+      if log_out = File.new(log_file,"w+")
+        log_out.puts report
+        log_out.close
+      else
+        puts "Unable to open log #{ log_file }. Output won't be wrotten"
+      end
+    end
+
+    def report_to_email(resume, report, subject )
+      # body
+      if @config[:debug_level] == 3
+        resume = resume + "\n\n LOG \n\n" + report
+      end
+
+      send_email({ :subject => subject, :body => resume })
+    end
+
+    def build_report
+      report = ''
+      
+      @log_process.each { |log_entry|
+        case log_entry[:type]
+          when "point"
+            @point ||= 0
+            underscroll_caracter = "="
+            report << "\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"
+            if @config[:debug_level] >= log_entry[:debug]
+              report << "#{ log_entry[:msj] }" 
+            end
+          when "command"
+            if @config[:debug_level] >= log_entry[:debug]
+              report << "\n\n  #{ log_entry[:msj] }" 
+            end
+        end
+      }
+      report
+    end
+
+    # method to report a info of the irgat process
+    def build_resume(fatal)
+
+
+      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."
+      fatal_log      = (fatal ? "ERROR" : "OK")
+
+      report_resume =  "\n"
+      report_resume << " * Status \n"
+      report_resume << "  [ #{ fatal_log } ] \n"
+      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 << "  [ 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"
+      end
+
+      return report_resume
+    end
+
+  end
+end

data/lib/irgat/mail.rb

@@ -0,0 +1,88 @@
+# add utils to irgat::irgat class
+
+module Irgat
+  module Mail
+
+    def send_email(options = {})
+      mail = build_email(options)
+  
+      if self.config[:smtp_mode]=='smtp'
+        Net::SMTP.start(self.config[:smtp_values]["server"],
+                        self.config[:smtp_values]["port"],
+                        self.config[:smtp_values]["server"],
+                        self.config[:smtp_values]["user"],
+                        self.config[:smtp_values]["password"],
+                        :login) do |smtp|
+            smtp.send_mail mail.encoded,
+            "irgat@#{ @config[:server_domain] }",
+            mail.destinations
+        end
+      else
+        #send email to localhost without authentication
+        Net::SMTP.start('localhost', 25) do |smtp|
+            smtp.send_mail mail.encoded,
+            "irgat@#{ @config[:server_domain] }",
+            mail.destinations
+        end
+      end
+    end
+
+    private
+    def build_email(options = {})
+      # crete emails and fill it
+      mail = TMail::Mail.new
+      mail.date = Time.now
+      mail.subject = options[:subject] || "[Irgat][#{ self.class.to_s }] Email from #{ @config[:server_name] }"
+      mail.to = options[:to] || @config[:mail_to]
+  
+      # add cc and bcc if exist
+      mail.cc = options[:cc]   if options[:cc]
+      mail.bcc = options[:bcc] if options[:bcc]
+  
+      # body
+      mail.body = options[:body] || "body empty"
+
+      mail
+    end
+  
+    #method to send emails using mutt... maybe, will be better to use action_mailer
+    # FIXME, added an option to run the mutt command in chroot, but probably is not good idea, only parse to litura 
+    # DEPRECATED
+    def send_email_with_mutt(options={})
+      #check mutt program
+      command=(%x[which mutt]).strip
+      if command==""
+        puts "Mutt is not installed, send_mail method can't be used"
+      else
+      if options[:in_chroot]
+        command='chroot /var/local/chroot '+command
+      end
+        # parse options
+        # cc copy
+        command=command+(options[:to_cc].split(',').collect {|c| ' -c '+c }).to_s if options[:to_cc]
+        # bcc copy
+        command=command+(options[:to_bcc].split(',').collect {|b| ' -b '+b }).to_s if options[:to_bcc]
+        # attach files
+        command=command+" -a '"+options[:attach_files].split(',').join(' ')+"'" if options[:attach_files]
+        # body, we include it from file
+        if options[:body]
+          email_body_file=File.new('/tmp/email_body_file',"w+")
+          email_body_file.puts options[:body]
+          email_body_file.close
+          command=command+" -i "+email_body_file.path
+        end
+        
+        # subject
+        command=command+" -s '"+(options[:subject] || "[Irgat] Email from #{self.class.to_s} Subsytem")+"'"
+        # to
+        command=command+" -- "+(options[:to] || "#{self.config[:mail_to]}")+""
+        # end command
+        command=command+' <.'
+        # exec it
+        self.execute_command(command,("Sending email"|| options[:log_text]))
+        # clean file
+        File.delete('/tmp/email_body_file')
+      end
+    end
+  end
+end

data/lib/irgat/utils.rb

@@ -0,0 +1,17 @@
+#= License
+#
+#  IRGAT (Intuitive Ruby for Gnoxys Administration Tools)
+#  2007 - 2008 Gnoxys. info@gnoxys.net
+#  This program is released under the terms of the GPL v3 license as you cand find in http://www.gnu.org/licenses/gpl.html
+
+begin
+  # require all the irgat utils
+  # FIXME atd wants includes in irgat.
+  require 'irgat/log'
+  require 'irgat/mail'
+  require 'irgat/execs'
+  require 'irgat/dependencies'
+rescue LoadError => msj
+  puts "Irgat needed the follow utils:"+(msj.to_s.split('--'))[1]+", but not found."
+  puts "[ ERROR ] in file "+msj.backtrace.to_s
+end