gat 0.2.8

data/lib/gat/version.rb

@@ -0,0 +1,20 @@
+=begin
+  This file is part of GAT: http://gat.rubyforge.org
+  
+  (c) 2008-2009 A.C. Gnoxys info@gnoxys.net
+   
+  GAT (Gnoxys Administration Tools) is released under the GPL License 3 or higher.
+  You can get a copy of the license easily at http://www.gnu.org/licenses/gpl.html.
+  
+  THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
+=end
+
+module Gat
+  VERSION = '0.2.8'
+end

data/lib/gatgets/dar_backup/dar_backup.rb

@@ -0,0 +1,367 @@
+=begin
+  This file is part of GAT: http://gat.rubyforge.org
+
+  (c) 2008-2009 A.C. Gnoxys info@gnoxys.net
+
+  GAT (Gnoxys Administration Tools) is released under the GPL License 3 or higher.
+  You can get a copy of the license easily at http://www.gnu.org/licenses/gpl.html.
+
+  THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+=end
+
+require 'gat'
+
+GATGET_DAR_BACKUP_ROOT =  File.expand_path(File.dirname(__FILE__))
+
+class GatgetDarBackup < Gat::Base
+
+
+  # helpers
+  def set_flag_mysql_dumps
+    set_flag("active_mysql_dumps", get_dependence_value("static", "mysql_dumps"))
+  end
+
+  def set_flag_catalog_exists
+    catalog_name = "bbdd_#{ self.config['server_name'] || 'backup' }"
+    set_dependence_variable("catalog_name", catalog_name)
+    set_dependence_variable("catalog_path", "#{ get_dependence_value("folders", "backups_folder_catalog") }/#{ catalog_name }")
+    set_flag("catalog_exists", File.exists?(get_dependence_variable("catalog_path")))
+  end
+
+  # get all the system backups and catalogs backups
+  def get_all_backups
+    get_system_backups
+    get_catalog_backups
+  end
+
+  # We are going to set the backups variables. Which ones must be deleted and the name of the current backup
+  def set_do_backup_variables
+    # if we dont have a backup
+    if not get_current_complete_backup
+
+      # * perform a complet backup
+      # * set the minimum space required at 1 kb
+      # * mark backups to delete, if nothing to delete,system will get it
+      # * create new dir and link it to current through new_link_current flag
+
+      set_variables_to_complete_backup
+      set_dependence_variable("last_backup_size", 1)
+      set_backups_to_delete
+      set_flag("delete_old_backups", true)
+      set_flag("new_complete_folder", true)
+
+    # if we have a complet backup but today is complet
+    elsif get_dependence_value("static", "complet_backup_days").include?(Date.today.wday)
+
+      # * perform a complet backup
+      # * get the last size of complet backup
+      # * identify backups to delete and mark delete flag
+      # * mark delete current link
+      # * create new dir and link it to current through new_link_current flag
+
+      set_variables_to_complete_backup
+      set_dependence_variable("last_backup_size", get_last_backup_size('complet'))
+      set_backups_to_delete
+      set_flag("delete_old_backups", true)
+      set_flag("delete_current_link", true)
+      set_flag("new_complete_folder", true)
+
+    # else, we must do a diff backup, do
+    else
+      # * perform diff backup
+      # * dont care about delete or new dirs... etc..
+      # * get the last size of diff backup
+      set_variables_to_diff_backup
+      set_dependence_variable("last_backup_size", get_last_backup_size('diff'))
+    end
+  end
+
+  def exists_backup_file
+    get_system_backups
+    backup_folder   = get_dependence_value("folders", "backups_folder_data_local")
+    backup_dar_name = get_dependence_value("arguments", "backup_dar_name")
+    backups_with_dar_name = get_dependence_variable("system_backups").select { |b| b['dar_name'] == backup_dar_name }
+    if backups_with_dar_name.empty?
+      self.logger.log("direct", "action_result", "\n ERROR: Backup dar name #{ backup_dar_name } not found\n\n Type $> #{ $0 } list_backups to see avalaibles backups\n\n")
+      set_flag("exists_backup_file", false)
+    else
+      backup = backups_with_dar_name.first
+      set_dependence_variable("backup_to_show_content", "#{ backup['folder'] }/#{ backup['dar_name']}")
+      set_flag("exists_backup_file", true)
+    end
+
+  end
+
+  # ruby methods
+  def list_backups_data
+  end
+
+  def show_nice_search
+    get_catalog_backups
+  end
+
+  # We need to have enough space to do backup
+  def check_enough_space_for_backup
+
+    last_backup_size = get_dependence_variable("last_backup_size")
+    backup_folder    = get_dependence_value("folders", "backups_folder_data_local")
+    thresold       = get_dependence_value("static", "space_thresold").to_i * 1024 * 1024 # to Bytes
+    # check it
+    if not check_enough_space({'where' => backup_folder, 'space_needed' => last_backup_size}) and not check_enough_space({'where' => backup_folder, 'space_needed' => thresold})
+      raise Gat::GatgetProcessException.new("System doesnt have enough space", "check_enough_space_for_backup")
+    end
+  end
+
+  # failed action launch_backup_rescue callback
+  # Dar, when the backup is so big, usually end with a 2 status, that means some files changed during backup operations. That
+  # is normal while is working over logs, mysql, etc...
+  # So, we have to discriminate what the non zero exit status means.
+  def launch_backup_rescue
+    # get the backup action
+    launch_backup = Gat::Action::Base.get_current_action
+
+    # Exit level 4 but with callback to delete backup
+    if launch_backup.exit_level == 4 and launch_backup.output.include?('No space left on device, you have the opportunity to make room now')
+      # disk is full, mark bad backup flag that will delete current backup
+      self.logger.log('trace', 'onfail_launch_backup_rescue', 'Disk is full, delete current backup')
+
+      delete_action = Gat::Action::ShellCommand.new('delete_bad_backup', get_element_config('actions', 'delete_bad_backup'), self.operation)
+      delete_action.execute
+
+      if delete_action.exit_level == 0
+        launch_backup.onfail_message = "Dar backup collapse disk, but backup was deleted"
+      else
+        launch_backup.onfail_message = "Dar backup collapse disk and backup WASNT DELETED."
+      end
+
+      # mark action to abort
+      launch_backup.onfail = 'abort'
+
+    # 4 exit level always means problems
+    elsif launch_backup.exit_level == 4 or launch_backup.exit_level == 2
+      # mark action to abort
+      launch_backup.onfail = 'abort'
+    end
+  end
+
+  # send rescue email will send a email for notification errors at do_backup operation
+  def onfail
+
+    unless self.config['email_config']
+      raise Gat::GatgetConfigException.new("Default email config is empty at gatget.config['email_config']", "run_output_email")
+    end
+
+    email_subject = "[GAT] [#{ self.class.name }] [#{ self.operation.name.camelize }] [FAILED]"
+
+
+    email_body    =  "Gatget #{ self.class.name } was stopped by raising of #{ self.onfail_error.class } at #{ Time.now }\n\n"
+    email_body    << "#{ onfail_error.exit_error }"
+    email_body    << "\n\n Errors log:  \n\n #{self.logger.entries.select{ |e| e.global_type == 'error' }.map{ |e| e.inspect }.join("\n") }\n\n"
+    email_body    << "\n\n Warning log: \n\n #{self.logger.entries.select{ |e| e.global_type == 'warning' }.map{ |e| e.inspect }.join("\n") }\n\n"
+    email_body    << "\n\n Whole log:   \n\n #{self.logger.entries.map{ |e| e.inspect }.join("\n") }"
+
+    self.create_and_deliver_email(self.config['email_config']['send_to'], { 'subject' => email_subject, 'body' => email_body }, self.config['email_config'])
+
+  end
+
+  # nothing to delete if catalog is empty
+  def catalog_is_empty
+    set_flag("catalog_is_not_empty", get_dependence_variable("catalog_backups").any?)
+  end
+
+  def print_status
+    if check_i_am_running
+      ret = "running"
+    else
+      ret = "not running"
+    end
+    puts ret
+    Gat::Action::Base.get_current_action.output = ret
+  end
+
+  private
+  def get_system_backups
+    backup_entries    = []
+    local_data_folder = get_dependence_value("folders", "backups_folder_data_local")
+
+    # get the current folder
+    current_folder = nil
+    if File.exists?("#{ local_data_folder }/current")
+      # on some S.O, readlink return folder with last slash. remove it anyway.
+      current_folder = File.readlink("#{ local_data_folder }/current").gsub(/\//,'')
+    end
+
+    (Dir.entries(local_data_folder) - ['current', '.', '..']).each do |backup_folder|
+      backup_folder_path = "#{ local_data_folder }/#{ backup_folder }"
+      (Dir.entries(backup_folder_path) - ['..', '.' ]).each do |backup_file|
+        backup_entries << { 'type'    => backup_file.include?('complet') ? 'complet' : 'diff',
+                            'name'    => backup_file,
+                            'path'    => "#{ local_data_folder }/#{ backup_folder }/#{ backup_file }",
+                            'dar_name'=> backup_file.split('.').first,
+                            'isolate' => backup_file.include?('isolate'),
+                            'folder'  => backup_folder,
+                            'current' => backup_folder == current_folder }
+      end
+    end
+    set_dependence_variable("system_backups", backup_entries)
+  end
+
+  def get_catalog_backups
+    backup_entries    = []
+    # define a new action to get all the catalogs in database
+    action = Gat::Action::ShellCommand.new('identify_all_backups_in_catalog', get_element_config('actions', 'identify_backups_in_catalog'), self.operation)
+    action.execute
+
+    backup_in_catalog = action.output
+    backup_in_catalog.each_line do |line|
+      if line.include?('complet') or line.include?('diff')
+        line = line.strip
+        backup_entries << { 'type'    => line.include?('complet') ? 'complet' : 'diff',
+                            'dar_name'=> line.split(' ')[2],
+                            'id'      => line.split(' ')[0],
+                            'folder'  => line.split(' ')[1] }
+      end
+    end
+    set_dependence_variable("catalog_backups", backup_entries)
+  end
+
+  def get_current_complete_backup
+    stored_backups      = get_dependence_variable("system_backups")
+
+    # select complete and current
+    complet_and_current = stored_backups.select { |backup| backup['type'] == 'complet' and backup['current'] and !backup['isolate']}
+    if complet_and_current.empty?
+      complet_backup_file = false
+    else
+      set_dependence_variable("backup_complet_folder", complet_and_current.first['folder'] )
+      set_dependence_variable("backup_complet_file", complet_and_current.first['name'].split('.').first)
+      complet_backup_file = true
+    end
+    complet_backup_file
+  end
+
+  def set_variables_to_complete_backup
+    backups_folder = get_dependence_value("folders", "backups_folder_data_local")
+    backup_folder = "#{ Date.today }"
+    backup_name   = "#{ Date.today }_#{ self.config['server_name'] || 'backup' }_complet"
+    backup_path   = "#{ backups_folder }/#{ backup_folder }/#{ backup_name }"
+    # set the variables
+    set_dependence_variable("backup_launch_argument", "-c #{ backup_path }")
+    set_dependence_variable("backup_folder", backup_folder)
+    set_dependence_variable("backup_name", backup_name)
+    set_dependence_variable("backup_path", backup_path)
+  end
+
+  def set_variables_to_diff_backup
+    backups_folder = get_dependence_value("folders", "backups_folder_data_local")
+    backup_folder  = get_dependence_variable("backup_complet_folder")
+    backup_name    = "#{ Date.today }_#{ self.config['server_name'] || 'backup' }_diff"
+    backup_path    = "#{ backups_folder }/#{ backup_folder }/#{ backup_name }"
+    backup_complet = "#{ backups_folder }/#{ backup_folder }/#{ get_dependence_variable("backup_complet_file") }"
+    # set the variables
+    set_dependence_variable("backup_launch_argument", "-c #{ backup_path } -A #{ backup_complet }")
+    set_dependence_variable("backup_folder", backup_folder)
+    set_dependence_variable("backup_name", backup_name)
+    set_dependence_variable("backup_path", backup_path)
+  end
+
+  def set_backups_to_delete
+    folders_backups_to_delete   = []
+    catalog_backups_to_delete   = []
+    number_stored_backups       = get_dependence_value("static", "number_backup_stored")
+    stored_entries              = Dir.entries(get_dependence_value("folders", "backups_folder_data_local")) - [".","..","current"]
+    catalog_backups             = get_dependence_variable("catalog_backups")
+    (stored_entries.sort.reverse[number_stored_backups..stored_entries.size] || []).each do |backup|
+      folders_backups_to_delete << backup
+      cbtd = catalog_backups.select { |b| b['folder'] == "#{ get_dependence_value("folders", "backups_folder_data_local") }/#{ backup }" }
+      if cbtd.any?
+        catalog_backups_to_delete << cbtd
+      end
+    end
+    # set dependence_variable to delete system folders
+    set_dependence_variable("backup_folders_to_delete", folders_backups_to_delete)
+
+    # anyway, need to delete?
+    set_flag("delete_system_backups_if_any",  folders_backups_to_delete.any?)
+
+    # set depedendece variable to delete catalog files
+    set_dependence_variable("backup_catalog_to_delete", catalog_backups_to_delete.flatten.uniq.map{ |b| '1' })
+    # any way, need to delete?
+    set_flag("delete_catalog_backups_if_any", catalog_backups_to_delete.any?)
+
+  end
+
+  def get_last_backup_size(backup_type)
+    size           = 0
+    system_backups = get_dependence_variable("system_backups")
+    if backup_type == 'complet'
+      complet_and_current = system_backups.select { |backup| backup['type'] == 'complet' and backup['current']}
+      complet_and_current.each do |backup_entry|
+        size += File.size("#{ get_dependence_value("folders","backups_folder_data_local") }/current/#{ backup_entry['name'] }")
+      end
+    elsif backup_type == 'diff'
+      # get the last diff backups
+      last_diff_backups = system_backups.select{ |backup| backup['type'] == 'diff' and not backup['isolate'] }
+      # select all the backup files with the same dar_name and calculate size if we have a last_diff_backup
+      if last_diff_backups and last_diff_backups.any?
+        system_backups.select { |backup| backup['dar_name'] == last_diff_backups.last['dar_name'] }.each do |backup_entry|
+          size += File.size("#{ get_dependence_value("folders","backups_folder_data_local") }/#{ backup_entry ['folder'] }/#{ backup_entry['name'] }")
+        end
+      end
+    end
+    size
+  end
+end
+
+
+module Gat
+
+  module Action
+
+    class ShellCommand < Base
+
+      # dar mixes a little bit its stdout and stderr outputs
+      def reinterpret_output_and_error(output, error, status)
+        all_errors = error.split("\n")
+        all_outputs = output.split("\n")
+        ret_error = Array.new
+        ret_output = ""
+        all_errors.each do |line|
+          if line != ""
+            if line == "No terminal found for user interaction. All questions will be assumed a negative answer (less destructive choice), which most of the time will abort the program."
+              status = 0 if status == 5
+            else
+              ret_error << line
+            end
+          end
+        end
+        add_next_line = false
+        all_outputs.each do |line|
+          if add_next_line
+            ret_error << line
+            add_next_line = false
+          elsif line.index("FATAL error") == 0
+            ret_error << line
+            status = 99 if status == 0
+            add_next_line = true
+          elsif line.index("Error") != nil
+            ret_error << line
+            status = 99 if status == 0
+            add_next_line = true
+          else
+            ret_output = line + "\n"
+          end
+        end
+        return ret_output, ret_error.join(". \n"), status
+      end
+    end
+
+  end
+
+end

data/lib/gatgets/dar_backup/dar_backup.yml

@@ -0,0 +1,387 @@
+# Gatget Config Script for DarBackup Gatget
+# -----------------------------------------
+
+description: 'Gatget backup manager with DAR'
+
+static:
+  complet_backup_days:  [ 0 ]
+  number_backup_stored: 1
+  # mysql dumps options
+  mysql_dumps: false
+  mysql_user: root
+  mysql_password: ''
+
+  # space limit to perform backup, in megas
+  space_thresold: 3000M
+
+  # dar tunned options
+  # enable compression. nil disable
+  dar_compression: 256
+  # size of division each file
+  dar_file_size: 3500M
+  # enable backup empty folders
+  dar_enable_empty_folders: true
+  # root folder from backup
+  dar_root_backup: '/'
+  # password to encrypt backups
+  dar_encrypt_passwd: 'none'
+  # password to decrypt backups
+  dar_decrypt_passwd: 'none'
+  # exclude foolders
+  exclude_folders:
+    - boot
+    - dev
+    - lib64
+    - media
+    - opt
+    - root
+    - selinux
+    - sys
+    - usr
+    - cdrom
+    - lib
+    - lost+found
+    - mnt
+    - proc
+    - sbin
+    - srv
+    - tmp
+    - home
+    - var
+    - etc
+  # exclude files
+  exclude_files:
+    - *.dar
+    - /initrd.img.old
+    - /vmlinuz
+    - /initrd.img
+    - /vmlinuz.old
+  exclude_to_compress:
+    - *.gz
+    - *.bz2
+    - *.zip
+    - *.png
+
+arguments:
+  search_pattern:
+    description: File or Folder pattern to search in catalog
+  backup_dar_name:
+    description: "Backup Dar name (for example: 2009_08_01_your_machine_complet)"
+  backup_id:
+    description: "Backup Dar catalog ID from data will be restored"
+  pattern_to_restore:
+    description: "Pattern to restore. It will be restored all the files or folder that match with pattern, even they are folders, subfolders, or files"
+
+folders:
+  backups_folder:
+    path: /tmp/backups
+    tree:
+      - data
+      - data/local
+      - data/external
+      - catalog
+      - extras
+      - extras/mysql
+      - restore
+
+programs:
+  dar:
+    description: Disk Linux Archive
+  dar_manager:
+    description: Dar manager for backups
+  mysql:
+    description: MySQl client
+  mysqldump:
+    description: Mysql Dumper
+  gzip:
+    description: Compressor
+
+
+parameters:
+  backup_id:
+    type: dependence
+    value: arguments/backup_id
+  backup_files:
+    type: dependence
+    value: variable/backup_launch_argument
+  backups_folder_mysql:
+    type: dependence
+    value: folders/backups_folder_extras_mysql
+  backups_folder_data_local:
+    type: dependence
+    value: folders/backups_folder_data_local
+  backups_folder_restore:
+    type: dependence
+    value: folders/backups_folder_restore
+  backup_path:
+    type: dependence
+    value: variable/backup_path
+  backups_path_for_dar:
+    type: dependence
+    value: variable/system_backups
+    array_method: "select{|b| b['isolate'] }.map{|b| b['folder'] + '/' + b['dar_name'].gsub(/_isolate$/,'') }"
+  catalog_path:
+    type: dependence
+    value: variable/catalog_path
+  catalog_entries:
+    type: dependence
+    value: variable/catalog_backups
+    array_method: "map{|b| '1' }"
+  complete_folder:
+    type: dependence
+    value: variable/backup_folder
+  current_date:
+    type: eval
+    value: "Date.today"
+  dar_compression:
+    type: dependence
+    value: static/dar_compression
+  dar_encrypt_password:
+    type: dependence
+    value: static/dar_encrypt_passwd
+  dar_decrypt_password:
+    type: dependence
+    value: static/dar_decrypt_passwd
+  dar_file_size:
+    type: dependence
+    value: static/dar_file_size
+  dar_manager_program:
+    type: dependence
+    value: programs/dar_manager
+  dar_program:
+    type: dependence
+    value: programs/dar
+  dar_root_backup:
+    type: dependence
+    value: static/dar_root_backup
+  exclude_to_compress:
+    type: dependence
+    value: static/exclude_to_compress
+    join: "' -Z '"
+  exclude_folders:
+    type: dependence
+    value: static/exclude_folders
+    join: "' -P '"
+  gzip_program:
+    type: dependence
+    value: programs/gzip
+  last_backup_size:
+    type: dependence
+    value: variable/last_backup_size
+  mysql_databases:
+    type: dependence
+    value: action_output/get_mysql_databases
+    array_method: 'split("\n")'
+  mysql_dump_program:
+    type: dependence
+    value: programs/mysqldump
+  mysql_password:
+    type: dependence
+    value: static/mysql_password
+  mysql_program:
+    type: dependence
+    value: programs/mysql
+  mysql_user:
+    type: dependence
+    value: static/mysql_user
+  pattern_simple_for_search:
+    type: dependence
+    value: arguments/search_pattern
+  pattern_to_restore:
+    type: dependence
+    value: arguments/pattern_to_restore
+  old_backups_at_catalog_ids:
+    type: dependence
+    value: variable/backup_catalog_to_delete
+  old_system_backups:
+    type: dependence
+    value: variable/backup_folders_to_delete
+  server_name:
+    type: dependence
+    value: static/server_name
+  show_backup_path:
+    type: dependence
+    value: variable/backup_to_show_content
+
+actions:
+  delete_old_mysql_dumps:
+    type: shell_command
+    flags: [ active_mysql_dumps ]
+    syntax: rm -f {{backups_folder_mysql}}/*.sql.gz {{backups_folder_mysql}}/*.sql
+    onfail: continue
+  get_mysql_databases:
+    type: shell_command
+    flags: [ active_mysql_dumps ]
+    syntax: "{{mysql_program}} -u {{mysql_user}} -p'{{mysql_password}}' -NBse 'Show databases'"
+    onfail: continue
+  do_mysql_dumps:
+    type: shell_command
+    flags: [ active_mysql_dumps ]
+    syntax: "cd {{backups_folder_mysql}}; {{mysql_dump_program}} -u {{mysql_user}} -p'{{mysql_password}}' {{mysql_databases}} -r mysqldump_{{mysql_databases}}_{{current_date}}.sql"
+    multiple: [ mysql_databases ]
+  compress_mysql_dumps:
+    type: shell_command
+    flags: [ active_mysql_dumps ]
+    syntax: "cd {{backups_folder_mysql}}; {{gzip_program}} -9 mysqldump_{{mysql_databases}}_{{current_date}}.sql"
+    multiple: [ mysql_databases ]
+  remove_old_system_backups:
+    type: shell_command
+    flags: [ delete_old_backups, delete_system_backups_if_any ]
+    syntax: 'rm -rf {{backups_folder_data_local}}/{{old_system_backups}}'
+    multiple: [ old_system_backups ]
+  remove_old_catalog_backups:
+    type: shell_command
+    flags: [ delete_old_backups, catalog_exists, delete_catalog_backups_if_any ]
+    syntax: '{{dar_manager_program}} -B {{catalog_path}} -D {{old_backups_at_catalog_ids}}'
+    multiple: [ old_backups_at_catalog_ids ]
+  remove_old_current_link:
+    type: shell_command
+    flags: [ delete_current_link ]
+    syntax: 'rm {{backups_folder_data_local}}/current'
+    onfail: continue
+  create_new_complet_folder:
+    type: shell_command
+    flags: [ new_complete_folder ]
+    syntax: 'mkdir -p {{backups_folder_data_local}}/{{complete_folder}}'
+  set_new_current_link:
+    type: shell_command
+    flags: [ new_complete_folder ]
+    syntax: 'cd {{backups_folder_data_local}} ; ln -sf {{complete_folder}} current'
+  launch_backup:
+    type: shell_command
+    syntax: "cd {{backups_folder_data_local}}; {{dar_program}} -w -m {{dar_compression}} -y -s {{dar_file_size}} -D -Q -R {{dar_root_backup}} -Z '{{exclude_to_compress}}' -P '{{exclude_folders}}' -X '*.dar' -J {{dar_encrypt_password}} -K {{dar_decrypt_password}} {{backup_files}}"
+    onfail: continue
+    onfail_callback: launch_backup_rescue
+  test_backup:
+    type: shell_command
+    syntax: "{{dar_program}} -Q -t {{backup_path}} -K {{dar_decrypt_password}}"
+  create_isolation_file:
+    type: shell_command
+    syntax: "{{dar_program}} -w -Q -C '{{backup_path}}_isolate' -A '{{backup_path}}' -J {{dar_decrypt_password}}"
+  identify_backups_in_catalog:
+    type: shell_command
+    flags: [ catalog_exists ]
+    syntax: '{{dar_manager_program}} -B {{catalog_path}} -l'
+  create_catalog:
+    type: shell_command
+    flags: [ '!catalog_exists' ]
+    syntax: '{{dar_manager_program}} -C {{catalog_path}}'
+  insert_in_catalog:
+    type: shell_command
+    syntax: "{{dar_manager_program}} -Q -B {{catalog_path}} -A '{{backup_path}}_isolate' '{{backup_path}}'"
+  list_backups_data:
+    type: ruby_method
+  delete_all_backups_at_catalog:
+    type: shell_command
+    flags: [ catalog_exists, catalog_is_not_empty ]
+    syntax: '{{dar_manager_program}} -B {{catalog_path}} -D {{catalog_entries}}'
+    multiple:  [ catalog_entries ]
+  insert_all_backups_at_catalog:
+    type: shell_command
+    flags: [ catalog_exists ]
+    syntax: "{{dar_manager_program}} -Q -B {{catalog_path}} -A '{{backups_folder_data_local}}/{{backups_path_for_dar}}_isolate' '{{backups_folder_data_local}}/{{backups_path_for_dar}}'"
+    multiple:  [ backups_path_for_dar ]
+  search_simple:
+    type: shell_command
+    flags: [ catalog_exists ]
+    syntax: "{{dar_manager_program}} -B {{catalog_path}} -f {{pattern_simple_for_search}}"
+    onfail: continue
+  show_nice_search:
+    type: ruby_method
+  show_backup_content:
+    type: shell_command
+    syntax: "{{dar_program}} -l {{backups_folder_data_local}}/{{show_backup_path}} -K {{dar_decrypt_password}}"
+    flags: [ exists_backup_file ]
+    output: true
+  restore_pattern:
+    type: shell_command
+    flags: [ exists_backup_file ]
+    syntax: "{{dar_program}} -x {{backups_folder_data_local}}/{{show_backup_path}} -R {{backups_folder_restore}} -K {{dar_decrypt_password}} -v -g '{{pattern_to_restore}}' -O"
+    output: true
+  delete_bad_backup:
+    type: shell_command
+    syntax: "rm -rf {{backup_path}}*.dar"
+  check_enough_space_for_backup:
+    type: ruby_method
+    onfail_message: 'System does not have enough space'
+  exit_if_i_am_running:
+    type: ruby_method
+    onfail_message: 'I am already running, I will exit now'
+  print_status:
+    type: ruby_method
+
+operations:
+  do_backup:
+    description: 'Perform a Backup with DAR. Backups can be tuned by config'
+    users:      [ root ]
+    programs:   [ dar, dar_manager, mysql, mysqldump, gzip ]
+    arguments:  [ ]
+    folders:    [ backups_folder ]
+    helpers:    [ exit_if_i_am_running, set_flag_mysql_dumps, set_flag_catalog_exists, get_all_backups, set_do_backup_variables ]
+    actions:    [ delete_old_mysql_dumps, get_mysql_databases, do_mysql_dumps, compress_mysql_dumps,
+                  remove_old_catalog_backups, remove_old_system_backups, remove_old_current_link,
+                  check_enough_space_for_backup, create_new_complet_folder, set_new_current_link,
+                  launch_backup, test_backup,
+                  create_isolation_file, create_catalog, insert_in_catalog ]
+    outputs:    [ ]
+
+  list_backups:
+    description: 'List avalaible backups at System && Catalog'
+    users:      [ root ]
+    programs:   [ dar_manager ]
+    arguments:  [  ]
+    folders:    [ backups_folder ]
+    helpers:    [ set_flag_catalog_exists, get_all_backups ]
+    conditions: [ ]
+    actions:    [ list_backups_data ]
+    onfail:     [ ]
+    outputs:    [ template ]
+
+  syncronize_backups:
+    description: 'Syncronize catalog with avalaible system backups'
+    users:      [ root ]
+    programs:   [ dar_manager ]
+    arguments:  [  ]
+    folders:    [ backups_folder ]
+    helpers:    [ exit_if_i_am_running, set_flag_catalog_exists, get_all_backups, catalog_is_empty ]
+    conditions: [ ]
+    actions:    [ delete_all_backups_at_catalog, insert_all_backups_at_catalog ]
+
+  search:
+    description: 'Search files to restore in backups'
+    users:      [ root ]
+    programs:   [ dar_manager ]
+    arguments:  [ search_pattern ]
+    folders:    [ backups_folder ]
+    helpers:    [ set_flag_catalog_exists ]
+    outputs:    [ template, yml ]
+    conditions: [ ]
+    actions:    [ search_simple, show_nice_search ]
+
+  show_backup_content:
+    description: 'Show all the backup contents. Redirect to a file if your backup content has many information'
+    users:      [ root ]
+    programs:   [ dar ]
+    arguments:  [ backup_dar_name ]
+    folders:    [ backups_folder ]
+    helpers:    [ exists_backup_file]
+    conditions: [ ]
+    actions:    [ show_backup_content ]
+
+  restore:
+    description: 'Allow to restore files || directory from backups, files will be restored under <your backup folder>/restore'
+    users:      [ root ]
+    programs:   [ dar ]
+    arguments:  [ pattern_to_restore, backup_dar_name ]
+    folders:    [ backups_folder ]
+    helpers:    [ exists_backup_file ]
+    conditions: [ ]
+    actions:    [ restore_pattern ]
+
+  status:
+    description: 'Checks whether the backup script is running'
+    users:      [ root  ]
+    actions:    [ print_status ]
+
+
+