oxidized 0.25.1 → 0.26.0

data/lib/oxidized/node/stats.rb

@@ -6,11 +6,11 @@ module Oxidized
 
       # @param [Job] job job whose information add to stats
       # @return [void]
-      def add job
+      def add(job)
         stat = {
-          :start  => job.start,
-          :end    => job.end,
-          :time   => job.time,
+          start: job.start,
+          end:   job.end,
+          time:  job.time
         }
         @stats[job.status] ||= []
         @stats[job.status].shift if @stats[job.status].size > @history_size
@@ -20,11 +20,11 @@ module Oxidized
 
       # @param [Symbol] status stats for specific status
       # @return [Hash,Array] Hash of stats for every status or Array of stats for specific status
-      def get status = nil
+      def get(status = nil)
         status ? @stats[status] : @stats
       end
 
-      def get_counter counter = nil
+      def get_counter(counter = nil)
         counter ? @stats[:counter][counter] : @stats[:counter]
       end
 

data/lib/oxidized/nodes.rb

@@ -5,12 +5,12 @@ 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) or raise(MethodNotFound, "cannot load node source '#{@source}', not found")
+        Oxidized.mgr.add_source(@source) || raise(MethodNotFound, "cannot load node source '#{@source}', not found")
         Oxidized.logger.info "lib/oxidized/nodes.rb: Loading nodes"
         nodes = Oxidized.mgr.source[@source].new.load node_want
         nodes.each do |node|
@@ -18,27 +18,27 @@ module Oxidized
           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
@@ -51,36 +51,36 @@ module Oxidized
       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.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
+    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
@@ -91,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
@@ -115,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)
+      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
@@ -155,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 # rubocop:disable Lint/HandleExceptions
         end
       end
       sort_by! { |x| x.last.nil? ? Time.new(0) : x.last.end }

data/lib/oxidized/output/file.rb

@@ -9,49 +9,45 @@ module Oxidized
     end
 
     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
+      return unless @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
 
-    def store node, outputs, opt = {}
+    def store(node, outputs, opt = {})
       file = File.expand_path @cfg.directory
-      if opt[:group]
-        file = File.join File.dirname(file), opt[:group]
-      end
+      file = File.join File.dirname(file), opt[:group] if opt[:group]
       FileUtils.mkdir_p file
       file = File.join file, node
-      open(file, 'w') { |fh| fh.write outputs.to_cfg }
+      File.open(file, 'w') { |fh| fh.write outputs.to_cfg }
       @commitref = file
     end
 
-    def fetch node, group
+    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)
+      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
-        if File.exists? 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
+        path = Dir.glob(File.join(File.dirname(cfg_dir), '**', node_name)).first # fetch node in all groups
+        File.read path
       end
     rescue Errno::ENOENT
-      return nil
+      nil
     end
 
-    def version node, group
+    def version(_node, _group)
       # not supported
       []
     end
 
-    def get_version node, group, oid
+    def get_version(_node, _group, _oid)
       'not supported'
     end
   end

data/lib/oxidized/output/git.rb

@@ -31,10 +31,10 @@ module Oxidized
       end
     end
 
-    def store file, outputs, opt = {}
+    def store(file, outputs, opt = {})
       @msg   = opt[:msg]
-      @user  = (opt[:user]  or @cfg.user)
-      @email = (opt[:email] or @cfg.email)
+      @user  = (opt[:user]  || @cfg.user)
+      @email = (opt[:email] || @cfg.email)
       @opt   = opt
       @commitref = nil
       repo = @cfg.repo
@@ -43,7 +43,7 @@ module Oxidized
         type_cfg = ''
         type_repo = File.join(File.dirname(repo), type + '.git')
         outputs.type(type).each do |output|
-          (type_cfg << output; next) if not output.name
+          (type_cfg << output; next) unless output.name # rubocop:disable Style/Semicolon
           type_file = file + '--' + output.name
           if @cfg.type_as_directory?
             type_file = type + '/' + type_file
@@ -57,85 +57,77 @@ module Oxidized
       update repo, file, outputs.to_cfg
     end
 
-    def fetch node, group
-      begin
-        repo, path = yield_repo_and_path(node, group)
-        repo = Rugged::Repository.new repo
-        index = repo.index
-        index.read_tree repo.head.target.tree unless repo.empty?
-        repo.read(index.get(path)[:oid]).data
-      rescue
-        'node not found'
-      end
+    def fetch(node, group)
+      repo, path = yield_repo_and_path(node, group)
+      repo = Rugged::Repository.new repo
+      index = repo.index
+      index.read_tree repo.head.target.tree unless repo.empty?
+      repo.read(index.get(path)[:oid]).data
+    rescue StandardError
+      'node not found'
     end
 
     # give a hash of all oid revision for the given node, and the date of the commit
-    def version node, group
-      begin
-        repo, path = yield_repo_and_path(node, group)
-
-        repo = Rugged::Repository.new repo
-        walker = Rugged::Walker.new(repo)
-        walker.sorting(Rugged::SORT_DATE)
-        walker.push(repo.head.target)
-        i = -1
-        tab = []
-        walker.each do |commit|
-          if commit.diff(paths: [path]).size > 0
-            hash = {}
-            hash[:date] = commit.time.to_s
-            hash[:oid] = commit.oid
-            hash[:author] = commit.author
-            hash[:message] = commit.message
-            tab[i += 1] = hash
-          end
-        end
-        walker.reset
-        tab
-      rescue
-        'node not found'
+    def version(node, group)
+      repo, path = yield_repo_and_path(node, group)
+
+      repo = Rugged::Repository.new repo
+      walker = Rugged::Walker.new(repo)
+      walker.sorting(Rugged::SORT_DATE)
+      walker.push(repo.head.target)
+      i = -1
+      tab = []
+      walker.each do |commit|
+        next if commit.diff(paths: [path]).empty?
+
+        hash = {}
+        hash[:date] = commit.time.to_s
+        hash[:oid] = commit.oid
+        hash[:author] = commit.author
+        hash[:message] = commit.message
+        tab[i += 1] = hash
       end
+      walker.reset
+      tab
+    rescue StandardError
+      'node not found'
     end
 
     # give the blob of a specific revision
-    def get_version node, group, oid
-      begin
-        repo, path = yield_repo_and_path(node, group)
-        repo = Rugged::Repository.new repo
-        repo.blob_at(oid, path).content
-      rescue
-        'version not found'
-      end
+    def get_version(node, group, oid)
+      repo, path = yield_repo_and_path(node, group)
+      repo = Rugged::Repository.new repo
+      repo.blob_at(oid, path).content
+    rescue StandardError
+      'version not found'
     end
 
     # give a hash with the patch of a diff between 2 revision and the stats (added and deleted lines)
-    def get_diff node, group, oid1, oid2
-      begin
-        diff_commits = nil
-        repo, _ = yield_repo_and_path(node, group)
-        repo = Rugged::Repository.new repo
-        commit = repo.lookup(oid1)
-
-        if oid2
-          commit_old = repo.lookup(oid2)
-          diff = repo.diff(commit_old, commit)
-          diff.each do |patch|
-            if /#{node.name}\s+/.match(patch.to_s.lines.first)
-              diff_commits = { :patch => patch.to_s, :stat => patch.stat }
-              break
-            end
+    def get_diff(node, group, oid1, oid2)
+      diff_commits = nil
+      repo, = yield_repo_and_path(node, group)
+      repo = Rugged::Repository.new repo
+      commit = repo.lookup(oid1)
+
+      if oid2
+        commit_old = repo.lookup(oid2)
+        diff = repo.diff(commit_old, commit)
+        diff.each do |patch|
+          if /#{node.name}\s+/ =~ patch.to_s.lines.first
+            diff_commits = { patch: patch.to_s, stat: patch.stat }
+            break
           end
-        else
-          stat = commit.parents[0].diff(commit).stat
-          stat = [stat[1], stat[2]]
-          patch = commit.parents[0].diff(commit).patch
-          diff_commits = { :patch => patch, :stat => stat }
         end
-
-        diff_commits
-      rescue
-        'no diffs'
+      else
+        stat = commit.parents[0].diff(commit).stat
+        stat = [stat[1], stat[2]]
+        patch = commit.parents[0].diff(commit).patch
+        diff_commits = { patch: patch, stat: stat }
       end
+
+      diff_commits
+    rescue StandardError
+      'no diffs'
     end
 
     private
@@ -143,14 +135,12 @@ module Oxidized
     def yield_repo_and_path(node, group)
       repo, path = node.repo, node.name
 
-      if group and @cfg.single_repo?
-        path = "#{group}/#{node.name}"
-      end
+      path = "#{group}/#{node.name}" if group && @cfg.single_repo?
 
       [repo, path]
     end
 
-    def update repo, file, data
+    def update(repo, file, data)
       return if data.empty?
 
       if @opt[:group]
@@ -171,20 +161,20 @@ module Oxidized
       rescue Rugged::OSError, Rugged::RepositoryError => open_error
         begin
           Rugged::Repository.init_at repo, :bare
-        rescue => create_error
+        rescue StandardError => create_error
           raise GitError, "first '#{open_error.message}' was raised while opening git repo, then '#{create_error.message}' was while trying to create git repo"
         end
         retry
       end
     end
 
-    def update_repo repo, file, data
+    def update_repo(repo, file, data)
       oid_old = repo.blob_at(repo.head.target_id, file) rescue nil
-      return false if oid_old and oid_old.content == data
+      return false if oid_old && (oid_old.content.b == data.b)
 
       oid = repo.write data, :blob
       index = repo.index
-      index.add path: file, oid: oid, mode: 0100644
+      index.add path: file, oid: oid, mode: 0o100644
 
       repo.config['user.name']  = @user
       repo.config['user.email'] = @email