gat 0.2.8

data/lib/gat/logger.rb

@@ -0,0 +1,331 @@
+=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
+  class Logger
+
+    include Gat::Debug
+
+    attr_reader :gatget
+    attr_reader :global_types
+
+    attr_accessor :times
+    attr_accessor :entries
+
+    def initialize(gatget)
+      @global_types   = { 'trace'    => { 'description' => 'Traces debug logs', 'verbose' => 4 },
+        'message'  => { 'description' => 'Message by gat',    'verbose' => 3 },
+        'warning'  => { 'description' => 'Warnings',          'verbose' => 2 },
+        'error'    => { 'description' => 'Errors at Gatget',  'verbose' => 1 },
+        'direct'   => { 'description' => 'Direct Outputs',    'verbose' => 0 }
+      }
+
+      @gatget         = gatget || raise(GatgetException.new("Logger needs a gatget object", "initialize_logger"))
+      @times          = Hash.new
+      @times['init']  = Time.now
+      @entries        = Array.new
+    end
+
+
+
+    # Log method
+    # Store logs entry into entries array instance attribute
+    def log(*args)
+      log_entry = LogEntry.new(self, *args)
+      direct_output?(log_entry)
+      @entries << log_entry
+    end
+
+
+    # Gatget Logger output
+    # When operation or whatever is finish, gatget logger throw the outputs
+    #
+    # 3 Standar types are defined
+    #  - Template output: Template output works with ERB standard template rubye engine. Template is evalued at printed as direct log
+    #       Template is searched at <gatget_path>/templates/<operation_name>.erb
+    #
+    #  - Email output:    Email output deliver log to default email config or raise Exception. Default email config must be stored at
+    #       @gatget.config['email_config']. Multiple to address can be defined and smtp && sendmail deliver methods are avalaible
+    #
+    #  - YML output:    YML output consist in a dump of logger to a yml structure file, so, then, log can be easily interpreted. YML log must be stored
+    #       at /var/log/gat/<gatget_name>_<operation_name>_<time>.yml, so, log folder must we writtable or exception will be launched.
+    #
+    # Gat is planned to have more custom outputs by yml config like
+    #
+    #  At operation definition (gatget yml config)
+    #
+    # operations:
+    #   example_operation:
+    #     outputs: [ custom_template, custom_email]
+    #
+    # and then, at templates definition
+    #
+    # templates:
+    #   custom_template:
+    #     type: template
+    #     config:
+    #       path: <your custom template path>
+    #       log_level: <direct|warning|whatever>
+    #   custom_email:
+    #     type: email
+    #     config:
+    #       <overwrite here default email config>
+    #
+    # But it is still on mind :D
+    #
+    def output(type)
+      case type
+      when 'template','email','yml'
+        send("output_#{ type }")
+      else
+        # Now, do nothing! :D
+      end
+    end
+
+    def to_yaml
+      entries_hash_array = []
+      @entries.each do |entry|
+        entries_hash_array << entry.to_hash
+      end
+      entries_hash_array.to_yaml
+    end
+
+    def human_sume
+      process_resume = "Process Resume:\n---------------\n\n"
+      process_resume << " - Times: \n    * start:      #{ self.gatget.times['init'] }\n    * now:        #{ Time.now }\n    * secs:       #{ Time.now - self.gatget.times['init']} \n    * min:        #{ (Time.now - self.gatget.times['init'])/60 } \n    * hours:      #{ ( Time.now - self.gatget.times['init'])/3600 } \n\n"
+      process_resume << " - Logger:\n    * msgs:       #{ self.entries.size }\n    * warnings:   #{ self.entries.select{|e| e.global_type == 'warning' }.size }\n    * errors:     #{ self.entries.select{|e| e.global_type == 'error' }.size }\n\n"
+      process_resume << " - Whole log: \n#{ self.entries.map{ |e| "    * #{ e.inspect } \n" } }"
+      process_resume
+    end
+
+    private
+    # just output message if direct output is enabled by debug or by verbosity
+    def direct_output?(log_entry)
+      if @gatget.debug
+        print_debug_msg(log_entry.inspect)
+      else
+        $stdout.puts log_entry.output unless self.gatget.verbose < log_entry.verbose_level
+      end
+    end
+
+
+    # Standar template output
+    # See output for more information
+    def output_template
+      template_file = "#{ @gatget.path }/templates/#{ @gatget.operation.name }.erb"
+
+      # raise GatgetException if template not found
+      unless File.exists?(template_file)
+        raise GatgetException.new("Template for operation #{ @gatget.operation.name } not found at #{ template_file }", "run_outputs_template")
+      end
+
+      template_content = File.read(template_file)
+
+      # bind operation variable to template
+      operation = @gatget.operation
+      template = ERB.new(template_content,  0, "%<>")
+      @gatget.logger.log("direct", "operation_output_template", template.result(binding))
+    end
+
+    # Standar email output
+    # See output for more information
+    def output_email
+      # default email config is used
+      unless @gatget.config['email_config']
+        raise GatgetConfigException.new("Default email config is empty at @gatget.config['email_config']", "run_output_email")
+      end
+
+      if @gatget.operation.status == 'ok'
+        subject_prefix = 'OK'
+      elsif @gatget.operation.status == 'failed'
+        subject_prefix = 'ERROR'
+      else
+        subject_prefix = 'WARNING'
+      end
+
+      email_subject = "[GAT] [#{ @gatget.class }] [#{ @gatget.operation.name.camelize }] [#{ subject_prefix }]"
+
+      email_body    = "#{ @gatget.logger.human_sume }"
+
+      @gatget.create_and_deliver_email(@gatget.config['email_config']['send_to'], { 'subject' => email_subject, 'body' => email_body }, @gatget.config['email_config'])
+    end
+
+    # Standar yml output
+    # See output for more information
+    def output_yml
+      yml_log = File.new("/var/log/gat/#{ self.gatget.name.underscore }_#{ self.gatget.operation.name }_#{ Time.now.strftime("%Y%m%d%H%M%S") }.yml", "w+")
+      yml_log.write(self.gatget.logger.to_yaml)
+      yml_log.close
+    end
+
+  end
+
+
+  class LogEntry
+
+    attr_reader :logger
+    attr_reader :global_type
+    attr_reader :category
+    attr_reader :message
+    attr_reader :options
+    attr_reader :verbose_level
+    attr_reader :time
+
+
+    def initialize(logger, global_type = "trace", category = "undefined",  message = "Empty", *options)
+      @logger         = logger
+      @time           = Time.now
+      @global_type    = global_type
+
+      unless logger.global_types.keys.include?(global_type)
+        raise GatgetException.new("Undefined log global_type #{ global_type }", "initialize_log_entry")
+      end
+
+      @category       = category
+      @message        = message
+      @options        = options
+      @verbose_level  = logger.global_types[global_type]['verbose']
+    end
+
+
+    def inspect
+      "#{ self.time.strftime("%Y-%m-%d %H:%M:%S") } | #{ self.global_type.ljust(20) } | #{ self.category.ljust(20) }  => #{ self.message }"
+    end
+
+    def to_hash
+      { 'time' => self.time, 'global_type' => self.global_type, 'category' => self.category, 'message' => self.message, 'options' => self.options }
+    end
+
+    def output
+      self.message
+    end
+
+  end
+end
+
+
+=begin
+
+  module Logger
+
+
+    # This function must be as robust as possible, so we can not allow any exception here
+    def log(global_type = "trace", category = "undefined",  message = "Empty", options = {})
+
+      # log goes always to gat::log
+
+      #gatget_object = self.class.name == 'Gat::Base' ? self : self.gatget
+      gatget_object = self
+
+      log_entry = Hash.new
+      log_entry['type']     = global_type
+      log_entry['category'] = category
+      log_entry['message']  = message
+      log_entry['position'] = @logger.size
+      gatget_object.logger << log_entry
+
+      # skip output on debug mode
+      if gatget_object.debug
+        log_to_debug(log_entry)
+      else
+
+        #gatget_stout_output = gatget_object.config['gatget_operations'][gatget_object.operation]['output'] || 'enabled'
+        #if gatget_stout_output == 'enabled'
+        #  log_entry_level  = get_debug_levels[log_entry['type']] || 5
+        #  if self.verbose >= log_entry_level
+        #    $stdout.puts format_output(log_entry)
+        #  end
+        #end
+      end
+    end
+
+    def format_output(log_entry, format = nil)
+      gatget_format_output = format || self.config['gatget_operations'][self.operation]['output_format'] || 'template'
+
+      if gatget_format_output == 'template'
+
+        template_file = self.templates["stdout"] || GAT_ROOT + '/templates/stdout.template'
+        template = File.new(template_file, "r")
+        template_content = ""
+        while (line = template.gets)
+          template_content << line
+        end
+        template.close
+        ret = eval(template_content)
+      else
+        ret = " #{ log_entry['position'].to_s.ljust(3) } | #{ log_entry['type'].ljust(10).upcase } | #{ log_entry['category'].ljust(30).upcase } | #{ log_entry['message'] }\n"
+      end
+      ret
+    end
+
+
+    # debug purpuose method, just output all
+    def log_to_debug(log_entry)
+      print_debug_msg "#{ log_entry['position'] } ** #{ log_entry['category'] } » #{ log_entry['message'] } «"
+    end
+
+    def get_type_messages(type)
+      entries = []
+      @logger.map { |log_entry|
+        entries << log_entry if log_entry['type'] == type
+      }
+      entries
+    end
+
+
+
+    # construct a string with all the logger information
+    def build_whole_log(options = {})
+      whole_log = ''
+
+      if options['start_text']
+        whole_log << options['start_text']
+      end
+
+      if options['include_resume']
+        for entry_type in ['error', 'warning']
+          type_entries =  get_type_messages(entry_type)
+
+          if type_entries and type_entries.any?
+            whole_log << "\n"
+            whole_log << "#{ entry_type }s at gatget (#{ type_entries.size })\n"
+            whole_log << "#{ '-' * entry_type.size }-------------#{ '-' * type_entries.size.to_s.size }-\n"
+            whole_log << "\n"
+
+            type_entries.each do |type_entry|
+              whole_log << format_output(type_entry, 'plain')
+            end
+          else
+            whole_log << "0 #{ entry_type }s at gatget"
+          end
+        end
+      end
+
+      # include all log
+      whole_log << "\n"
+      whole_log << "whole log\n"
+      whole_log << "---------\n"
+      self.logger.each do |log_entry|
+        whole_log << format_output(log_entry, 'plain')
+        whole_log << "\n"
+      end
+
+      whole_log
+    end
+  end
+end
+=end

data/lib/gat/operation.rb

@@ -0,0 +1,253 @@
+=begin
+
+  :file   => operation.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::Operation
+  #
+  # Operations are the pieces of a gatget. Operations means the whole procement when we want to make something
+  # Operations have the next config options at YML definition
+  #
+  # <operation_name> *must be uniq*
+  #   description: <description text>
+  #     Description of operation... It will be showed at gatget help
+  #   users: [ <allowed users to run gat> ]
+  #     Users that are allowed to run GatGet. If empty or missing, no restrictions are applied
+  #   programs: [ <array of programs_names> ]
+  #     Array of programs that are defined in YML config that operation will need
+  #   arguments:[ <array of arguments_names> ]
+  #     Array of arguments that are defined in YML config that operation will need
+  #   folders:[ <array of folders_names> ]
+  #     Array of folders that are defined in YML config that operation will need
+  #   helpers:[ <array of helpers_names> ]
+  #	Ruby methods that will be launched before actions starts
+  #   actions:
+  #    Array of actions that operation will launch
+  #   outpus:
+  #    Array of outputs that operation will print or make
+  #   onfail:
+  #     Ruby method that is launched if Operation fail_do_backup
+  #
+
+
+  class Operation
+
+    attr_reader :gatget
+
+    attr_reader :config
+    attr_reader :name
+    attr_reader :description
+
+    attr_reader :programs
+    attr_reader :arguments
+    attr_reader :folders
+
+    attr_reader :helpers
+
+    attr_reader :outputs
+    attr_reader :users
+
+    attr_accessor :actions
+    attr_accessor :status
+
+    def initialize(operation_name, operation_config, gatget)
+      @name         = operation_name
+      @gatget       = gatget
+      @description  = operation_config['description'] || "#{ operation_name } at GatGet #{ self.class }"
+      @config       = operation_config
+      @helpers      = operation_config['helpers'] || []
+
+      @status       = 'ok'
+
+      if operation_config['users'] and not valid_user(operation_config['users'])
+        raise GatgetException.new('Current user is not allowed to run gatget operation', 'valid_user')
+      end
+
+      for dependence in [ 'programs', 'arguments', 'folders' ]
+        self.instance_variable_set("@#{ dependence }", evalue_dependences(dependence))
+      end
+    end
+
+
+    def evalue_dependences(dependence_type)
+      # get named dependences
+      dependences             = self.config[dependence_type] || []
+      evalued_dependences     = Array.new
+      dependences.each do |dependence|
+        config              =  self.gatget.get_element_config(dependence_type, dependence)
+        dependence_object   =  Object.module_eval("Gat::Dependence::#{ dependence_type.gsub(/s$/,'').capitalize }").new(dependence, config, self)
+        dependence_object.evalue
+        evalued_dependences << dependence_object
+      end
+
+      evalued_dependences
+    end
+
+    # Execute operation.
+    # After set all dependences, operation is ready to run. Just do it
+    # By steps, operation will run:
+    #
+    # 1) Helpers
+    # 2) Actions
+    # 3) Outputs
+    #
+    # Each step, operation will check that state is ok, if not ok, operation is stopped
+    def execute
+      run_helpers     if continue_operation('helpers')
+      ret = run_actions     if continue_operation('actions')
+
+      self.gatget.logger.log("message", "operation", "Operation #{ self.name } Ended!")
+
+      run_outputs
+      ret
+    end
+
+
+    def get_action(action_name)
+      actions = self.actions.select { |a| a.name == action_name }
+      actions.first || raise(GatgetException.new("Action #{ action_name } not found at operation #{ self.name }", "get_actions"))
+    end
+
+    private
+    # Run Helpers
+    #
+    # Helpers are:
+    #
+    # - Ruby methods that are wrotten at controller gatget file and provides specific features to the gatget
+    # - Helpers can not stop or modify gatget operation status, only actions can do it
+    #
+    def run_helpers
+      self.helpers.each do |helper|
+        self.gatget.logger.log("trace", "helper", "Running helper #{ self.class } @#{ helper }")
+
+        self.gatget.send(helper)
+      end
+    end
+
+
+    def run_actions
+      action_result = nil
+      actions              = self.config['actions'] || []
+
+      if actions.empty?
+        raise GatgetConfigException.new("Actions are empty for operation #{ self.name }", "run_actions")
+      end
+
+      self.actions = Array.new
+      actions.each do |action|
+        action_config     =  self.gatget.get_element_config('actions', action) || []
+
+        if not action_config['type'] or action_config['type'].empty?
+          raise GatgetConfigException.new("Action type missing or empty for operation #{ self.name }", "run_actions")
+        end
+
+        action_object   = Object.module_eval("Gat::Action::#{ action_config['type'].camelize }").new(action, action_config, self)
+
+        action_result   = action_object.execute
+        self.actions    << action_object
+      end
+      action_result
+    end
+
+    def run_outputs
+      outputs           = self.config['outputs'] || []
+
+      outputs.each do |output|
+        self.gatget.logger.output(output)
+      end
+    end
+
+
+    def valid_user(users)
+      users.empty? or users.include?(%x[ whoami ].strip)
+    end
+
+    def continue_operation(continue_with)
+      ret = true
+      if self.status == 'failed'
+        self.gatget.logger.log("message", "operation", "Operation #{ self.name } will not run #{ continue_with }. Status is #{ self.status }")
+        ret = false
+      end
+      ret
+    end
+
+
+  end
+
+end
+
+
+
+# gatget_name:              Your underscore gatgetname
+
+# gatget_description:       Your Gatget Description
+
+# gatget_config_variables:  Variable configurations to be used accross the gatget
+
+# gatget_arguments:         Gatget needed Arguments, by stdin or pipe
+
+# gatget_programs:          Array of programs gatget will use
+
+# gaget_outputs             Outputs an operations will launch
+
+# gatget_conditions         Conditions to be checked
+  # < condition_name >
+    # description           Condition description
+    # type                  Condition check Type
+    # onfail                What happens when condition fail
+    # onfail_message        Optional Message for onfail
+
+# gatget_actions
+
+
+# gatget_operations         Operations gatget will suport
+  # < operation_name >
+    # description           Operation description
+    # arguments             Array of arguments
+    # stdout:               Array of stdouts
+    # instructions          Array of instructions to execute
+    # onfail                On fail Method
+
+
+=begin
+
+  Gatget instance methods
+  # log                     Array of logs entries           RW
+
+  # config                  Gatget Structure config         R
+  # times                   Gatget Process Times            RW
+
+  # operation               Gatget runned operations        R
+
+  # dependences:            All that is needed by the program to run.extrated from config
+    # programs:             Array with all the programs... take by config['gatget_config']['programs ']
+    # folders               Array of Hasesh with config['gatget_config'][¡folder_name'] => { 'path' => '<path>', 'tree' => [ <tree folder array> ] }
+    # static                Hash of static variables to the script
+    # arguments             Command Line Arguments by get || pipe
+    #
+
+=end
+
+
+
+