gat 0.2.8

data/lib/gat/action/base.rb

@@ -0,0 +1,197 @@
+=begin
+
+  :file   => action/base.rb
+  :author => (c) 2008-2009 A.C. Gnoxys info@gnoxys.net
+
+  ######################################################################################
+  ## This file is part of GAT: http://gat.rubyforge.org                               ##
+  ##                                                                                  ##
+  ## 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
+
+
+  # Gat::Action::Base
+  #
+  # Action are pieces of operations. Actions are the objetives of dependences
+  # Actions have the next config options at YML definition
+  #
+  # <action_name> *must be uniq*
+  #  type: <shell_command> || <ruby_method>
+  #    Type of the action. It can be
+  #      - shell_command:  Action will execute a shell command
+  #      - ruby_method: Action will call a ruby_method called by action.name
+  #  flags: [ <action flags> ]
+  #    Conditional flags have to been passed to execute action. Action is skipped if only one flag failed
+  #    Flags can be marked as negative. For example, [ '!file_doesnt_exist' ]. In this case, flags must be marked as false
+  #    to result in action execution
+  #
+  #   syntax: "<shell_command_syntax">
+  #     Only in Shell Commands types, syntax is the command line form to be executed by Ruby Terminal.
+  #
+  #   multiple: ["<n multiple parameters>"]
+  #     Only in shell commands types.
+  #     If multiple isnt empty, Action will interprete multiple parameters as multiple values. That means, that gat expect
+  #	that multiple paramters return an array of values. Gat::Action will loop and execute each shell_command with these parameters substitions
+  #     For example, that is usefull to exec one command peer each File in one Dir.
+  #
+  #   onfail: "<continue> || <abort>"
+  #	What happens is action end with non 0 status
+  #
+  #   onfail_message: "<onfail_message>"
+  #	Custom message to be logged at error
+  #
+  #   onfail_callback: "<on_fail_callback>"
+  #     Custom ruby method that is executed if action fails
+
+  module Action
+
+    class Base
+
+      include Gat::Interpreter
+
+      attr_reader :operation
+      attr_reader :config
+      attr_reader :name
+      attr_reader :argument
+      attr_reader :description
+      attr_reader :flags
+      attr_accessor :error
+
+
+      attr_accessor :times
+      attr_accessor :output
+      attr_accessor :errors
+      attr_accessor :exit_level
+
+      attr_accessor :status
+
+      attr_accessor :parsed_syntax
+
+      attr_accessor :onfail
+      attr_accessor :onfail_message
+      attr_accessor :onfail_callback
+
+
+
+      # Get the current action
+      def self.get_current_action
+	@@current_action
+      end
+
+
+      def initialize(name, config, operation)
+
+	operation.gatget.logger.log("trace", "action", "Initialize action #{ self.class } @#{ name }")
+
+	@times            = Hash.new
+	@times['init']    = Time.now
+	@operation        = operation
+	@config           = config
+	@name             = name
+	@description      = config['description'] || "Another Action named #{ name }"
+	@flags            = config['flags'] || [ ]
+	@output           = ''
+	@error            = nil
+
+	@onfail           = config['onfail'] 	   || 'abort'
+	@onfail_message   = config['onfail_message']
+	@onfail_callback  = config['onfail_callback']
+
+	@@current_action = self
+      end
+
+
+      def execute
+
+	      if self.execute?
+
+	        self.run
+
+	        #self.set_outputs
+
+	        unless self.exit_level == 0
+            self.operation.gatget.logger.log("warning", "action_error", "#{self.error}")
+	          self.operation.gatget.logger.log("warning", "action_error", "Action #{ self.name } finished with status #{self.exit_level}")
+
+	          if self.onfail_callback
+	            self.operation.gatget.send(self.onfail_callback)
+	          end
+
+	          if self.onfail == 'abort'
+	            self.operation.gatget.logger.log('error', 'action_execute', "Action #{ self.name } abort Gatget")
+	            self.operation.status = 'fail'
+
+	            raise GatgetProcessException.new(self.error, "execute_action", self.onfail_message ? {:message => self.onfail_message} : {} )
+	          end
+	        end
+
+	      end
+
+	      @times['end'] = Time.now
+      end
+
+
+      # Execute? Method check if action must be executed. It test the follow conditions
+      # If flags is set, check that all flags are true
+      # If operation state is to abort or skip actions, skip actions
+      def execute?
+      	flags_ok? and status_ok?
+      end
+
+
+      private
+      # Check if action flags are ok...
+      def flags_ok?
+	      flags_ok = true
+	      marker_flag = nil
+
+	      if @flags and @flags.any?
+	        @flags.each do |flag|
+
+	          if flag[0..0] == '!'
+	            compare_with = false
+	            flag = flag.gsub(/^!/,'')
+	          else
+	            compare_with = true
+	          end
+
+	          unless self.operation.gatget.get_flag(flag) == compare_with
+	            flags_ok 	  = false
+	            marker_flag = flag
+	          end
+	        end
+	      end
+
+	      unless flags_ok
+	        self.operation.gatget.logger.log("message", "action", "Action #{ self.class } @#{ self.name } not mark to exec by flag: #{ marker_flag }")
+	      end
+	      flags_ok
+            end
+
+            def status_ok?
+	      status_ok = self.operation.status == 'ok'
+	      unless status_ok
+	        self.operation.gatget.logger.log("message", "action", "Operation #{ self.operation.name } is not marked as OK. Actions are skipped")
+	      end
+	      status_ok
+      end
+
+    end
+
+  end
+end

data/lib/gat/action/ruby_method.rb

@@ -0,0 +1,35 @@
+
+module Gat
+  module Action
+    class RubyMethod < Base
+
+      attr_accessor :status
+
+      def run
+
+      	self.exec
+
+      end
+
+
+      def exec
+	      self.operation.gatget.logger.log("trace", "action_syntax", "Action #{ self.name }  exec ruby method." )
+	      self.times['init'] ||= Time.now
+
+	      begin
+	        self.operation.gatget.send(self.name)
+	        self.status     = 'ok'
+	        self.exit_level = 0
+	      rescue => e
+	        self.error = e
+	        self.status     = 'failed'
+	        self.exit_level = 1
+	      end
+
+	      self.times['end'] ||= Time.now
+        self.exit_level
+      end
+    end
+
+  end
+end

data/lib/gat/action/shell_command.rb

@@ -0,0 +1,185 @@
+module Gat
+  module Action
+
+    class ShellCommand < Base
+
+      attr_reader :syntax
+      attr_reader :childs
+      attr_accessor :arguments
+
+      attr_accessor :pid
+      attr_accessor :status
+
+      def initialize(name, config, operation)
+      	super(name, config, operation)
+
+	      @syntax = config['syntax'] || raise(GatgetConfigException.new("Shell Command Action #{ name } has not a syntax attribute", "initialize_shell_command"))
+      end
+
+
+      def run
+        ret = nil
+	      # Shell Command can be multiple, that means the command will be execute over a foreach variable subtitutions.
+	      # That is usefull, for example, when you need to do the same actions with some variable subtition, like
+	      # a multiple files compression.
+	      @childs = (@config['multiple'] and @config['multiple'].any?) ? set_multiple_childs(@config['multiple']) : [ ]
+
+	      # If ShellCommand is multiple, then, we exec all of its childs
+	      # If not, we just execute ShellCommand instance
+	      if @childs.any?
+	        @childs.each { |child|
+            if not child.exec
+              ret = false
+            end
+          }
+	      else
+	        self.parsed_syntax = interpreter_parameters(self.syntax, self.operation.gatget)
+	        ret = exec(self.parsed_syntax)
+	      end
+
+	      if self.config['output']
+	        self.operation.gatget.logger.log("direct", "action_output", self.output)
+	      end
+        ret
+      end
+
+
+      # Execute shell command with Open4
+      #
+      # Open4 module is the next generation Ruby module for executing shell commands.
+      # Open4 works better thant the standard Open3 module, and has built inside the feature
+      # to return exit status through Process.status Class.
+      # Even it has some problems too. Open4 module has big problems when the stdout or the stderr comes
+      # with tons of information. For example, with a mysqldump output.
+      #
+      # The solution presented here is a wapper through Process.fork. We create a new fork, making
+      # and the output is not managed by the ruby script itself but by the fork process.
+      # IO.pipes are created to pass the stdout, stderr and stdin data through Gat proccess and Fork process
+      #
+      # Some disccusion about this can be readed here: http://stackoverflow.com/questions/1076257/returning-data-from-forked-processes
+      #
+      # Maybe, we could use Theread.new, and maybe it would be better, but... =)
+      #
+      def exec(shell_command, multiple_name = '')
+
+        trap_save = trap( 0, "IGNORE" )
+
+        self.operation.gatget.logger.log("trace", "action_syntax", "Action #{ self.name }#{ multiple_name } exec command syntax : #{ shell_command }" )
+
+	      self.times['init'] ||= Time.now
+
+	      read_stdout, write_stdout = IO.pipe
+	      read_stderr, write_stderr = IO.pipe
+
+	      pid = fork do
+          trap( 0, "IGNORE" )
+	        read_stdout.close
+	        read_stderr.close
+
+	        pid_open4, stdin, stdout, stderr = Open4::popen4 "#{ shell_command }"
+
+	        write_stdout.puts stdout.read
+	        write_stderr.puts stderr.read
+
+	        ignored, status_open4 = Process::waitpid2 pid_open4
+	        exit status_open4.exitstatus
+	      end
+        trap( 0, trap_save )
+
+	      write_stdout.close
+	      write_stderr.close
+
+	      result_stdout = read_stdout.read
+	      result_stderr = read_stderr.read
+
+	      pid, status = Process.wait2(pid)
+
+	      self.output, self.error, self.exit_level = reinterpret_output_and_error(result_stdout, result_stderr, status.exitstatus)
+
+	      self.pid = pid
+        self.status = status
+	      self.times['end'] = Time.now
+      end
+
+
+      def set_multiple_childs(multiples_parameters)
+	      # get multiples values
+	      multiples_values = {}
+	      multiples_parameters.each do |parameter|
+	        values = interpreter_parameter(parameter, self.operation.gatget)
+	        multiples_values[parameter] = values
+	      end
+
+	      # all multiple values must have the same size for substitution
+	      last_multiple_vales_size = multiples_values.values.first.size
+	      multiples_values.values.each do |values|
+	        unless values.size == last_multiple_vales_size
+	          raise GatgetConfigException.new("Multiples values at Action #{ self.name } doesnt have the same size. Substitution cannot be interpreted", "set_multiple_chids")
+	        end
+	        last_multiple_vales_size == values.size
+          end
+
+
+	        unless last_multiple_vales_size > 0
+	          raise GatgetConfigException.new("Multiples values at Action #{ self.name } are empty", "set_multiple_chids")
+	        end
+
+	        # create childs objects
+	        childs = []
+	        i = 0
+	        last_multiple_vales_size.times do
+	          child_multiple_parameters = {}
+	          multiples_values.each_pair do |parameter, values|
+	            child_multiple_parameters[parameter] = values[i]
+	          end
+	          childs << ShellCommandChild.new(self, child_multiple_parameters)
+	          i += 1
+	        end
+
+	        # return child
+	        childs
+        end
+
+      # Redefine this two methods in your class to clean or reinterpret the output and error
+      def reinterpret_output_and_error(output, error, status)
+	      return output == "\n" ? "" : output,
+	            error == "\n" ? "" : error, status
+      end
+
+    end
+
+
+    class ShellCommandChild
+      include Gat::Interpreter
+
+      attr_reader :parent
+      attr_reader :syntax
+      attr_reader :values
+      attr_reader :name
+
+      attr_accessor :syntax
+      attr_accessor :arguments
+
+
+      def initialize(parent, values)
+	      @parent    = parent
+	      @values    = values
+
+
+	      @syntax    = parent.syntax
+	      @name      = "#{ parent.name }*over* #{ values.values.join("_") }"
+      end
+
+      def exec
+	      # make the substitution of each parameter and exec like other action
+	      values.each_pair do |parameter_key, parameter_value |
+	        self.syntax = self.syntax.gsub(/\{\{#{ parameter_key }\}\}/, parameter_value)
+	      end
+
+	      parse_syntax = interpreter_parameters(self.syntax, self.parent.operation.gatget)
+ 	      self.parent.exec(parse_syntax, " *over* #{ values.values.join("_") }")
+      end
+
+    end
+  end
+end

data/lib/gat/boot.rb

@@ -0,0 +1,63 @@
+=begin
+
+  :file   => boot.rb
+  :author => (c) 2008-2009 A.C. Gnoxys info@gnoxys.net
+  
+  ######################################################################################
+  ## This file is part of GAT: http://gat.rubyforge.org                               ##
+  ##                                                                                  ##
+  ## 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
+
+
+# Boot File provides the starting point to execute gatget based script.
+#
+# Boot load required modules && classes for Gat::Base and other gems.
+# Differents exit levels are launched if requires files fails.
+#
+# Gat constants
+GAT_GATGETS   	= GAT_ROOT + '/gatgets'
+GAT_TEMPLATES 	= GAT_ROOT + '/templates'
+
+# External gems
+gems            = [ 'ftools', 'rubygems', 'open4', 'yaml', 'erb', 'rdoc/usage', 'rdoc/code_objects',
+                    'rdoc/markup/simple_markup', 'rdoc/markup/simple_markup/to_flow', 'rdoc/ri/ri_formatter',
+                    'rdoc/ri/ri_options', 'net/smtp', 'tmail', 'erb' ]
+
+# Gat Modules 
+modules         = [ 'debug', 'help', 'interpreter', 'extends', 'version', 'launcher', 'checks', 'email' ]
+
+# Gat Classes
+classes         = [ 'exceptions', 'operation', 'dependence/base', 'dependence/program', 'dependence/argument', 'dependence/folder',
+                    'action/base.rb', 'action/shell_command.rb', 'action/ruby_method.rb', 'logger' ]
+
+
+# Build required hash
+load_data 	= { 'gems'      => { 'data' => gems,    'path' => '',                            'exit' => 9 },
+		    'modules'   => { 'data' => modules, 'path' => "#{ GAT_ROOT + '/lib/gat/' }", 'exit' => 10 },
+		    'classes'   => { 'data' => classes, 'path' => "#{ GAT_ROOT + '/lib/gat/' }", 'exit' => 11 } }
+
+# Require all data
+load_data.each_pair do |key, value|
+  value['data'].each do |dependency|
+    begin
+      require value['path'] + dependency
+    rescue LoadError => msg
+      $stderr.puts "Error while loading #{ key }: #{ msg }"
+      $stderr.puts "[ ERROR ] Backtrace \n" + msg.backtrace.join("\n")
+      $stderr.puts "\nexit level #{ value['exit'] }"
+      exit value['exit']
+    end
+  end
+end