oxidized 0.20.0 → 0.28.0

data/lib/oxidized/node.rb

@@ -6,26 +6,28 @@ module Oxidized
   class ModelNotFound  < OxidizedError; end
   class Node
     attr_reader :name, :ip, :model, :input, :output, :group, :auth, :prompt, :vars, :last, :repo
-    attr_accessor :running, :user, :msg, :from, :stats, :retry
-    alias :running? :running
-    def initialize opt
+    attr_accessor :running, :user, :email, :msg, :from, :stats, :retry
+    alias running? running
+
+    def initialize(opt)
       Oxidized.logger.debug 'resolving DNS for %s...' % opt[:name]
       # remove the prefix if an IP Address is provided with one as IPAddr converts it to a network address.
-      ip_addr, _ = opt[:ip].to_s.split("/")
+      ip_addr, = opt[:ip].to_s.split("/")
       Oxidized.logger.debug 'IPADDR %s' % ip_addr.to_s
-      @name           = opt[:name]
-      @ip             = IPAddr.new(ip_addr).to_s rescue nil
-      @ip           ||= Resolv.new.getaddress @name
-      @group          = opt[:group]
-      @input          = resolve_input opt
-      @output         = resolve_output opt
-      @model          = resolve_model opt
-      @auth           = resolve_auth opt
-      @prompt         = resolve_prompt opt
-      @vars           = opt[:vars]
-      @stats          = Stats.new
-      @retry          = 0
-      @repo           = resolve_repo opt
+      @name = opt[:name]
+      @ip = IPAddr.new(ip_addr).to_s rescue nil
+      @ip ||= Resolv.new.getaddress(@name) if Oxidized.config.resolve_dns?
+      @ip ||= @name
+      @group = opt[:group]
+      @model = resolve_model opt
+      @input = resolve_input opt
+      @output = resolve_output opt
+      @auth = resolve_auth opt
+      @prompt = resolve_prompt opt
+      @vars = opt[:vars]
+      @stats = Stats.new
+      @retry = 0
+      @repo = resolve_repo opt
 
       # model instance needs to access node instance
       @model.node = self
@@ -36,9 +38,10 @@ module Oxidized
       @input.each do |input|
         # don't try input if model is missing config block, we may need strong config to class_name map
         cfg_name = input.to_s.split('::').last.downcase
-        next unless @model.cfg[cfg_name] and not @model.cfg[cfg_name].empty?
+        next unless @model.cfg[cfg_name] && (not @model.cfg[cfg_name].empty?)
+
         @model.input = input = input.new
-        if config=run_input(input)
+        if (config = run_input(input))
           Oxidized.logger.debug "lib/oxidized/node.rb: #{input.class.name} ran for #{name} successfully"
           status = :success
           break
@@ -51,62 +54,66 @@ module Oxidized
       [status, config]
     end
 
-    def run_input input
+    def run_input(input)
       rescue_fail = {}
       [input.class::RescueFail, input.class.superclass::RescueFail].each do |hash|
-        hash.each do |level,errors|
+        hash.each do |level, errors|
           errors.each do |err|
             rescue_fail[err] = level
           end
         end
       end
       begin
-        input.connect(self) and input.get
+        input.connect(self) && input.get
       rescue *rescue_fail.keys => err
-        resc  = ''
-        if not level = rescue_fail[err.class]
-          resc  = err.class.ancestors.find{|e|rescue_fail.keys.include? e}
+        resc = ''
+        unless (level = rescue_fail[err.class])
+          resc  = err.class.ancestors.find { |e| rescue_fail.has_key?(e) }
           level = rescue_fail[resc]
           resc  = " (rescued #{resc})"
         end
-        Oxidized.logger.send(level, '%s raised %s%s with msg "%s"' % [self.ip, err.class, resc, err.message])
-        return false
-      rescue => err
-        file = Oxidized::Config::Crash + '.' + self.ip.to_s
-        open file, 'w' do |fh|
+        Oxidized.logger.send(level, '%s raised %s%s with msg "%s"' % [ip, err.class, resc, err.message])
+        false
+      rescue StandardError => err
+        crashdir  = Oxidized.config.crash.directory
+        crashfile = Oxidized.config.crash.hostnames? ? name : ip.to_s
+        FileUtils.mkdir_p(crashdir) unless File.directory?(crashdir)
+
+        File.open File.join(crashdir, crashfile), 'w' do |fh|
           fh.puts Time.now.utc
           fh.puts err.message + ' [' + err.class.to_s + ']'
           fh.puts '-' * 50
           fh.puts err.backtrace
         end
-        Oxidized.logger.error '%s raised %s with msg "%s", %s saved' % [self.ip, err.class, err.message, file]
-        return false
+        Oxidized.logger.error '%s raised %s with msg "%s", %s saved' % [ip, err.class, err.message, crashfile]
+        false
       end
     end
 
     def serialize
       h = {
-        :name      => @name,
-        :full_name => @name,
-        :ip        => @ip,
-        :group     => @group,
-        :model     => @model.class.to_s,
-        :last      => nil,
-        :vars      => @vars,
+        name:      @name,
+        full_name: @name,
+        ip:        @ip,
+        group:     @group,
+        model:     @model.class.to_s,
+        last:      nil,
+        vars:      @vars,
+        mtime:     @stats.mtime
       }
       h[:full_name] = [@group, @name].join('/') if @group
       if @last
         h[:last] = {
-          :start  => @last.start,
-          :end    => @last.end,
-          :status => @last.status,
-          :time   => @last.time,
+          start:  @last.start,
+          end:    @last.end,
+          status: @last.status,
+          time:   @last.time
         }
       end
       h
     end
 
-    def last= job
+    def last=(job)
       if job
         ostruct = OpenStruct.new
         ostruct.start  = job.start
@@ -120,95 +127,81 @@ module Oxidized
     end
 
     def reset
-      @user = @msg = @from = nil
+      @user = @email = @msg = @from = nil
       @retry = 0
     end
 
+    def modified
+      @stats.update_mtime
+    end
+
     private
 
-    def resolve_prompt opt
+    def resolve_prompt(opt)
       opt[:prompt] || @model.prompt || Oxidized.config.prompt
     end
 
-    def resolve_auth opt
+    def resolve_auth(opt)
       # Resolve configured username/password
       {
-        username:       resolve_key(:username, opt),
-        password:       resolve_key(:password, opt),
+        username: resolve_key(:username, opt),
+        password: resolve_key(:password, opt)
       }
     end
 
-    def resolve_input opt
+    def resolve_input(opt)
       inputs = resolve_key :input, opt, Oxidized.config.input.default
       inputs.split(/\s*,\s*/).map do |input|
-        if not Oxidized.mgr.input[input]
-          Oxidized.mgr.add_input input or raise MethodNotFound, "#{input} not found for node #{ip}"
-        end
+        Oxidized.mgr.add_input(input) || raise(MethodNotFound, "#{input} not found for node #{ip}") unless Oxidized.mgr.input[input]
         Oxidized.mgr.input[input]
       end
     end
 
-    def resolve_output opt
+    def resolve_output(opt)
       output = resolve_key :output, opt, Oxidized.config.output.default
-      if not Oxidized.mgr.output[output]
-        Oxidized.mgr.add_output output or raise MethodNotFound, "#{output} not found for node #{ip}"
-      end
+      Oxidized.mgr.add_output(output) || raise(MethodNotFound, "#{output} not found for node #{ip}") unless Oxidized.mgr.output[output]
       Oxidized.mgr.output[output]
     end
 
-    def resolve_model opt
+    def resolve_model(opt)
       model = resolve_key :model, opt
-      if not Oxidized.mgr.model[model]
+      unless Oxidized.mgr.model[model]
         Oxidized.logger.debug "lib/oxidized/node.rb: Loading model #{model.inspect}"
-        Oxidized.mgr.add_model model or raise ModelNotFound, "#{model} not found for node #{ip}"
+        Oxidized.mgr.add_model(model) || raise(ModelNotFound, "#{model} not found for node #{ip}")
       end
       Oxidized.mgr.model[model].new
     end
 
-    def resolve_repo opt
-      if is_git? opt
-        remote_repo = Oxidized.config.output.git.repo
+    def resolve_repo(opt)
+      type = git_type opt
+      return nil unless type
 
-        if remote_repo.is_a?(::String)
-          if Oxidized.config.output.git.single_repo? || @group.nil?
-            remote_repo
-          else
-            File.join(File.dirname(remote_repo), @group + '.git')
-          end
-        else
-          remote_repo[@group]
-        end
-      elsif is_gitcrypt? opt
-        remote_repo = Oxidized.config.output.gitcrypt.repo
-
-        if remote_repo.is_a?(::String)
-          if Oxidized.config.output.gitcrypt.single_repo? || @group.nil?
-            remote_repo
-          else
-            File.join(File.dirname(remote_repo), @group + '.git')
-          end
+      remote_repo = Oxidized.config.output.send(type).repo
+      if remote_repo.is_a?(::String)
+        if Oxidized.config.output.send(type).single_repo? || @group.nil?
+          remote_repo
         else
-          remote_repo[@group]
+          File.join(File.dirname(remote_repo), @group + '.git')
         end
       else
-        return
+        remote_repo[@group]
       end
     end
 
-    def resolve_key key, opt, global=nil
+    def resolve_key(key, opt, global = nil)
       # resolve key, first get global, then get group then get node config
       key_sym = key.to_sym
       key_str = key.to_s
       value   = global
       Oxidized.logger.debug "node.rb: resolving node key '#{key}', with passed global value of '#{value}' and node value '#{opt[key_sym]}'"
 
-      #global
-      if not value and Oxidized.config.has_key?(key_str)
+      # global
+      if (not value) && Oxidized.config.has_key?(key_str)
         value = Oxidized.config[key_str]
         Oxidized.logger.debug "node.rb: setting node key '#{key}' to value '#{value}' from global"
       end
 
-      #group
+      # group
       if Oxidized.config.groups.has_key?(@group)
         if Oxidized.config.groups[@group].has_key?(key_str)
           value = Oxidized.config.groups[@group][key_str]
@@ -216,7 +209,7 @@ module Oxidized
         end
       end
 
-      #model
+      # model
       if Oxidized.config.models.has_key?(@model.class.name.to_s.downcase)
         if Oxidized.config.models[@model.class.name.to_s.downcase].has_key?(key_str)
           value = Oxidized.config.models[@model.class.name.to_s.downcase][key_str]
@@ -224,19 +217,17 @@ module Oxidized
         end
       end
 
-      #node
+      # node
       value = opt[key_sym] || value
       Oxidized.logger.debug "node.rb: returning node key '#{key}' with value '#{value}'"
       value
     end
 
-    def is_git? opt
-      (opt[:output] || Oxidized.config.output.default) == 'git'
-    end
+    def git_type(opt)
+      type = opt[:output] || Oxidized.config.output.default
+      return nil unless type[0..2] == "git"
 
-    def is_gitcrypt? opt
-      (opt[:output] || Oxidized.config.output.default) == 'gitcrypt'
+      type
     end
-
   end
 end

data/lib/oxidized/nodes.rb

@@ -5,79 +5,82 @@ module Oxidized
   class Oxidized::NodeNotFound < OxidizedError; end
   class Nodes < Array
     attr_accessor :source, :jobs
-    alias :put :unshift
-    def load node_want=nil
+    alias put unshift
+    def load(node_want = nil)
       with_lock do
         new = []
         @source = Oxidized.config.source.default
-        Oxidized.mgr.add_source @source
+        Oxidized.mgr.add_source(@source) || raise(MethodNotFound, "cannot load node source '#{@source}', not found")
         Oxidized.logger.info "lib/oxidized/nodes.rb: Loading nodes"
-        Oxidized.mgr.source[@source].new.load.each do |node|
+        nodes = Oxidized.mgr.source[@source].new.load node_want
+        nodes.each do |node|
           # we want to load specific node(s), not all of them
           next unless node_want? node_want, node
+
           begin
-            _node = Node.new node
-            new.push _node
+            node_obj = Node.new node
+            new.push node_obj
           rescue ModelNotFound => err
             Oxidized.logger.error "node %s raised %s with message '%s'" % [node, err.class, err.message]
           rescue Resolv::ResolvError => err
             Oxidized.logger.error "node %s is not resolvable, raised %s with message '%s'" % [node, err.class, err.message]
           end
         end
-        size == 0 ? replace(new) : update_nodes(new)
+        size.zero? ? replace(new) : update_nodes(new)
         Oxidized.logger.info "lib/oxidized/nodes.rb: Loaded #{size} nodes"
       end
     end
 
-    def node_want? node_want, node
+    def node_want?(node_want, node)
       return true unless node_want
+
       node_want_ip = (IPAddr.new(node_want) rescue false)
       name_is_ip   = (IPAddr.new(node[:name]) rescue false)
-      if name_is_ip and node_want_ip == node[:name]
+      if name_is_ip && (node_want_ip == node[:name])
         true
-      elsif node[:ip] and node_want_ip == node[:ip]
+      elsif node[:ip] && (node_want_ip == node[:ip])
         true
       elsif node_want.match node[:name]
         true unless name_is_ip
       end
     end
 
-
     def list
       with_lock do
         map { |e| e.serialize }
       end
     end
 
-    def show node
+    def show(node)
       with_lock do
         i = find_node_index node
         self[i].serialize
       end
     end
 
-    def fetch node_name, group
+    def fetch(node_name, group)
       yield_node_output(node_name) do |node, output|
         output.fetch node, group
       end
     end
 
     # @param node [String] name of the node moved into the head of array
-    def next node, opt={}
-      if waiting.find_node_index(node)
-        with_lock do
-          n = del node
-          n.user = opt['user']
-          n.msg  = opt['msg']
-          n.from = opt['from']
-          # set last job to nil so that the node is picked for immediate update
-          n.last = nil
-          put n
-          jobs.want += 1 if Oxidized.config.next_adds_job?
-        end
+    def next(node, opt = {})
+      return unless waiting.find_node_index(node)
+
+      with_lock do
+        n = del node
+        n.user = opt['user']
+        n.email = opt['email']
+        n.msg  = opt['msg']
+        n.from = opt['from']
+        # set last job to nil so that the node is picked for immediate update
+        n.last = nil
+        put n
+        jobs.want += 1 if Oxidized.config.next_adds_job?
       end
     end
-    alias :top :next
+    alias top next
 
     # @return [String] node from the head of the array
     def get
@@ -88,23 +91,23 @@ module Oxidized
 
     # @param node node whose index number in Nodes to find
     # @return [Fixnum] index number of node in Nodes
-    def find_node_index node
-      find_index node or raise Oxidized::NodeNotFound, "unable to find '#{node}'"
+    def find_node_index(node)
+      find_index(node) || raise(Oxidized::NodeNotFound, "unable to find '#{node}'")
     end
 
-    def version node_name, group
+    def version(node_name, group)
       yield_node_output(node_name) do |node, output|
         output.version node, group
       end
     end
 
-    def get_version node_name, group, oid
+    def get_version(node_name, group, oid)
       yield_node_output(node_name) do |node, output|
         output.get_version node, group, oid
       end
     end
 
-    def get_diff node_name, group, oid1, oid2
+    def get_diff(node_name, group, oid1, oid2)
       yield_node_output(node_name) do |node, output|
         output.get_diff node, group, oid1, oid2
       end
@@ -112,39 +115,39 @@ module Oxidized
 
     private
 
-    def initialize opts={}
+    def initialize(opts = {})
       super()
       node = opts.delete :node
-      @mutex= Mutex.new  # we compete for the nodes with webapi thread
-      if nodes = opts.delete(:nodes)
+      @mutex = Mutex.new # we compete for the nodes with webapi thread
+      if (nodes = opts.delete(:nodes))
         replace nodes
       else
         load node
       end
     end
 
-    def with_lock &block
+    def with_lock(&block)
       @mutex.synchronize(&block)
     end
 
-    def find_index node
-      index { |e| e.name == node or e.ip == node}
+    def find_index(node)
+      index { |e| [e.name, e.ip].include? node }
     end
 
     # @param node node which is removed from nodes list
     # @return [Node] deleted node
-    def del node
+    def del(node)
       delete_at find_node_index(node)
     end
 
     # @return [Nodes] list of nodes running now
     def running
-      Nodes.new :nodes => select { |node| node.running? }
+      Nodes.new nodes: select { |node| node.running? }
     end
 
     # @return [Nodes] list of nodes waiting (not running)
     def waiting
-      Nodes.new :nodes => select { |node| not node.running? }
+      Nodes.new nodes: select { |node| not node.running? }
     end
 
     # walks list of new nodes, if old node contains same name, adds last and
@@ -152,16 +155,16 @@ module Oxidized
     #
     # @todo can we trust name to be unique identifier, what about when groups are used?
     # @param [Array] nodes Array of nodes used to replace+update old
-    def update_nodes nodes
-      old = self.dup
+    def update_nodes(nodes)
+      old = dup
       replace(nodes)
       each do |node|
         begin
-          if i = old.find_node_index(node.name)
+          if (i = old.find_node_index(node.name))
             node.stats = old[i].stats
             node.last  = old[i].last
           end
-        rescue  Oxidized::NodeNotFound
+        rescue Oxidized::NodeNotFound
         end
       end
       sort_by! { |x| x.last.nil? ? Time.new(0) : x.last.end }
@@ -172,6 +175,7 @@ module Oxidized
         node = find { |n| n.name == node_name }
         output = node.output.new
         raise Oxidized::NotSupported unless output.respond_to? :fetch
+
         yield node, output
       end
     end

data/lib/oxidized/output/file.rb

@@ -1,59 +1,54 @@
 module Oxidized
-class OxidizedFile < Output
-  require 'fileutils'
+  class OxidizedFile < Output
+    require 'fileutils'
 
-  attr_reader :commitref
+    attr_reader :commitref
 
-  def initialize
-    @cfg = Oxidized.config.output.file
-  end
+    def initialize
+      @cfg = Oxidized.config.output.file
+    end
+
+    def setup
+      return unless @cfg.empty?
 
-  def setup
-    if @cfg.empty?
       Oxidized.asetus.user.output.file.directory = File.join(Config::Root, 'configs')
       Oxidized.asetus.save :user
       raise NoConfig, 'no output file config, edit ~/.config/oxidized/config'
     end
-  end
 
-  def store node, outputs, opt={}
-    file = File.expand_path @cfg.directory
-    if opt[:group]
-      file = File.join File.dirname(file), opt[:group]
+    def store(node, outputs, opt = {})
+      file = File.expand_path @cfg.directory
+      file = File.join File.dirname(file), opt[:group] if opt[:group]
+      FileUtils.mkdir_p file
+      file = File.join file, node
+      File.open(file, 'w') { |fh| fh.write outputs.to_cfg }
+      @commitref = file
     end
-    FileUtils.mkdir_p file
-    file = File.join file, node
-    open(file, 'w') { |fh| fh.write outputs.to_cfg }
-    @commitref = file
-  end
 
-  def fetch node, group
-    cfg_dir   = File.expand_path @cfg.directory
-    node_name = node.name
+    def fetch(node, group)
+      cfg_dir   = File.expand_path @cfg.directory
+      node_name = node.name
 
-    if group # group is explicitly defined by user
-      cfg_dir = File.join File.dirname(cfg_dir), group
-      File.read File.join(cfg_dir, node_name)
-    else
-      if File.exists? File.join(cfg_dir, node_name) # node configuration file is stored on base directory
+      if group # group is explicitly defined by user
+        cfg_dir = File.join File.dirname(cfg_dir), group
+        File.read File.join(cfg_dir, node_name)
+      elsif File.exist? File.join(cfg_dir, node_name) # node configuration file is stored on base directory
         File.read File.join(cfg_dir, node_name)
       else
         path = Dir.glob(File.join(File.dirname(cfg_dir), '**', node_name)).first # fetch node in all groups
         File.read path
       end
+    rescue Errno::ENOENT
+      nil
     end
-  rescue Errno::ENOENT
-    return nil
-  end
 
-  def version node, group
-    # not supported
-    []
-  end
+    def version(_node, _group)
+      # not supported
+      []
+    end
 
-  def get_version node, group, oid
-    'not supported'
+    def get_version(_node, _group, _oid)
+      'not supported'
+    end
   end
-
-end
 end