oxidized 0.25.1 → 0.26.0

data/lib/oxidized/cli.rb

@@ -2,15 +2,16 @@ module Oxidized
   class CLI
     require 'slop'
     require 'oxidized'
+    require 'English'
 
     def run
       check_pid
       Process.daemon if @opts[:daemonize]
       write_pid
       begin
-        Oxidized.logger.info "Oxidized starting, running as pid #{$$}"
+        Oxidized.logger.info "Oxidized starting, running as pid #{$PROCESS_ID}"
         Oxidized.new
-      rescue => error
+      rescue StandardError => error
         crash error
         raise
       end
@@ -27,9 +28,9 @@ module Oxidized
       @pidfile = File.expand_path(Oxidized.config.pid)
     end
 
-    def crash error
+    def crash(error)
       Oxidized.logger.fatal "Oxidized crashed, crashfile written in #{Config::Crash}"
-      open Config::Crash, 'w' do |file|
+      File.open Config::Crash, 'w' do |file|
         file.puts '-' * 50
         file.puts Time.now.utc
         file.puts error.message + ' [' + error.class.to_s + ']'
@@ -40,7 +41,7 @@ module Oxidized
     end
 
     def parse_opts
-      opts = Slop.new(:help => true) do
+      opts = Slop.new(help: true) do
         on 'd', 'debug', 'turn on debugging'
         on 'daemonize',  'Daemonize/fork the process'
         on 'show-exhaustive-config', 'output entire configuration, including defaults' do
@@ -56,43 +57,41 @@ module Oxidized
       [opts.parse!, opts]
     end
 
-    def pidfile
-      @pidfile
-    end
+    attr_reader :pidfile
 
     def pidfile?
       !!pidfile
     end
 
     def write_pid
-      if pidfile?
-        begin
-          File.open(pidfile, ::File::CREAT | ::File::EXCL | ::File::WRONLY) { |f| f.write("#{Process.pid}") }
-          at_exit { File.delete(pidfile) if File.exists?(pidfile) }
-        rescue Errno::EEXIST
-          check_pid
-          retry
-        end
+      return unless pidfile?
+
+      begin
+        File.open(pidfile, ::File::CREAT | ::File::EXCL | ::File::WRONLY) { |f| f.write(Process.pid.to_s) }
+        at_exit { File.delete(pidfile) if File.exist?(pidfile) }
+      rescue Errno::EEXIST
+        check_pid
+        retry
       end
     end
 
     def check_pid
-      if pidfile?
-        case pid_status(pidfile)
-        when :running, :not_owned
-          puts "A server is already running. Check #{pidfile}"
-          exit(1)
-        when :dead
-          File.delete(pidfile)
-        end
+      return unless pidfile?
+
+      case pid_status(pidfile)
+      when :running, :not_owned
+        puts "A server is already running. Check #{pidfile}"
+        exit(1)
+      when :dead
+        File.delete(pidfile)
       end
     end
 
     def pid_status(pidfile)
-      return :exited unless File.exists?(pidfile)
+      return :exited unless File.exist?(pidfile)
 
       pid = ::File.read(pidfile).to_i
-      return :dead if pid == 0
+      return :dead if pid.zero?
 
       Process.kill(0, pid)
       :running

data/lib/oxidized/config.rb

@@ -4,13 +4,13 @@ module Oxidized
   class InvalidConfig < OxidizedError; end
   class Config
     Root      = ENV['OXIDIZED_HOME'] || File.join(ENV['HOME'], '.config', 'oxidized')
-    Crash     = File.join Root, 'crash'
-    Log       = File.join Root, 'logs'
-    InputDir  = File.join Directory, %w(lib oxidized input)
-    OutputDir = File.join Directory, %w(lib oxidized output)
-    ModelDir  = File.join Directory, %w(lib oxidized model)
-    SourceDir = File.join Directory, %w(lib oxidized source)
-    HookDir   = File.join Directory, %w(lib oxidized hook)
+    Crash     = File.join(ENV['OXIDIZED_LOGS'] || Root, 'crash')
+    Log       = File.join(ENV['OXIDIZED_LOGS'] || Root, 'logs')
+    InputDir  = File.join Directory, %w[lib oxidized input]
+    OutputDir = File.join Directory, %w[lib oxidized output]
+    ModelDir  = File.join Directory, %w[lib oxidized model]
+    SourceDir = File.join Directory, %w[lib oxidized source]
+    HookDir   = File.join Directory, %w[lib oxidized hook]
     Sleep     = 1
 
     def self.load(cmd_opts = {})
@@ -49,13 +49,13 @@ module Oxidized
       asetus.default.source.default = 'csv'   # csv, sql
 
       asetus.default.model_map = {
-        'cisco'   => 'ios',
         'juniper' => 'junos',
+        'cisco'   => 'ios'
       }
 
       begin
         asetus.load # load system+user configs, merge to Config.cfg
-      rescue => error
+      rescue StandardError => error
         raise InvalidConfig, "Error loading config: #{error.message}"
       end
 

data/lib/oxidized/config/vars.rb

@@ -1,17 +1,13 @@
 module Oxidized::Config::Vars
   # convenience method for accessing node, group or global level user variables
   # nil values will be ignored
-  def vars name
+  def vars(name)
     r = @node.vars[name] unless @node.vars.nil?
     if Oxidized.config.groups.has_key?(@node.group)
-      if Oxidized.config.groups[@node.group].vars.has_key?(name.to_s)
-        r ||= Oxidized.config.groups[@node.group].vars[name.to_s]
-      end
+      r ||= Oxidized.config.groups[@node.group].vars[name.to_s] if Oxidized.config.groups[@node.group].vars.has_key?(name.to_s)
     end
     if Oxidized.config.models.has_key?(@node.model.class.name.to_s.downcase)
-      if Oxidized.config.models[@node.model.class.name.to_s.downcase].vars.has_key?(name.to_s)
-        r ||= Oxidized.config.models[@node.model.class.name.to_s.downcase].vars[name.to_s]
-      end
+      r ||= Oxidized.config.models[@node.model.class.name.to_s.downcase].vars[name.to_s] if Oxidized.config.models[@node.model.class.name.to_s.downcase].vars.has_key?(name.to_s)
     end
     r ||= Oxidized.config.vars[name.to_s] if Oxidized.config.vars.has_key?(name.to_s)
     r

data/lib/oxidized/core.rb

@@ -1,6 +1,6 @@
 module Oxidized
   class << self
-    def new *args
+    def new(*args)
       Core.new args
     end
   end
@@ -8,11 +8,11 @@ module Oxidized
   class Core
     class NoNodesFound < OxidizedError; end
 
-    def initialize args
+    def initialize(_args)
       Oxidized.mgr = Manager.new
       Oxidized.Hooks = HookManager.from_config(Oxidized.config)
       nodes = Nodes.new
-      raise NoNodesFound, 'source returns no usable nodes' if nodes.size == 0
+      raise NoNodesFound, 'source returns no usable nodes' if nodes.size.zero?
 
       @worker = Worker.new nodes
       trap('HUP') { nodes.load }
@@ -33,10 +33,7 @@ module Oxidized
 
     def run
       Oxidized.logger.debug "lib/oxidized/core.rb: Starting the worker..."
-      while true
-        @worker.work
-        sleep Config::Sleep
-      end
+      @worker.work while sleep Config::Sleep
     end
   end
 end

data/lib/oxidized/hook.rb

@@ -1,7 +1,7 @@
 module Oxidized
   class HookManager
     class << self
-      def from_config cfg
+      def from_config(cfg)
         mgr = new
         cfg.hooks.each do |name, h_cfg|
           h_cfg.events.each do |event|
@@ -17,27 +17,27 @@ module Oxidized
     class HookContext < OpenStruct; end
 
     # RegisteredHook is a container for a Hook instance
-    class RegisteredHook < Struct.new(:name, :hook); end
+    RegisteredHook = Struct.new(:name, :hook)
 
-    Events = [
-      :node_success,
-      :node_fail,
-      :post_store,
-      :nodes_done
-    ]
+    Events = %i[
+      node_success
+      node_fail
+      post_store
+      nodes_done
+    ].freeze
     attr_reader :registered_hooks
 
     def initialize
       @registered_hooks = Hash.new { |h, k| h[k] = [] }
     end
 
-    def register event, name, hook_type, cfg
+    def register(event, name, hook_type, cfg)
       unless Events.include? event
         raise ArgumentError,
               "unknown event #{event}, available: #{Events.join ','}"
       end
 
-      Oxidized.mgr.add_hook(hook_type) or raise("cannot load hook '#{hook_type}', not found")
+      Oxidized.mgr.add_hook(hook_type) || raise("cannot load hook '#{hook_type}', not found")
       begin
         hook = Oxidized.mgr.hook.fetch(hook_type).new
       rescue KeyError
@@ -50,15 +50,15 @@ module Oxidized
       Oxidized.logger.debug "Hook #{name.inspect} registered #{hook.class} for event #{event.inspect}"
     end
 
-    def handle event, ctx_params = {}
+    def handle(event, ctx_params = {})
       ctx = HookContext.new ctx_params
       ctx.event = event
 
       @registered_hooks[event].each do |r_hook|
         begin
           r_hook.hook.run_hook ctx
-        rescue => e
-          Oxidized.logger.error "Hook #{r_hook.name} (#{r_hook.hook}) failed " +
+        rescue StandardError => e
+          Oxidized.logger.error "Hook #{r_hook.name} (#{r_hook.hook}) failed " \
                                 "(#{e.inspect}) for event #{event.inspect}"
         end
       end
@@ -69,15 +69,14 @@ module Oxidized
   class Hook
     attr_reader :cfg
 
-    def initialize
-    end
+    def initialize; end
 
     def cfg=(cfg)
       @cfg = cfg
-      validate_cfg! if self.respond_to? :validate_cfg!
+      validate_cfg! if respond_to? :validate_cfg!
     end
 
-    def run_hook ctx
+    def run_hook(_ctx)
       raise NotImplementedError
     end
 

data/lib/oxidized/hook/awssns.rb

@@ -10,13 +10,13 @@ class AwsSns < Oxidized::Hook
     sns = Aws::SNS::Resource.new(region: cfg.region)
     topic = sns.topic(cfg.topic_arn)
     message = {
-      :event => ctx.event.to_s
+      event: ctx.event.to_s
     }
     if ctx.node
       message.merge!(
-        :group => ctx.node.group.to_s,
-        :model => ctx.node.model.class.name.to_s.downcase,
-        :node => ctx.node.name.to_s
+        group: ctx.node.group.to_s,
+        model: ctx.node.model.class.name.to_s.downcase,
+        node:  ctx.node.name.to_s
       )
     end
     topic.publish(

data/lib/oxidized/hook/exec.rb

@@ -12,12 +12,10 @@ class Exec < Oxidized::Hook
     if cfg.has_key? "timeout"
       @timeout = cfg.timeout
       raise "invalid timeout value" unless @timeout.is_a?(Integer) &&
-                                           @timeout > 0
+                                           @timeout.positive?
     end
 
-    if cfg.has_key? "async"
-      @async = !!cfg.async
-    end
+    @async = !!cfg.async if cfg.has_key? "async"
 
     if cfg.has_key? "cmd"
       @cmd = cfg.cmd
@@ -28,23 +26,23 @@ class Exec < Oxidized::Hook
           "#{self.class.name}: configuration invalid: #{e.message}"
   end
 
-  def run_hook ctx
+  def run_hook(ctx)
     env = make_env ctx
     log "Execute: #{@cmd.inspect}", :debug
     th = Thread.new do
       begin
         run_cmd! env
-      rescue => e
+      rescue StandardError => e
         raise e unless @async
       end
     end
     th.join unless @async
   end
 
-  def run_cmd! env
+  def run_cmd!(env)
     pid, status = nil, nil
     Timeout.timeout(@timeout) do
-      pid = spawn env, @cmd, :unsetenv_others => true
+      pid = spawn env, @cmd, unsetenv_others: true
       pid, status = wait2 pid
       unless status.exitstatus.zero?
         msg = "#{@cmd.inspect} failed with exit value #{status.exitstatus}"
@@ -59,27 +57,25 @@ class Exec < Oxidized::Hook
     raise Timeout::Error, msg
   end
 
-  def make_env ctx
+  def make_env(ctx)
     env = {
       "OX_EVENT" => ctx.event.to_s
     }
     if ctx.node
       env.merge!(
-        "OX_NODE_NAME" => ctx.node.name.to_s,
-        "OX_NODE_IP" => ctx.node.ip.to_s,
-        "OX_NODE_FROM" => ctx.node.from.to_s,
-        "OX_NODE_MSG" => ctx.node.msg.to_s,
-        "OX_NODE_GROUP" => ctx.node.group.to_s,
-        "OX_NODE_MODEL" => ctx.node.model.class.name,
+        "OX_NODE_NAME"      => ctx.node.name.to_s,
+        "OX_NODE_IP"        => ctx.node.ip.to_s,
+        "OX_NODE_FROM"      => ctx.node.from.to_s,
+        "OX_NODE_MSG"       => ctx.node.msg.to_s,
+        "OX_NODE_GROUP"     => ctx.node.group.to_s,
+        "OX_NODE_MODEL"     => ctx.node.model.class.name,
         "OX_REPO_COMMITREF" => ctx.commitref.to_s,
-        "OX_REPO_NAME" => ctx.node.repo.to_s,
+        "OX_REPO_NAME"      => ctx.node.repo.to_s
       )
     end
     if ctx.job
-      env.merge!(
-        "OX_JOB_STATUS" => ctx.job.status.to_s,
-        "OX_JOB_TIME" => ctx.job.time.to_s,
-      )
+      env["OX_JOB_STATUS"] = ctx.job.status.to_s
+      env["OX_JOB_TIME"] = ctx.job.time.to_s
     end
     env
   end

data/lib/oxidized/hook/githubrepo.rb

@@ -18,7 +18,7 @@ class GithubRepo < Oxidized::Hook
     result = repo.fetch('origin', [repo.head.name], credentials: credentials)
     log result.inspect, :debug
 
-    unless result[:total_deltas] > 0
+    unless result[:total_deltas].positive?
       log "nothing recieved after fetch", :debug
       return
     end
@@ -34,24 +34,18 @@ class GithubRepo < Oxidized::Hook
       return
     end
 
-    Rugged::Commit.create(repo, {
-                            parents: [repo.head.target, their_branch.target],
-                            tree: merge_index.write_tree(repo),
-                            message: "Merge remote-tracking branch '#{their_branch.name}'",
-                            update_ref: "HEAD"
-                          })
+    Rugged::Commit.create(repo,
+                          parents:    [repo.head.target, their_branch.target],
+                          tree:       merge_index.write_tree(repo),
+                          message:    "Merge remote-tracking branch '#{their_branch.name}'",
+                          update_ref: "HEAD")
   end
 
   private
 
   def credentials
-    Proc.new do |url, username_from_url, allowed_types|
-      if cfg.has_key?('username')
-        git_user = cfg.username
-      else
-        git_user = username_from_url || 'git'
-      end
-
+    Proc.new do |_url, username_from_url, _allowed_types| # rubocop:disable Style/Proc
+      git_user = cfg.has_key?('username') ? cfg.username : (username_from_url || 'git')
       if cfg.has_key?('password')
         log "Authenticating using username and password as '#{git_user}'", :debug
         Rugged::Credentials::UserPassword.new(username: git_user, password: cfg.password)

data/lib/oxidized/hook/noophook.rb

@@ -3,7 +3,7 @@ class NoopHook < Oxidized::Hook
     log "Validate config"
   end
 
-  def run_hook ctx
+  def run_hook(ctx)
     log "Run hook with context: #{ctx}"
   end
 end

data/lib/oxidized/hook/xmppdiff.rb

@@ -19,7 +19,7 @@ class XMPPDiff < Oxidized::Hook
         diff = gitoutput.get_diff ctx.node, ctx.node.group, ctx.commitref, nil
 
         interesting = diff[:patch].lines.to_a[4..-1].any? do |line|
-          ["+", "-"].include?(line[0]) and not ["#", "!"].include?(line[1])
+          ["+", "-"].include?(line[0]) && (not ["#", "!"].include?(line[1]))
         end
         interesting &&= diff[:patch].lines.to_a[5..-1].any? { |line| line[0] == '-' }
         interesting &&= diff[:patch].lines.to_a[5..-1].any? { |line| line[0] == '+' }

data/lib/oxidized/input/cli.rb

@@ -32,24 +32,24 @@ module Oxidized
         @pre_logout.each { |command, block| block ? block.call : (cmd command, nil) }
       end
 
-      def post_login _post_login = nil, &block
-        unless @exec
-          @post_login << [_post_login, block]
-        end
+      def post_login(cmd = nil, &block)
+        return if @exec
+
+        @post_login << [cmd, block]
       end
 
-      def pre_logout _pre_logout = nil, &block
-        unless @exec
-          @pre_logout << [_pre_logout, block]
-        end
+      def pre_logout(cmd = nil, &block)
+        return if @exec
+
+        @pre_logout << [cmd, block]
       end
 
-      def username re = /^(Username|login)/
-        @username or @username = re
+      def username(regex = /^(Username|login)/)
+        @username || (@username = regex)
       end
 
-      def password re = /^Password/
-        @password or @password = re
+      def password(regex = /^Password/)
+        @password || (@password = regex)
       end
 
       def login