gat 0.2.8

data/History.txt

@@ -0,0 +1,84 @@
+== 0.2.8 2010-02-16
+* Bugfix release
+  * ShellCommandChilds was only executing for the first child
+  * Folder backups were not ordered when reading them for deletion
+  * Added more error messages to avoid meaningless messages
+* Tests
+  * Added a good lot of basic tests
+
+== 0.2.7 2009-11-12
+
+* Gat Improve
+  * Added mount capabilities to folder dependencies thourgh type 'mount'
+  * Starting with SPEC test
+* Dar Backup Fixes
+  * Fix Gat::Action.get_current_action bug. Now, Base class must be called, since me move action to module.
+
+
+== 0.2.6 2009-11-10
+
+* Gat Improve
+  * Moved action.rb and dependences.rb to more orderned folder structure.
+* Gat Fixes
+  * Fix blank domain at email default output
+* Dar Backup Fixes
+  * Fix. Invalid excution of delete catalog and system backups when no need to delete backups
+
+
+== 0.2.5 2009-10-23
+
+* Gat Fixes
+  * Incorrect mess in hour gatget times.
+* DarBackup changes:
+  * Added thresold concept. Space disk limit to perform backup
+* Syncronization
+  * First include of syncronization gatget.
+
+== 0.2.4 2009-10-20
+
+* Gat changes
+  * Exceptions has been revised. Now, inherit from StandardError insted of ::Exception
+  * Changed Exception error.
+  * Include new Argument support types (get and gat_password) which gets values from stdin.
+* GatgetManager Support.
+  * First release with GatgetManager, which is a gatget to control install of rest.
+  * Included launcher as bin executable, avalaible from instalation
+* DarBackup gatget Bug fixes
+  * Fixed argument of marked backups to delete.
+
+== 0.2.3 2009-10-18
+
+* Gat changes
+  * Permanent remove of conditions. Instead of, we will use helpers everywhere.
+  * Revised email default body and subjects.
+* DarBackup gatget Bug fixes
+  * Fixed argument of marked backups to delete.
+
+== 0.2.2 2009-10-02
+
+* Gat changes
+  * Temporal (or maybe permanent) deprecation of conditions
+* DarBackup gatget Bug fixes
+  * Incorrect compartion because slashes between current and date based folder for backups.
+  * Revised onfail launch method
+
+== 0.2.1 2009-09-30
+
+* 1 minor enhancement
+  * Gemified.
+
+== 0.2.0 2009-09-07
+
+* 1 major enhancement:
+  * Changed all gat structure from procedural to classes
+  * Removed gatget modules and converted actions, conditions, outputs, etc. to classes
+  * Gat start to be what we thought it will be :D
+  * Added templates
+
+
+== 0.1.0 2009-06-25
+
+* 1 major enhancement:
+  * Initial release
+  * Moved from IRGAT proyect
+  * Include Backup Gatget. Sync Gatget is still under development

data/PostInstall.txt

@@ -0,0 +1,22 @@
+    Gat Gem Post Install Doc
+===============================================================================
+
+    Gat provides several built in Gatgets. For now, it contains
+
+    - GatgetDarBackup => Performs and maintains a whole system of backups with
+dar (Disk Archiver for GNU/Linux)
+
+
+    To use this, simply copy the file named launcher.rb to the gatget install
+folder (default by gem, /usr/lib/ruby/gems/ruby1.8/gat/gatgets/<gatget_name>)
+and place it under your local executable folder (for example: /usr/local/bin).
+
+
+  For more information on gat, see http://gat.rubyforge.org
+
+
+===============================================================================
+  Copyright © 2007-2009 Gnoxys. http://www.gnoxys.net.
+  Gat is released under GPL v3.0 or higther. See README for more information
+
+

data/README.txt

@@ -0,0 +1,49 @@
+= G.A.T. (Gnoxys Administrations Tools)
+
+== DESCRIPTION:
+ 
+ GAT is a Ruby gem that tries to provide a script fast development framework.
+ 
+ Based on a YML structure, GAT allows you to write basic and advanced scripts with a whole set of tools that scripting need.
+ 
+ More info can be found at http://gat.rubyforge.org
+    
+ 
+== FEATURES/PROBLEMS:
+
+* Still in ALPHA release. Not recommended for production use
+
+== SYNOPSIS:
+
+
+== REQUIREMENTS:
+
+
+
+== INSTALL:
+
+Just type at console (as root or with sudo):
+
+    # gem install gat
+    
+
+== EXAMPLE
+
+Look into gatgets/example for an example of using GAT
+
+== LICENSE:
+
+  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. 

data/Rakefile

@@ -0,0 +1,12 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+
+Hoe.spec 'gat' do
+   developer('gnoxys', 'soporte@gnoxys.net')
+
+  # self.rubyforge_name = 'blahx' # if different than 'blah'
+end
+
+# vim: syntax=ruby

data/bin/gat

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+require 'gatgets/gatgets_manager/gatgets_manager'
+
+class MainGatgetsManagerScript < GatgetGatgetsManager #:nodoc:
+end
+
+# default options... see all options at Gatget config file GAT_ROOT + /lib/gatgets/gatget_manager/gatgets_manager
+
+options = {
+  'gatget_config' => { }
+  }
+
+# Launch Gatget
+MainGatgetsManagerScript.launch(options, ARGV)

data/lib/gat.rb

@@ -0,0 +1,323 @@
+=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
+
+# Gat Base Folder
+if File.symlink?(__FILE__)
+  GAT_ROOT = File.expand_path(File.dirname(File.readlink(__FILE__)) + '/..')
+else
+  GAT_ROOT = File.expand_path(File.dirname(__FILE__) + '/..')
+end
+
+# Gat Script Folder
+if File.symlink?($0)
+  GAT_SCRIPT_PATH = File.expand_path(File.dirname(File.readlink($0)))
+else
+  GAT_SCRIPT_PATH = File.expand_path(File.dirname($0))
+end
+
+# Gat BOOT
+require GAT_ROOT + '/lib/gat/boot'
+
+
+
+module Gat
+
+  # Gat::Base Class
+  #
+  # Gat::Base provides basic features, like logger, times, debug levels, a launcher controlled by exceptions and command line parsed
+  # Base class is, as we see, the container. It control the config and the whole process. But it is only the container,
+  # the process itlsef is runned by actions, conditions or operations.
+  #
+  # Gat::Base include then, methods to collect config information, mess the time, launch the script, etc... features that are usually needed
+  # by almost of the scripts
+  #
+  # Gat::Base now, delegate the execution to the Gat::Operation, but, we want that Gat::Base provides interaction framework, for
+  # example, interact with machine, creating onfly actions
+  class Base
+
+    # include module methods at base class
+    include Gat::Checks
+    include Gat::Debug
+    include Gat::Help
+    include Gat::Launcher
+    include Gat::Email
+
+    # set read only attributes
+    attr_reader :config
+    attr_reader :arguments
+    attr_reader :operation
+    attr_reader :debug
+    attr_reader :verbose
+    attr_reader :name
+    attr_reader :path
+
+
+    # set read && write attributes
+    attr :times
+    attr :logger
+    attr :variables
+    attr :flags
+
+    attr_accessor :onfail_error
+
+
+    # Initializes the Gat.Base class, reading the yaml script and any templates.
+    # Gat set a lot of variable accessors
+    # - logger:             through log method, store all the ouputs of a gatget process
+    # - times:              stores times references
+    # - config:             gatget config merged with option passed to the script
+    # - dependences:        needed information through the process
+    #
+    #
+    def initialize(options = {}, arguments = [])
+
+      @logger             = Logger.new(self)                         # start gatget_logger
+
+      @times              = Hash.new                                 # store time
+      @times['init']      = Time.now
+
+      @debug,arguments    = debug?(arguments)                        # load_debug
+      @verbose,arguments  = verbose?(arguments)                      # load_verbose
+
+      @config             = set_gatget_config(options)               # load config
+
+      @arguments       	  = arguments
+
+
+      @logger.log("message", "gatget", "Initialize #{ self.name } < #{ self.class.superclass.name } at script #{ $0 }" )
+      @logger.log("message", "gatget", "Gat::Version: #{ Gat::VERSION }, http://www.gnoxys.net")
+
+      # ToDO
+      # Gat, at this time, is only a operation framework. I mean, a gatget has many operation,
+      # like gat_password store_password || view_password.
+      # Then, at this point of development, we care only about these operations. But,
+      # inside gat planning, we want not only run operation but simulations or interactive
+      # programs, that doesnt have a start.steps.end structure, like console
+      #
+      # @operation, is though to be remove for gat::mode at future
+      #
+      @operation          = build_operation(arguments)          # load operation
+      @variables          = { }                                 # variables are empty at start
+      @flags              = { }                                 # flags are empty at start
+    end
+
+    # Return the config for a defined gatget element structure
+    # only arguments, folders, programs, actions, conditions, outputs element_types are allowed
+    #
+    # raise GatgetConfigException if none found
+    def get_element_config(element_type, element_name)
+
+      unless ['arguments', 'folders', 'programs', 'actions', 'conditions', 'parameters'].include?(element_type)
+        raise GatgetConfigException.new("undefined gat element type #{ element_type } in YML structure", "get_element_config")
+      end
+      @config[element_type] ||
+          raise(GatgetConfigException.new("'#{ element_type.capitalize }' section not defined in YML structure", "get_element_config"))
+      @config[element_type][element_name] ||
+                        raise(GatgetConfigException.new("'#{ element_type.capitalize }/#{ element_name }' element not found in YML structure",
+                                                        "get_element_config"))
+    end
+
+    def get_dependence_variable( variable_name )
+      get_dependence_value('variable', variable_name)
+    end
+
+    # Return the dependence value
+    # only arguments, folders, programs, static, variable are allowed
+    #
+    # raise GatgetConfigException if none found
+    def get_dependence_value(dependence_type, dependence_name)
+
+      unless ['arguments', 'folders', 'programs', 'static', 'variable', 'flags', 'action_output'].include?(dependence_type)
+        raise GatgetConfigException.new("undefined gat dependence type #{ dependence_type }", "get_dependence_value")
+      end
+
+      case dependence_type
+        when 'static'
+          ret = self.config['static'][dependence_name]
+        when 'variable'
+          ret = self.variables[dependence_name]
+        when 'folders'
+          dependence_folders = self.operation.send(dependence_type).select { |dependence| dependence_name[/^#{ dependence.name }/]}
+          if dependence_folders.any?
+             ret = dependence_folders.first.value(dependence_name)
+          else
+             ret = nil
+          end
+        when 'action_output'
+          ret = self.operation.get_action(dependence_name).output
+      else
+        values = self.operation.send(dependence_type)
+        if values.any?
+          ret = values.select { |dependence| dependence_name == dependence.name  }.first.value
+        else
+          raise GatgetConfigException.new("Empty dependence '#{dependence_type}', for operation '#{self.operation.name}'", "get_dependence_value")
+        end
+      end
+    end
+
+    # Set a value for a variable to be used along the script
+    # Override variable is warned at warning level
+    def set_dependence_variable(variable_name, variable_value)
+      if self.variables[variable_name]
+        @logger.log("warning", "dependence", "#{ self.class } rewrite variable #{ variable_name } at #{ Time.now }")
+      end
+
+      self.variables[variable_name] = variable_value
+    end
+
+    # Set flag value
+    def set_flag(flag_name, true_or_false)
+      self.flags[flag_name] = true_or_false
+    end
+
+    # Get flag value
+    def get_flag(flag_name)
+      ret = self.flags[flag_name]
+      if ret == nil
+        self.operation.gatget.logger.log("warning", "get_flag","Undefined flag #{flag_name}")
+        ret = false
+      end
+      ret
+    end
+
+    # Execute the gatget
+    # Now, this method just call the current operation and run it. As interactive mode, and after set dependences,
+    # execute method will run also @operations or another interactive process
+    def execute
+      if self.operation
+        self.operation.execute
+      else
+        raise GatgetConfigException("Operation is undefined!", "gatget_execute")
+      end
+    end
+
+
+    # Set the @config attribute to the gaget. This method read the Gatget YML config and merge with other possible inputs
+    #
+    # Gat gets the gatget name by the class.superclass method. So, a Gatget must be ALWAYS runned by a launchers see example for more information
+    #
+    # options Hash with some options
+    #  - config_file_path:  where the config file is stored. By default < gat_gem_install/gatgets/category/<gatget_name>.yml
+    #  - gatget_config:     override default options with launcher options
+    #  - gat_config:        link to common gatgets config at yml format
+    #
+    private
+    def set_gatget_config(options)
+
+      gatget_name = self.class.superclass.name.gsub(/^Gatget/,'').underscore
+      @path       = eval("GATGET_#{ gatget_name.upcase }_ROOT")
+      options ||= Hash.new
+      config_file = options['config_file_path'] || "#{ @path }/#{ gatget_name }.yml"
+
+      config = get_yaml_config("#{ config_file }") || Hash.new
+
+      # merge default yml script structure with specific instance options
+      if options['gatget_config'] and options['gatget_config'].any?
+          config = config.deep_merge(options['gatget_config'])
+      end
+
+      # include gat common config?
+      if options['gat_config']
+        gat_config = get_yaml_config(options['gat_config'])
+        config = config.deep_merge(gat_config)
+      end
+
+      # set attributes
+      @name         = gatget_name
+      @description  = config['description'] || 'Another Gatget'
+      @config_file  = config_file
+      @config       = config
+    end
+
+
+    # Get the YML config at one path
+    # Just to rescue the error formating at YML or so
+    #
+    def get_yaml_config(gatget_config_file)
+      begin
+        config_yml = YAML.load_file(gatget_config_file)
+      rescue => error_msj
+        raise GatgetConfigException.new(error_msj, 'get_yaml_config')
+      end
+      config_yml
+    end
+
+
+
+    # Evalue the gatget operation
+    #
+    # Gatget runs by operations, which *must* come as first aguments. For example. gat_backup do_backup, perform #do_backup# operations
+    # Detect if operations missing or not in config
+    def build_operation(arguments = [])
+
+      # Run help for gatget
+      help?(arguments)
+
+      # is gatget_operations defined?
+      unless @config['operations'] and @config['operations'].any?
+        raise GatgetConfigException.new("operations not defined in config: #{@config_file}", "build_operation")
+      end
+
+      # do we have an operation in arguments?
+      unless arguments.any?
+        gatget_help
+        raise GatgetArgumentException.new("no operation invoking gat", "build_operation")
+      end
+
+      # do we have an operation at config?
+      unless @config['operations'].include?(arguments.first)
+        gatget_help
+        raise GatgetArgumentException.new("operation `#{ arguments.first }` undefined invoking gat", "build_operation")
+      end
+
+      # return operation.new
+      operation = Gat::Operation.new(arguments.first, @config['operations'][arguments.first], self)
+    end
+
+
+    protected
+    # Set debug to Gat
+    def debug?(arguments)
+      debug = false
+      if arguments.include?('-d') or arguments.include?('--debug_mode')
+        debug = true
+        arguments = arguments - ['-d', '--debug_mode']
+      end
+      return debug, arguments
+    end
+
+    # Set verbose to gat
+    def verbose?(arguments)
+      verbose = 0
+      arguments.each do |argument|
+        if argument[/^-v/]
+          verbose = argument.count('v')
+          arguments = arguments - [ argument ]
+        end
+      end
+      return verbose, arguments
+    end
+
+    # Show help and exit
+    def help?(arguments)
+      if arguments.include?('-h') or arguments.include?('--help')
+        gatget_help
+        exit 0
+      end
+    end
+  end
+end