irgat 0.0.1

data/lib/irgat/version.rb

@@ -0,0 +1,10 @@
+module Irgat
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 0
+    TINY  = 1
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+    self
+  end
+end

data/lib/modules/backup.rb

@@ -0,0 +1,348 @@
+=begin
+
+Irgat::Backup 
+--------------
+
+Author:  Gnoxys. info@gnoxys.net 
+License: GPL v3.
+
+Read more info in <irgat_path>/README
+
+=end
+
+
+module Irgat
+  
+  # create the class, that extends the Module Irgat::Irgat class
+  class Backup < Irgat
+
+    # initialize the Class... make default operations
+    def initialize
+      # Create and irgat process
+      irgat_process = Irgat.new()
+      # Get the instance variables
+      @config = irgat_process.config
+      # load options for subsystem
+      @config_module = self.load_config
+      @init_time = Time.now
+      # build the programs needed
+      need_programs=["dar", "dar_manager", "gzip","tar"]
+      # in function of options
+      need_programs << "mysql" << "mysqldump" if @config_module[:dump_mysql]
+      need_programs << "ssh" << "scp" if @config_module[:distribute_method]
+      # check all the needed things
+      check_dependencies(:check_programs       => need_programs,
+                         :check_mounted_folder => (@config_module[:mounted_folder] ? @config_module[:working_path] : false),
+                         :check_folders        => [ @config_module[:working_path],
+                                                    @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'
+    end
+
+    def list(args =  [])
+      puts list_catalog
+    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
+      end
+
+      # 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" })
+      
+    end
+
+    private
+    # Perform a mysqldump of all the databases
+    def do_mysql_dumps
+      # Take the DBs
+      dbs = execute_command(
+              "#{ @programs[:mysql] } -u '#{ @config_module[:mysql_user] }' -p'#{ @config_module[:mysql_pass] }' -Bse 'show databases'",
+              "Get databases info")
+      # chdir to mysql
+      Dir.chdir(@folders[:extras_mysql])
+
+      # delete old files, if exists || sure that we only delete .sql.gz files
+      if Dir.entries(@folders[:extras_mysql]).length > 1
+        execute_command("rm -f *.sql.gz ", "Delete old's dumps' files")
+      end
+
+      # Each db, make dump and compress with gzip
+      dbs.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}",
+              "Dumping database #{db.chop}")
+          execute_command(
+              "#{ @programs[:gzip] } -9 #{dump_file}",
+              "Compressing sql file:  #{dump_file}")
+        }
+
+    end
+  
+    # do dar backup with dar tool
+    def do_backup_with_dar
+      # move to current_folder
+      Dir.chdir(@folders[:data_local_current])
+
+      # define file names
+      @complete_backup_file = "#{ Date.today }_#{ @config[:server_name] }_complete"
+      @diff_backup_file     = "#{ Date.today }_#{ @config[:server_name] }_diff"
+      @last_complete_backup_file = Dir["*complete.*"][0]
+
+      # complet or diff
+      backup_type = ((@config_module[:complet_backup_days].include?(Time.now.wday) || !@last_complete_backup_file) ? "complet" : "diff")
+
+      # need to move files if backup is complete and there is some backup already
+      if backup_type == 'complet' && @last_complete_backup_file
+        move_and_purge_old_backups
+      end
+
+      # build command 
+      dar_command = build_dar_command("do_backup", { "backup_type" => backup_type })
+
+      # exec backup
+      log("point", "Doing backup")
+      execute_command(dar_command, "Doing #{ backup_type.capitalize } Backup")
+
+      # test backup
+      log("point", "Testing  backup")
+      do_test_backup
+
+      # add the backup in the catalog
+      log("point","Isolation and backup to catalog")
+      # 1) make the isolation file and add the backup in catalog
+      do_isolation_file
+      insert_backup_in_catalog
+    end
+
+    # method to move the old backups and purge the older in function of how many backups we are storing
+    def move_and_purge_old_backups
+      # move to current Dir
+      Dir.chdir(@folders[:data_local_current])
+      # move old backup
+      complet_date_backup = Dir["*complete.*"][0].slice(0,10)
+      folder_date_name = @folders[:data_local_old] + '/' + complet_date_backup
+      exist_or_create_folder(folder_date_name)
+      # move the current files to the new location "only .dar files"
+      execute_command(
+          "mv *.dar #{ folder_date_name }",
+          "Moving Olds Backup Files",
+          {:fatal_error => true})
+      # change the path for this backups
+      Dir.chdir(folder_date_name)
+      # all but isolates files
+      (Dir["*"] - Dir["*isolate*"]).each { |backup_file|
+        change_path_in_catalog(folder_date_name, backup_file.slice(0,10))
+      }
+
+      # return to delete
+      Dir.chdir(@folders[:data_local_old])
+      # if we have more, that the options how many stored backups number...
+      if (old_backups = Dir["*"].sort).length > @config_module[:number_backup_stored]
+        while old_backups.length > @config_module[:number_backup_stored]
+          to_delete_folder = old_backups.shift
+          Dir.chdir(to_delete_folder)             # FIXME
+          # all but isolates files
+          (Dir["*"] - Dir["*isolate*"]).each { |backup_file|
+            # remove from catalog
+            remove_from_catalog(backup_file.slice(0,10))
+          }
+          Dir.chdir(@folders[:data_local_old])    # FIXME
+          execute_command(
+            "rm -rf #{ @folders[:data_local_old] + '/' + to_delete_folder}",
+            "Deleting old backup folder #{ to_delete_folder.strip }",
+            { :fatal_error => true })
+
+        end
+      end
+    end
+
+    def change_path_in_catalog(new_path, backup_pattern, options = {})
+      catalog = options[:catalog] || @folders[:catalog] + '/catalog_' + @config[:server_name]
+      # search the backups to delete
+      ids_backups = identifies_backups_in_catalog(backup_pattern)
+      ids_backups.each { |id|
+        command_change_path = @programs[:dar_manager] + ' -B ' + catalog + ' -p ' + id + ' ' + new_path
+        execute_command(
+            command_change_path,
+            "Change path to backup #{ id } in catalog")
+      }
+
+    end
+
+    # build the command to check backup and exec it
+    def do_test_backup
+      test_command = @programs[:dar] + ' -t ' + @backup_file + ' -K ' + @config_module[:dar]["encrypt_passwd"]
+      #exec it
+      self.execute_command(
+          test_command,
+          "Testing integrity off backup")
+    end
+  
+    # build the isolation file
+    def do_isolation_file
+      isolation_command = self.programs[:dar] + ' -J ' + @config_module[:dar]["decrypt_passwd"] + ' -C ' + @backup_file + '_isolate -A ' +@backup_file
+      #exec it
+      execute_command(
+          isolation_command,
+          "Making isolation file",
+          { :fatal_error => true })
+    end
+  
+    # insert the backup in catalog
+    def insert_backup_in_catalog(options = {})
+      # options
+      catalog = options[:catalog] || @folders[:catalog] + '/catalog_' + @config[:server_name]
+      backup_file = options[:backup_file] || @folders[:data_local_current] + '/' + @backup_file + '_isolate '
+      backup_file_name = options[:backup_file_name] || @folders[:data_local_current] + '/' + @backup_file 
+
+      if ! test(?e,catalog)
+        create_catalog(catalog)
+      end
+
+      # now, build the command to insert in catalog
+      command_insert_in_catalog = @programs[:dar_manager] + ' -B  ' + catalog + ' -A' +  backup_file + backup_file_name
+      # exec it
+      execute_command(
+          command_insert_in_catalog,
+          "Inserting backup in catalog",
+          { :fatal_error => true })
+    end
+
+
+    def remove_from_catalog(backup_pattern, options = {})
+      catalog = options[:catalog] || @folders[:catalog] + '/catalog_' + @config[:server_name]
+      # search the backups to delete
+      ids_backups = identifies_backups_in_catalog(backup_pattern)
+      ids_backups.each { |id|
+        command_remove_backup= @programs[:dar_manager] + ' -B ' + catalog + ' -D ' + id
+        execute_command(
+            command_remove_backup,
+            "Removing Backup #{ id } from catalog")
+      }
+    end
+
+
+    def list_catalog(options = {})
+      catalog = options[:catalog] || @folders[:catalog] + '/catalog_' + @config[:server_name]
+      command_list_catalog = @programs[:dar_manager] + ' -B ' + catalog + ' -l'
+      execute_command(
+          command_list_catalog,
+          "Listing backup in catalog")
+    end
+
+    def identifies_backups_in_catalog(pattern)
+      ids_backups = []
+      backups_in_catalog = list_catalog
+      backups_in_catalog.each_line { |backup_data|
+        if backup_data.include?(pattern)
+          ids_backups << backup_data.split(' ')[0]
+        end
+      }
+      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
+      
+      end
+      # write the report also to the file
+      self.log("text",report,1)
+    end
+
+    def create_catalog(catalog_file_name)
+     create_catalog_command = @programs[:dar_manager] + ' -C ' + catalog_file_name
+     execute_command(
+          create_catalog_command,
+          "Creating catalog",
+          { :fatal_error => true })
+    end
+
+    # FIXME
+    def build_dar_command(for_what, options = {})
+      # merge options with default
+      options = options.merge(@config_module[:dar])
+      # BUILD basic dar command 
+      dar_command = Hash.new
+      # required
+      dar_command[:file_size]      = "-s #{ options["file_size"] }" 
+      dar_command[:root_backup]    = "-R #{ options["root_backup"] }" 
+      dar_command[:encrypt_passwd] = "-J #{ options["encrypt_passwd"] }"
+      dar_command[:decrypt_passwd] = "-K #{ options["decrypt_passwd"] }"
+      # conditionals
+      if options["compression"]
+        dar_command[:compression] = '-m ' + options["compression"].to_s + ' -y'
+      end
+      if options["enable_empty_folders"]
+        dar_command[:enable_empty_folders] = '-D ' 
+      end
+
+      # multiples
+      dar_command[:exclude_to_compress] = ''
+      for extension in @config_module[:exclude_to_compress]
+        dar_command[:exclude_to_compress] << "-Z '*" + extension + "' "
+      end
+      dar_command[:exclude_folders] = ''
+      for folder in @config_module[:exclude_folders]
+        dar_command[:exclude_folders] << "-P #{folder} " 
+      end
+      dar_command[:exclude_files] = ''
+      for extension in @config_module[:exclude_files]
+        dar_command[:exclude_files] << "-X '*#{extension}' " 
+      end
+
+      dar_cmd = @programs[:dar] + " "
+
+      dar_command.each_value {|v|
+        dar_cmd << v + ' '
+      }
+
+      # diff or complete
+      if options["backup_type"] == 'complet'
+        dar_cmd << "-c #{ @complete_backup_file }"
+        @backup_file = @complete_backup_file
+      elsif options["backup_type"] == 'diff'
+        dar_cmd << "-c #{ @diff_backup_file } -A #{ @last_complete_backup_file.split('.')[0] }"
+        @backup_file = @diff_backup_file
+      end
+
+      dar_cmd
+    end
+
+    
+  end
+end

data/lib/modules/console.rb

@@ -0,0 +1,48 @@
+=begin
+
+IRGAT::Console
+--------------
+
+Author:  Gnoxys. info@gnoxys.net 
+License: GPL v3.
+
+Read more info in <irgat_path>/README
+
+=end
+
+
+module Irgat
+  
+  # create the class, that extends the Module Irgat::Irgat class
+  class Console < Irgat
+
+    #accesor to configs
+    attr_reader :config
+
+    def initialize
+      # Create and irgat process
+      irgat_process = Irgat.new()
+      # Get config
+      @config = irgat_process.config
+      # load options for module
+      @config_module = self.load_config
+      # include modules?
+      #case @config_module[:load_modules]
+      #  when 'all'
+      #    log("text", "Loading all activated modules")
+      #    # get modules
+      #    # @config
+      #    # TODO
+      #  when 
+      @log_to_stdout = true
+    end
+
+    def default(args =  {})
+      require 'irb'
+      puts "\nLaunching irgat command line"
+      puts "---------------------------"
+      exec("irb -r #{IRGAT_ROOT}/lib/boot.rb -r #{IRGAT_ROOT}/lib/irgat.rb -r #{IRGAT_ROOT}/lib/irgat/console.rb -r irb/completion")
+    end
+
+  end
+end

data/lib/modules/kwallet.rb

@@ -0,0 +1,133 @@
+#=Index
+#
+#  IRGAT::Kwallet Class
+#  ----------------------
+#  get more info typing @your_object.help '<reference word>'
+#
+#  * Methods:
+#   - get_passwd_entry        # Get a password entry from you wallet
+#   - show_passwd_list        # List the avalible passwords in your wallet
+#   - get_kwallet_int_code    # Get the code of your wallet
+#   - show_folders            # Show the folders in your wallet
+#
+#
+#= Get_passwd_entry
+#
+#  method: public: get_passwd_entry(folder,key)
+#
+#  Description: Get a password entry stored in your kwallet defined in your irgat_kwallet.yml file.
+#
+#  Need: 
+#       -folder: string name of the folder tha have the key
+#       -key:    string name of the wanted coded
+#
+#  Return: this method return an string with the password entry
+#
+
+
+# create the class, that extends the Module IRGAT::Base class
+
+module Irgat
+
+  class Kwallet < Irgat
+
+    # initialize the Class... make default operations
+    def initialize
+      # Create and irgat process
+      irgat_process = Irgat.new()
+      # Get the instance variables
+      @config = irgat_process.config
+      # load options for subsystem
+      @config_module = self.load_config
+      @init_time = Time.now
+      # build the programs needed
+      need_programs = ["dcop", "gpg"]
+      
+      # get kwallet code at start
+      @code ||= get_kwallet_int_code.strip
+      # define module to log in console
+      @log_to_stdout = true
+    end
+
+    def default(args)
+      do_petition(args)
+    end
+
+    def do_petition(args)
+      petition = args.shift
+      if !petition or petition == ""
+        log("text","No petition registered. Options are: ", 1)
+      else
+        if !args.empty?
+          self.send(petition, (args))
+        else
+          self.send(petition)
+        end
+      end
+    end
+
+    def show( arg = [])
+      puts arg.inspect
+      args = arg.split(' ')
+      folder = args.shift
+      entry  = args.shift
+      puts folder
+      puts entry
+      if !folder || !entry
+        return "Select a folder or entry"
+      else
+        return "Value: #{ get_passwd_entry(folder,entry) }"
+      end
+    end
+
+    def list( args = [])
+      option = args.first
+      if !option
+        return " List stored objects. Specify a folder from list: #{ show_folders.gsub(/\n/,' ') }"
+      else
+        if option == "all"
+        else
+          show_passwd_list(option.strip)
+        end
+      end
+    end
+
+    private
+    #get the kwallet code from the default wallet
+    def get_kwallet_int_code
+      code = execute_command("dcop kded kwalletd open '#{ @config_module[:kwallet_name] }' ''","Get #{ @config_module[:kwallet_name] } wallet code id' files")
+      code
+    end
+
+  
+    def insert_passwd_entry(folder, key, value)
+      petition = execute_command("dcop kded kwalletd writePassword #{ @code }  '#{ folder }' '#{ key }' '#{ value }'","Writing new password key #{ key } in #{ folder }")
+    end
+
+    def get_passwd_entry(folder, key)
+      petition = execute_command("dcop kded kwalletd readPasswordList  #{ @code }  '#{ folder }' '#{ key }'","Get password key #{ key } in #{ folder }",1)
+      pass=petition.split('->')[1]
+      pass
+    end
+  
+    def show_passwd_list(folder)
+      petition = execute_command("dcop kded kwalletd entryList #{ @code } '#{ folder }'", "Get Password of #{ folder }")
+      return "Avaible Entries in #{ folder }: #{ petition.gsub(/\n/,' ') } . Type $ @kwallet.show #{ folder } <entry> to see the key value"
+    end
+  
+    def show_folders
+      petition = execute_command("dcop kded kwalletd folderList  #{ @code }","Get the folders in  #{ @config_module[:kwallet_name] } wallet")
+      petition
+    end
+  
+    def commit_kwallet_file
+      execute_command("scp -P #{@config_module[:remote_path]["port"]} #{@config_module[:local_path]}/#{@config_module[:kwallet_name]}.kwl  #{@config_module[:remote_path]["user"]}@#{@config_module[:remote_path]["server"]}:/#{@config_module[:remote_path]["folder"]}","Sending local kwallet file",1)
+    end
+
+    def update_kwallet_file
+       execute_command("scp -P #{@config_module[:remote_path]["port"]} #{@config_module[:remote_path]["user"]}@#{@config_module[:remote_path]["server"]}:/#{@config_module[:remote_path]["folder"]}/#{@config_module[:kwallet_name]}.kwl #{@config_module[:local_path]}","Updating local kwallet file from server",1)
+    end
+  
+  end
+
+end