oxidized 0.32.1 → 0.34.0

data/lib/oxidized/node.rb

@@ -6,15 +6,18 @@ module Oxidized
   class ModelNotFound  < OxidizedError; end
 
   class Node
+    include SemanticLogger::Loggable
+
     attr_reader :name, :ip, :model, :input, :output, :group, :auth, :prompt, :vars, :last, :repo
     attr_accessor :running, :user, :email, :msg, :from, :stats, :retry, :err_type, :err_reason
     alias running? running
 
+    # opt is a hash with the node parameters given in the source (:name, :group, :ip...)
     def initialize(opt)
-      Oxidized.logger.debug 'resolving DNS for %s...' % opt[:name]
+      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("/")
-      Oxidized.logger.debug 'IPADDR %s' % ip_addr.to_s
+      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) if Oxidized.config.resolve_dns?
@@ -37,7 +40,8 @@ module Oxidized
     end
 
     def run
-      status, config = :fail, nil
+      status = :fail
+      config = nil
       @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
@@ -45,14 +49,16 @@ module Oxidized
 
         @model.input = input = input.new
         if (config = run_input(input))
-          Oxidized.logger.debug "lib/oxidized/node.rb: #{input.class.name} ran for #{name} successfully"
+          logger.debug "#{input.class.name} ran for #{name} successfully"
           status = :success
           break
         else
-          Oxidized.logger.debug "lib/oxidized/node.rb: #{input.class.name} failed for #{name}"
+          logger.debug "#{input.class.name} failed for #{name}"
           status = :no_connection
         end
       end
+      logger.error "No suitable input found for #{name}" unless @model.input
+
       @model.input = nil
       [status, config]
     end
@@ -75,13 +81,18 @@ module Oxidized
           level = rescue_fail[resc]
           resc  = " (rescued #{resc})"
         end
-        Oxidized.logger.send(level, '%s raised %s%s with msg "%s"' % [ip, err.class, resc, err.message])
+        logger.send(level, '%s raised %s%s with msg "%s"' % [ip, err.class, resc, err.message])
         @err_type = err.class.to_s
         @err_reason = err.message.to_s
         false
       rescue StandardError => e
         # Send a message in debug mode in case we are not able to create a crashfile
-        Oxidized.logger.send(:debug, '%s raised %s with msg "%s", creating crashfile' % [ip, e.class, e.message])
+        logger.error "#{ip} raised #{e.class} with msg #{e.message}, creating crashfile"
+        unless Oxidized.config.crash.directory?
+          logger.error "Cannot create crashfile for exception", e
+          return false
+        end
+
         crashdir  = Oxidized.config.crash.directory
         crashfile = Oxidized.config.crash.hostnames? ? name : ip.to_s
         FileUtils.mkdir_p(crashdir) unless File.directory?(crashdir)
@@ -92,7 +103,7 @@ module Oxidized
           fh.puts '-' * 50
           fh.puts e.backtrace
         end
-        Oxidized.logger.error '%s raised %s with msg "%s", %s saved' % [ip, e.class, e.message, crashfile]
+        logger.error '%s raised %s with msg "%s", %s saved' % [ip, e.class, e.message, crashfile]
         @err_type = e.class.to_s
         @err_reason = e.message.to_s
         false
@@ -122,14 +133,10 @@ module Oxidized
       h
     end
 
+    JobStruct = Struct.new(:start, :end, :status, :time)
     def last=(job)
       if job
-        ostruct = OpenStruct.new
-        ostruct.start  = job.start
-        ostruct.end    = job.end
-        ostruct.status = job.status
-        ostruct.time   = job.time
-        @last = ostruct
+        @last = JobStruct.new(job.start, job.end, job.status, job.time)
       else
         @last = nil
       end
@@ -160,8 +167,11 @@ module Oxidized
 
     def resolve_input(opt)
       inputs = resolve_key :input, opt, Oxidized.config.input.default
-      inputs.split(/\s*,\s*/).map do |input|
-        Oxidized.mgr.add_input(input) || raise(MethodNotFound, "#{input} not found for node #{ip}") unless Oxidized.mgr.input[input]
+      inputs.split(',').map do |input|
+        input.strip!
+        unless Oxidized.mgr.input[input]
+          Oxidized.mgr.add_input(input) || raise(MethodNotFound, "#{input} not found for node #{ip}")
+        end
 
         Oxidized.mgr.input[input]
       end
@@ -169,7 +179,10 @@ module Oxidized
 
     def resolve_output(opt)
       output = resolve_key :output, opt, Oxidized.config.output.default
-      Oxidized.mgr.add_output(output) || raise(MethodNotFound, "#{output} not found for node #{ip}") unless Oxidized.mgr.output[output]
+      unless Oxidized.mgr.output[output]
+        Oxidized.mgr.add_output(output) || raise(MethodNotFound,
+                                                 "#{output} not found for node #{ip}")
+      end
 
       Oxidized.mgr.output[output]
     end
@@ -177,7 +190,7 @@ module Oxidized
     def resolve_model(opt)
       model = resolve_key :model, opt
       unless Oxidized.mgr.model[model]
-        Oxidized.logger.debug "lib/oxidized/node.rb: Loading model #{model.inspect}"
+        logger.debug "Loading model #{model.inspect}"
         Oxidized.mgr.add_model(model) || raise(ModelNotFound, "#{model} not found for node #{ip}")
       end
       Oxidized.mgr.model[model].new
@@ -200,42 +213,46 @@ module Oxidized
     end
 
     def resolve_key(key, opt, global = nil)
-      # resolve key: the priority is as follows: node -> group specific model -> group -> model -> global passed -> global
+      # resolve key: the priority is as follows:
+      # node -> group specific model -> group -> model -> global passed -> global
       # where node has the highest priority (= if defined, overwrites other values)
       key_sym = key.to_sym
       key_str = key.to_s
       model_name = @model.class.name.to_s.downcase
-      Oxidized.logger.debug "node.rb: resolving node key '#{key}', with passed global value of '#{global}' and node value '#{opt[key_sym]}'"
+      logger.debug "resolving node key '#{key}', with passed global value of '#{global}' " \
+                   "and node value '#{opt[key_sym]}'"
 
       # Node
       if opt[key_sym]
         value = opt[key_sym]
-        Oxidized.logger.debug "node.rb: setting node key '#{key}' to value '#{value}' from node"
+        logger.debug "setting node key '#{key}' to value '#{value}' from node"
 
       # Group specific model
-      elsif Oxidized.config.groups.has_key?(@group) && Oxidized.config.groups[@group].models.has_key?(model_name) && Oxidized.config.groups[@group].models[model_name].has_key?(key_str)
+      elsif Oxidized.config.groups.has_key?(@group) &&
+            Oxidized.config.groups[@group].models.has_key?(model_name) &&
+            Oxidized.config.groups[@group].models[model_name].has_key?(key_str)
         value = Oxidized.config.groups[@group].models[model_name][key_str]
-        Oxidized.logger.debug "node.rb: setting node key '#{key}' to value '#{value}' from model in group"
+        logger.debug "setting node key '#{key}' to value '#{value}' from model in group"
 
       # Group
       elsif Oxidized.config.groups.has_key?(@group) && Oxidized.config.groups[@group].has_key?(key_str)
         value = Oxidized.config.groups[@group][key_str]
-        Oxidized.logger.debug "node.rb: setting node key '#{key}' to value '#{value}' from group"
+        logger.debug "setting node key '#{key}' to value '#{value}' from group"
 
       # Model
       elsif Oxidized.config.models.has_key?(model_name) && Oxidized.config.models[model_name].has_key?(key_str)
         value = Oxidized.config.models[model_name][key_str]
-        Oxidized.logger.debug "node.rb: setting node key '#{key}' to value '#{value}' from model"
+        logger.debug "setting node key '#{key}' to value '#{value}' from model"
 
       # Global passed
       elsif global
         value = global
-        Oxidized.logger.debug "node.rb: setting node key '#{key}' to value '#{value}' from passed global value"
+        logger.debug "setting node key '#{key}' to value '#{value}' from passed global value"
 
       # Global
       elsif 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"
+        logger.debug "setting node key '#{key}' to value '#{value}' from global"
       end
       value
     end

data/lib/oxidized/nodes.rb

@@ -5,6 +5,8 @@ module Oxidized
   class NodeNotFound < OxidizedError; end
 
   class Nodes < Array
+    include SemanticLogger::Loggable
+
     attr_accessor :source, :jobs
     alias put unshift
     def load(node_want = nil)
@@ -12,7 +14,7 @@ module Oxidized
         new = []
         @source = Oxidized.config.source.default
         Oxidized.mgr.add_source(@source) || raise(MethodNotFound, "cannot load node source '#{@source}', not found")
-        Oxidized.logger.info "lib/oxidized/nodes.rb: Loading nodes"
+        logger.info "Loading nodes"
         nodes = Oxidized.mgr.source[@source].new.load node_want
         nodes.each do |node|
           # we want to load specific node(s), not all of them
@@ -22,13 +24,14 @@ module Oxidized
             node_obj = Node.new node
             new.push node_obj
           rescue ModelNotFound => e
-            Oxidized.logger.error "node %s raised %s with message '%s'" % [node, e.class, e.message]
+            logger.error "node %s raised %s with message '%s'" % [node, e.class, e.message]
           rescue Resolv::ResolvError => e
-            Oxidized.logger.error "node %s is not resolvable, raised %s with message '%s'" % [node, e.class, e.message]
+            logger.error "node %s is not resolvable, raised %s with message '%s'" % [node, e.class, e.message]
           end
         end
         size.zero? ? replace(new) : update_nodes(new)
-        Oxidized.logger.info "lib/oxidized/nodes.rb: Loaded #{size} nodes"
+        Output.clean_obsolete_nodes(self) if node_want.nil?
+        logger.info "Loaded #{size} nodes"
       end
     end
 
@@ -74,6 +77,7 @@ module Oxidized
     def next(node, opt = {})
       return if running.find_index(node)
 
+      logger.info "Add node #{node} to running jobs"
       with_lock do
         n = del node
         n.user = opt['user']

data/lib/oxidized/output/file.rb

@@ -19,6 +19,9 @@ module Oxidized
         raise NoConfig, "no output file config, edit #{Oxidized::Config.configfile}"
       end
 
+      # node: node name (String)
+      # outputs: Oxidized::Models::Outputs
+      # opts: hash of node vars
       def store(node, outputs, opt = {})
         file = ::File.expand_path @cfg.directory
         file = ::File.join ::File.dirname(file), opt[:group] if opt[:group]
@@ -53,6 +56,31 @@ module Oxidized
       def get_version(_node, _group, _oid)
         'not supported'
       end
+
+      def self.node_path(node_name, group_name = nil)
+        cfg_dir = ::File.expand_path Oxidized.config.output.file.directory
+
+        if group_name
+          ::File.join ::File.dirname(cfg_dir), group_name, node_name
+        else
+          ::File.join cfg_dir, node_name
+        end
+      end
+
+      def self.clean_obsolete_nodes(active_nodes)
+        cfg_dir = ::File.expand_path Oxidized.config.output.file.directory
+        dir_base = ::File.dirname(cfg_dir)
+        default_dir = ::File.basename(cfg_dir)
+
+        keep_files = active_nodes.map { |n| node_path(n.name, n.group) }
+        active_groups = active_nodes.map(&:group).compact.uniq
+
+        [default_dir, *active_groups].each do |group|
+          Dir.glob(::File.join(dir_base, group, "*")).each do |file|
+            ::File.delete(file) if ::File.file?(file) && !keep_files.include?(file)
+          end
+        end
+      end
     end
   end
 end

data/lib/oxidized/output/git.rb

@@ -21,17 +21,17 @@ module Oxidized
         if @cfg.empty?
           Oxidized.asetus.user.output.git.user  = 'Oxidized'
           Oxidized.asetus.user.output.git.email = 'o@example.com'
-          Oxidized.asetus.user.output.git.repo = File.join(Config::ROOT, 'oxidized.git')
+          Oxidized.asetus.user.output.git.repo = ::File.join(Config::ROOT, 'oxidized.git')
           Oxidized.asetus.save :user
           raise NoConfig, "no output git config, edit #{Oxidized::Config.configfile}"
         end
 
         if @cfg.repo.respond_to?(:each)
           @cfg.repo.each do |group, repo|
-            @cfg.repo["#{group}="] = File.expand_path repo
+            @cfg.repo["#{group}="] = ::File.expand_path repo
           end
         else
-          @cfg.repo = File.expand_path @cfg.repo
+          @cfg.repo = ::File.expand_path @cfg.repo
         end
       end
 
@@ -45,7 +45,7 @@ module Oxidized
 
         outputs.types.each do |type|
           type_cfg = ''
-          type_repo = File.join(File.dirname(repo), type + '.git')
+          type_repo = ::File.join(::File.dirname(repo), type + '.git')
           outputs.type(type).each do |output|
             (type_cfg << output; next) unless output.name # rubocop:disable Style/Semicolon
             type_file = file + '--' + output.name
@@ -64,8 +64,8 @@ module Oxidized
       # Returns the configuration of group/node_name
       #
       # #fetch is called by Nodes#fetch
-      # Nodes#fetch creates a new Output object each time, so we cannot
-      # store the repo index in memory. But as we keep the repo index up
+      # Nodes#fetch creates a new Output object each time, so it not easy
+      # to cache the repo index in memory. But as we keep the repo index up
       # to date on disk in #update_repo, we can read it from disk instead of
       # rebuilding it each time.
       def fetch(node, group)
@@ -79,29 +79,13 @@ module Oxidized
         'node not found'
       end
 
-      # give a hash of all oid revision for the given node, and the date of the commit
+      # give a hash of all oid revisions for the given node, and the date of
+      # the commit.
+      #
+      # Called by Nodes#version
       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.oid)
-        i = -1
-        tab = []
-        walker.each do |commit|
-          # Diabled rubocop because the suggested .empty? does not work here.
-          next if commit.diff(paths: [path]).size.zero? # rubocop:disable Style/ZeroLengthPredicate
-
-          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
+        repo_path, node_path = yield_repo_and_path(node, group)
+        self.class.hash_list(node_path, repo_path)
       rescue StandardError
         'node not found'
       end
@@ -143,10 +127,139 @@ module Oxidized
         'no diffs'
       end
 
+      # Return the list of oids for node_path in the repository repo_path
+      def self.hash_list(node_path, repo_path)
+        update_cache(repo_path)
+        @gitcache[repo_path][:nodes][node_path] || []
+      end
+
+      # Update @gitcache, a class instance variable, ensuring persistence
+      # by saving the cache independently of object instances
+      def self.update_cache(repo_path)
+        # initialize our cache as a class instance variable
+        @gitcache ||= {}
+        # When single_repo == false, we have multiple repositories
+        unless @gitcache[repo_path]
+          @gitcache[repo_path] = {}
+          @gitcache[repo_path][:nodes] = {}
+          @gitcache[repo_path][:last_commit] = nil
+        end
+
+        repo = Rugged::Repository.new repo_path
+
+        walker = Rugged::Walker.new(repo)
+        walker.sorting(Rugged::SORT_DATE)
+        walker.push(repo.head.target.oid)
+
+        # We store the commits into a temporary cache. It will be prepended
+        # to @gitcache to preserve the order of the commits.
+        cache = {}
+        walker.each do |commit|
+          if commit.oid == @gitcache[repo_path][:last_commit]
+            # we have reached the last cached commit, so we're done
+            break
+          end
+
+          commit.diff.each_delta do |delta|
+            next unless delta.added? || delta.modified?
+
+            hash = {}
+            # We keep :date for reverse compatibility on oxidized-web <= 0.15.1
+            hash[:date] = commit.time.to_s
+            # date as a Time instance for more flexibility in oxidized-web
+            hash[:time] = commit.time
+            hash[:oid] = commit.oid
+            hash[:author] = commit.author
+            hash[:message] = commit.message
+
+            filename = delta.new_file[:path]
+            if cache[filename]
+              cache[filename].append hash
+            else
+              cache[filename] = [hash]
+            end
+          end
+        end
+
+        cache.each_pair do |filename, hashlist|
+          if @gitcache[repo_path][:nodes][filename]
+            # using the splat operator (*) should be OK as hashlist should
+            # not be very big when working on deltas
+            @gitcache[repo_path][:nodes][filename].prepend(*hashlist)
+          else
+            @gitcache[repo_path][:nodes][filename] = hashlist
+          end
+        end
+
+        # Store the most recent commit
+        @gitcache[repo_path][:last_commit] = repo.head.target.oid
+      end
+
+      # Currently only used in unit tests
+      def self.clear_cache
+        @gitcache = nil
+      end
+
+      def self.clean_obsolete_nodes(active_nodes)
+        git_config = Oxidized.config.output.git
+        repo_path = git_config.repo
+
+        unless git_config.single_repo?
+          logger.warn "clean_obsolete_nodes is not implemented for " \
+                      "multiple git repositories"
+          return
+        end
+
+        if git_config.type_as_directory?
+          logger.warn "clean_obsolete_nodes is not implemented for output " \
+                      "types as a directory within the git repository"
+          return
+        end
+
+        # The repo might not exist on the first run
+        return unless ::File.directory?(repo_path)
+
+        repo = Rugged::Repository.new repo_path
+        return if repo.empty?
+
+        keep_files = active_nodes.map do |n|
+          n.group ? ::File.join(n.group, n.name) : n.name
+        end
+
+        tree = repo.last_commit.tree
+        files_to_delete = []
+
+        tree.walk_blobs do |root, entry|
+          file_path = root.empty? ? entry[:name] : ::File.join(root, entry[:name])
+          files_to_delete << file_path unless keep_files.include?(file_path)
+        end
+
+        return if files_to_delete.empty?
+
+        logger.info "clean_obsolete_nodes: removing " \
+                    "#{files_to_delete.size} obsolete configs"
+        index = repo.index
+
+        files_to_delete.each { |file_path| index.remove(file_path) }
+
+        repo.config['user.name']  = git_config.user
+        repo.config['user.email'] = git_config.email
+        Rugged::Commit.create(
+          repo,
+          tree:       index.write_tree(repo),
+          message:    "Removing #{files_to_delete.size} obsolete configs",
+          parents:    [repo.head.target].compact,
+          update_ref: 'HEAD'
+        )
+
+        index.write
+      end
+
       private
 
       def yield_repo_and_path(node, group)
-        repo, path = node.repo, node.name
+        repo = node.repo
+        path = node.name
 
         path = "#{group}/#{node.name}" if group && !group.empty? && @cfg.single_repo?
 
@@ -158,10 +271,10 @@ module Oxidized
 
         if @opt[:group]
           if @cfg.single_repo?
-            file = File.join @opt[:group], file
+            file = ::File.join @opt[:group], file
           else
             repo = if repo.is_a?(::String)
-                     File.join File.dirname(repo), @opt[:group] + '.git'
+                     ::File.join ::File.dirname(repo), @opt[:group] + '.git'
                    else
                      repo[@opt[:group]]
                    end
@@ -175,27 +288,21 @@ module Oxidized
           begin
             Rugged::Repository.init_at repo, :bare
           rescue StandardError => create_error
-            raise GitError, "first '#{e.message}' was raised while opening git repo, then '#{create_error.message}' was while trying to create git repo"
+            raise GitError, "first '#{e.message}' was raised while opening git repo, then '#{create_error.message}' " \
+                            "was while trying to create git repo"
           end
           retry
         end
       end
 
-      # Uploads data into file in the repo
-      #
-      # @param [String] file: the file to save the configuration to
-      # @param [String] data: the configuration to save
-      # @param [Rugged::Repository] repo: the git repository to use
-      #
-      # If Oxidized.config.output.git.single_repo = false (which is the default),
-      # there will one repository for each group.
+      # Uploads data into file in the repository repo
       #
       # update_repo caches the index on disk. An index is usually used in a
       # working directory and not in a bare repository, which confuses users.
       # The alternative would be to rebuild the index each time, which a little
       # time consuming. Caching the index in memory is difficult because a new
       # Output object is created each time #store is called.
-      def update_repo(repo, file, data)
+      def update_repo(repo, file, data) # rubocop:disable Naming/PredicateMethod
         oid_old = repo.blob_at(repo.head.target_id, file) rescue nil
         return false if oid_old && (oid_old.content.b == data.b)
 

data/lib/oxidized/output/gitcrypt.rb

@@ -25,17 +25,17 @@ module Oxidized
         if @cfg.empty?
           Oxidized.asetus.user.output.gitcrypt.user  = 'Oxidized'
           Oxidized.asetus.user.output.gitcrypt.email = 'o@example.com'
-          Oxidized.asetus.user.output.gitcrypt.repo = File.join(Config::ROOT, 'oxidized.git')
+          Oxidized.asetus.user.output.gitcrypt.repo = ::File.join(Config::ROOT, 'oxidized.git')
           Oxidized.asetus.save :user
           raise NoConfig, "no output git config, edit #{Oxidized::Config.configfile}"
         end
 
         if @cfg.repo.respond_to?(:each)
           @cfg.repo.each do |group, repo|
-            @cfg.repo["#{group}="] = File.expand_path repo
+            @cfg.repo["#{group}="] = ::File.expand_path repo
           end
         else
-          @cfg.repo = File.expand_path @cfg.repo
+          @cfg.repo = ::File.expand_path @cfg.repo
         end
       end
 
@@ -45,7 +45,7 @@ module Oxidized
           @cfg.users.each do |user|
             system("#{@gitcrypt_adduser} #{user}")
           end
-          File.write(".gitattributes", "* filter=git-crypt diff=git-crypt\n.gitattributes !filter !diff")
+          ::File.write(".gitattributes", "* filter=git-crypt diff=git-crypt\n.gitattributes !filter !diff")
           repo.add(".gitattributes")
           repo.commit("Initial commit: crypt all config files")
         end
@@ -73,7 +73,7 @@ module Oxidized
 
         outputs.types.each do |type|
           type_cfg = ''
-          type_repo = File.join(File.dirname(repo), type + '.git')
+          type_repo = ::File.join(::File.dirname(repo), type + '.git')
           outputs.type(type).each do |output|
             (type_cfg << output; next) unless output.name # rubocop:disable Style/Semicolon
             type_file = file + '--' + output.name
@@ -95,9 +95,9 @@ module Oxidized
         unlock repo
         index = repo.index
         # Empty repo ?
-        raise 'Empty git repo' if File.exist?(index.path)
+        raise 'Empty git repo' if ::File.exist?(index.path)
 
-        File.read path
+        ::File.read path
         lock repo
       rescue StandardError
         'node not found'
@@ -114,7 +114,10 @@ module Oxidized
         tab = []
         walker.each do |commit|
           hash = {}
+          # We keep :date for reverse compatibility on oxidized-web <= 0.15.1
           hash[:date] = commit.date.to_s
+          # date as a Time instance for more flexibility in oxidized-web
+          hash[:time] = commit.date
           hash[:oid] = commit.objectish
           hash[:author] = commit.author
           hash[:message] = commit.message
@@ -173,7 +176,8 @@ module Oxidized
       private
 
       def yield_repo_and_path(node, group)
-        repo, path = node.repo, node.name
+        repo = node.repo
+        path = node.name
 
         path = "#{group}/#{node.name}" if group && @cfg.single_repo?
 
@@ -185,10 +189,10 @@ module Oxidized
 
         if @opt[:group]
           if @cfg.single_repo?
-            file = File.join @opt[:group], file
+            file = ::File.join @opt[:group], file
           else
             repo = if repo.is_a?(::String)
-                     File.join File.dirname(repo), @opt[:group] + '.git'
+                     ::File.join ::File.dirname(repo), @opt[:group] + '.git'
                    else
                      repo[@opt[:group]]
                    end
@@ -198,12 +202,13 @@ module Oxidized
         begin
           update_repo repo, file, data, @msg, @user, @email
         rescue Git::GitExecuteError, ArgumentError => e
-          Oxidized.logger.debug "open_error #{e} #{file}"
+          logger.debug "open_error #{e} #{file}"
           begin
             grepo = Git.init repo
             crypt_init grepo
           rescue StandardError => create_error
-            raise GitCryptError, "first '#{e.message}' was raised while opening git repo, then '#{create_error.message}' was while trying to create git repo"
+            raise GitCryptError, "first '#{e.message}' was raised while opening git repo, then " \
+                                 "'#{create_error.message}' was while trying to create git repo"
           end
           retry
         end
@@ -215,7 +220,7 @@ module Oxidized
         grepo.config('user.email', email)
         grepo.chdir do
           unlock grepo
-          File.write(file, data)
+          ::File.write(file, data)
           grepo.add(file)
           if grepo.status[file].nil? || !grepo.status[file].type.nil?
             grepo.commit(msg)

data/lib/oxidized/output/http.rb

@@ -34,14 +34,14 @@ module Oxidized
 
         case response.code.to_i
         when 200 || 201
-          Oxidized.logger.info "Configuration http backup complete for #{node}"
+          logger.info "Configuration http backup complete for #{node}"
           p [:success]
         when (400..499)
-          Oxidized.logger.info "Configuration http backup for #{node} failed status: #{response.body}"
+          logger.info "Configuration http backup for #{node} failed status: #{response.body}"
           p [:bad_request]
         when (500..599)
           p [:server_problems]
-          Oxidized.logger.info "Configuration http backup for #{node} failed status: #{response.body}"
+          logger.info "Configuration http backup for #{node} failed status: #{response.body}"
         end
       end
 
@@ -55,7 +55,8 @@ module Oxidized
           'group'  => opt[:group],
           'node'   => node,
           'config' => outputs.to_cfg
-          # actually we need to also iterate outputs, for other types like in gitlab. But most people don't use 'type' functionality.
+          # actually we need to also iterate outputs, for other types like in gitlab.
+          # But most people don't use 'type' functionality.
         )
       end
     end