gat 0.2.8

data/lib/gat/checks.rb

@@ -0,0 +1,136 @@
+=begin
+
+  :file   => checks.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::Checks Module
+  #
+  # Check methods return true or false through some arguments. Extend module if you want to add more checkable methods
+  #
+  # Check methods are hash based to better human arguments readeable. I mean, when you make a comparation beetwen two
+  # values, it is better to use arguments[:small] > arguments[:big] thatn arguments[0] > arguments[1]
+  #
+  # So, need_arguments method is avaible as public inside this module. This function will check the arguments hash
+  # and raise a GatgetConfixException if check_method miss one argument. For example
+  #
+  # def check_minor_than(arguments)
+  #  need_arguments(['minor', 'major'], arguments)
+  #  arguments['minor'] < arguments['major']
+  # end
+  #
+  # check_minor_than('minor' => 10, 'bigger' => 20)   # =>  raise GatgetConfigException
+  # check_minor_than('minor' => 10, 'major' => 20)    # =>  true
+  # check_minor_than('minor' => 20, 'major' => 10)    # =>  false
+  module Checks
+
+    # Files checkers!!!!!!
+    # --------------------
+
+    # Check if file exist
+    def check_file_exists(arguments)
+      need_arguments(['file_url'], arguments)
+      File.exists?(arguments['file_url'])
+    end
+
+    # Check if file exist
+    def check_file_not_exists(arguments)
+      need_arguments(['file_url'], arguments)
+      !File.exists?(arguments['file_url'])
+    end
+
+    def check_enough_space(arguments)
+      need_arguments(['where', 'space_needed'], arguments)
+      # get space at where
+      space = %x[ df -B 1 #{ arguments['where'] }].split("\n").last.split(" ")[3].to_i
+      space > arguments['space_needed'].to_i
+    end
+
+    def check_true(arguments)
+      need_arguments(['true_expression'], arguments)
+      eval("#{ arguments['true_expression'] }")
+    end
+
+    def check_false(arguments)
+      need_arguments(['false_expression'], arguments)
+      !eval(arguments['false_expression'])
+    end
+
+
+
+    # need_arguments checks that all the needed arguments are in array
+    # raise GagetConfigException if someone is not avaliable
+    def need_arguments(needed, avalaible)
+      needed.each do |need|
+        unless avalaible.keys.include?(need)
+          raise GatgetConfigException.new("needed argument #{ need } not avalaible at #{ self.class.name }", "need_arguments")
+        end
+      end
+    end
+
+    def exit_if_i_am_running(myname = nil)
+      if check_i_am_running(myname)
+        exit 0
+      end
+    end
+
+    def check_i_am_running(myname = nil)
+      # lock dirs/files
+      myname ||= File.basename($0, ".rb")
+      lockdir="/tmp/#{myname}-lock"
+      pidfile="#{lockdir}/PID"
+
+      ### start locking attempt
+
+      r = FileUtils.mkdir(lockdir) rescue r = nil
+      if not r.nil?
+          # lock succeeded, install signal handlers and store the PID
+          trap 0, proc { p "Trapped"
+FileUtils.rm_rf lockdir }
+          r = File.open(pidfile, 'w') {|f| f.write($$) }
+      else
+          # lock failed, now check if the other PID is alive
+          begin
+            f = File.open(pidfile, 'r')
+            otherpid = f.readline.to_i
+          rescue
+            # if it wasn't possible to read the file anymore, another instance probably is
+            # about to remove the lock -- exit, we're *still* locked
+            return true
+          end
+          r = Process.kill(0, otherpid) rescue r = nil
+          if r == nil
+              # lock is stale, remove it and go on
+              trap 0, proc { p "Trapped"
+FileUtils.rm_rf lockdir }
+              r = File.open(pidfile, 'w') {|f| f.write($$) } rescue r=nil
+              return false
+          else
+              # lock is valid and otherpid is active - exit, we're locked!
+              return true
+          end
+      end
+      return false
+    end
+
+
+  end
+end

data/lib/gat/debug.rb

@@ -0,0 +1,29 @@
+=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
+  module Debug
+
+    def print_debug_msg(message)
+      $stdout.puts "* debug *:  #{ message } \n"
+    end
+    
+    def get_debug_levels
+      { "trace" => 4, "message" => 3, "warning" => 2, "error" => 1, "direct_output" => 0 }
+    end
+  end
+end

data/lib/gat/dependence/argument.rb

@@ -0,0 +1,62 @@
+module Gat
+ module Dependence
+    class Argument < Base
+
+      attr_reader :position
+      attr_reader :optional
+      attr_reader :prefix
+      attr_reader :type
+      
+      attr :value
+
+      def initialize(name, config, operation)
+	
+	super(name, config, operation)
+	# by default, argument is command line
+	@type     = @config['type']     || 'command_line'
+	@optional = @config['optional'] || false
+	@prefix	= @config['prefix']   || nil
+	
+	@@argument_position ||= 0
+	@position = ( @@argument_position += 1 )
+
+      end
+      
+      # Argument must come
+      def evalue
+	# command line arguments
+	if self.type == 'command_line' and self.operation.gatget.arguments.any? and self.operation.gatget.arguments[self.position]
+	  
+	  # ToDo => add prefix to arguments
+	  # if self.position == 'prefix'
+	    #prefix_position = self.operation.gatget.arguments.index(self.prefix)
+	    #self.value	  = self.operation.gatget.arguments[
+	  # else
+	    self.value = self.operation.gatget.arguments[self.position]
+	  # end
+	  
+	# get arguments
+	elsif self.type == 'get' or self.type == 'get_password'
+	  
+	  # log direct question
+	  get_question = self.config['get_question'] || "Gatget need a value for argument #{ self.name } (#{ self.description })"
+	  
+	  self.operation.gatget.logger.log("direct", 'get_argument', get_question)
+					  
+	  system "stty -echo" if self.type == 'get_password'   # remove letter echo
+
+	  self.value = $stdin.gets.chomp
+	  
+	  system "stty echo" if self.type == 'get_password'   # remove letter echo
+	  
+	# argument missing but not required
+	elsif self.optional
+	  self.operation.gatget.logger.log("info", "missing argument #{ self.name } at operation #{ self.operation.name }. Argument is marked as optional")
+	else  
+	  raise GatgetArgumentException.new("Missing dependence argument #{ self.name } (@#{ self.type}) ", "evalue_program_dependence")
+	end
+      end
+
+    end
+  end
+end

data/lib/gat/dependence/base.rb

@@ -0,0 +1,54 @@
+=begin
+
+  :file   => dependences.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
+  module Dependence
+    class Base
+
+      attr_reader :operation
+      attr_reader :config
+      attr_reader :name
+      attr_reader :type
+      attr_reader :description
+      
+      
+      attr_accessor :value
+
+
+      def initialize(name, config, operation)
+	operation.gatget.logger.log("trace", "dependence", "Initialize dependence #{ self.class } @#{ name }")
+	@operation    = operation
+	@config       = config
+	@name         = name
+	@description  = @config['description'] || "Another #{ self.class } dependence named #{ self.name }"
+      end
+      
+      
+      def evalue
+	raise GatgetException.new("Evalue method is not available at Gat::Dependece. Create your own at #{ self.class }", 'evalue_dependence_without_type')
+      end
+      
+    end
+  end
+end
+

data/lib/gat/dependence/folder.rb

@@ -0,0 +1,104 @@
+module Gat
+  module Dependence
+    class Folder < Base
+      
+      attr_reader :value
+      attr_reader :path
+      attr_reader :config
+      attr_reader :mode
+      
+      attr :tree
+      
+      def initialize(name, config, operation)
+	super(name, config, operation)
+	@type = config['type'] || 'normal'
+	@tree = { }
+	@path = config['path'] || ''
+	@mode = config['mode'] || 0700
+      end
+      
+      # Folders
+      def evalue
+	if self.path.blank?
+	  raise GatgetConfigException.new("folder #{ self.name } doesnt have a path attribute at config", 'evalue_folder_dependence')
+	end
+      
+	# mount directory
+	mounted? if self.type == 'mount'
+
+        # main folder
+	unless File.exists?(self.path) and File.directory?(self.path)
+	  FileUtils.mkdir_p(self.path, :mode => self.mode)        
+	end
+	
+	# tree
+	if self.config['tree'] and self.config['tree'].any?
+	  self.config['tree'].each do |subfolder|
+	    absolut_folder = "#{ self.path }/#{ subfolder }"
+	    unless File.exists?(absolut_folder) and File.directory?(absolut_folder)
+	      FileUtils.mkdir_p(absolut_folder, :mode => self.mode)
+	    end
+	    self.tree["#{ self.name }_#{ subfolder.gsub(/\//,'_') }"] = absolut_folder
+	  end
+	end
+      end
+      
+      # Folder dependence value is special, because it can be the root folder or one subfolder at tree
+      # so, we dont have a value attribute but method, and this method check by folder_name, which folder do we want
+      def value(folder_name)
+	ret = ''
+	if folder_name == self.name
+	  ret = self.path
+	elsif self.tree.any?
+	  self.tree.each_pair do |subfolder_name, subfolder_path|
+	    ret = subfolder_path if subfolder_name == folder_name
+	  end
+	end
+
+	if ret.blank?
+	  raise GatgetException.new("Value for folder dependence #{ folder_name } doesnt return results", "value_folders_dependence")
+	end
+	ret     
+      end
+      
+      private
+      # check if folder is mounted, if not, try it, if doesnt work, launch GatgetProcessException
+      def mounted?
+        unless already_mounted? 
+          unless mount_folder
+            raise Gat::GatgetProcessException.new("Unable to mount folder #{ self.name } at #{ self.path }", "mounted")
+	  end
+	end
+      end
+      
+    
+      # Open Unix mounts folder and test that mounts table contents main folder
+      def already_mounted?
+        mounts_file = File.open('/proc/mounts', 'r')
+        mounted = false
+        mounts_file.each_line do |mount_line|
+          mounted = true if mount_line.split(" ")[2].include?(self.path)
+        end
+        mounted
+      end
+      
+      
+      def mount_folder
+        self.operation.gatget.logger.log("trace", "mount_folder", "Folder #{ self.name } is not mounted. Triying to mount")
+        
+        pid_open4, stdin, stdout, stderr = Open4::popen4 "mount #{ self.path  }"
+        
+        ignored, status_open4 = Process::waitpid2 pid_open4
+        
+        if status_open4.exitstatus == 0   # try to mount_folder
+          self.operation.gatget.logger.log("trace", "mount_folder", "Folder #{ self.name } nicely mounted ")
+          ret = true
+        else
+          self.operation.gatget.logger.log("error", "mount_folder", "#{ stderr.read }")
+          ret = false
+        end
+        ret
+      end
+    end
+  end
+end

data/lib/gat/dependence/program.rb

@@ -0,0 +1,36 @@
+module Gat
+  module Dependence
+    class Program < Base
+      
+      attr_reader :path
+      
+      def initialize(name, config, operation)
+	super(name, config, operation)
+	@type = @config['type'] || 'external'
+        @path = @config['path'] || false
+      end
+      
+      def evalue
+        self.path || evalue_from_shell
+      end
+      
+      # Program is evalued through 'which' shell command
+      def evalue_from_shell
+	errors     = ''
+	output     = ''
+	process_id = ''
+	status = Open4.popen4 "which #{ self.name }" do |pid, stdin, stdout, stderr|
+		  process_id = pid
+		  errors     = stderr.readlines.join('')
+		  output     = stdout.readlines.join('')
+		end
+
+	if not output.blank? and errors.blank? and status.exitstatus == 0
+	  self.value = output.strip
+	else
+	  raise GatgetConfigException.new("Dependece program #{ self.name } not found", "evalue_program_dependence")
+	end
+      end
+    end
+  end
+end

data/lib/gat/email.rb

@@ -0,0 +1,80 @@
+=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
+  module Email
+    
+    # Create and deliver a email    
+    def create_and_deliver_email(to, email_config, deliver_config)
+      email = new_email(to, deliver_config.merge(email_config))
+      send_email(email, deliver_config)
+    end
+    
+    
+    def send_email(email, smtp_config)
+      
+      if !smtp_config or smtp_config.empty? or !smtp_config['send_by']
+        raise GatgetConfigException.new('email_config is empty or missing or send_by is not defined', 'send_email')
+      end
+
+      domain     = self.config['server_domain']  || 'localhost'
+      email_from = smtp_config["send_from"] 	 || "#{ self.class.name }@#{ domain }"
+
+
+      case smtp_config['send_by']
+        when 'smtp'
+          server    = smtp_config['smtp_config']["server"]   || 'localhost'
+          port      = smtp_config['smtp_config']["port"]     || 25
+          user      = smtp_config['smtp_config']["user"]     || ""
+          password  = smtp_config['smtp_config']["password"] || ""
+
+          begin
+            Net::SMTP.start(server, port, server, user, password, :login) do |smtp|
+              smtp.send_mail email.encoded, email_from, email.destinations
+            end
+          rescue => error
+            raise GatgetConfigException.new(error, "send_email(smtp)", 
+              { :message => "Error sending mail to '#{email.destinations}' on '#{server}:#{port}': #{error}" })
+          end
+
+        when 'sendmail'
+
+          Net::SMTP.start('localhost', 25) do |smtp|
+            smtp.send_mail email.encoded, email_from, email.destinations
+          end
+          
+      else
+        raise GatgetConfigException.new("undefined send_mail method #{ smtp_config['send_by'] } at config", 'send_email')
+      end
+    end
+  
+    def new_email(to, options = {})
+
+      options ||= Hash.new
+      mail = TMail::Mail.new
+      mail.date = Time.now
+      mail.to = to
+      mail.subject = options['subject']    || "#{ self.class.name } email report"
+      mail.from = options['send_from']     || "#{ self.class.name.underscore }@#{ self.config['server_name'] }"      
+      mail.cc = options['cc']              if options['cc']
+      mail.bcc = options['bcc']            if options['bcc']
+
+      mail.body = options['body']          || "empty body"
+      mail
+    end
+  end
+end