oxidized 0.29.1 → 0.37.0

data/extra/syslog.rb

@@ -8,8 +8,10 @@
 # set system syslog host SERVER interactive-commands notice
 # set system syslog host SERVER match "^mgd\[[0-9]+\]: UI_COMMIT: .*"
 
-# Ports < 1024 need extra privileges, use a port higher than this by setting the port option in your oxidized config file.
-# To use the default port for syslog (514) you shouldn't pass an argument, but you will need to allow this with:
+# Ports < 1024 need extra privileges, use a port higher than this by setting the
+# port option in your oxidized config file.
+# To use the default port for syslog (514) you shouldn't pass an argument, but
+# you will need to allow this with:
 # sudo setcap 'cap_net_bind_service=+ep' /usr/bin/ruby
 
 # Config options are:
@@ -43,8 +45,8 @@ module Oxidized
 
   begin
     CFGS.load
-  rescue StandardError => error
-    raise InvalidConfig, "Error loading config: #{error.message}"
+  rescue StandardError => e
+    raise InvalidConfig, "Error loading config: #{e.message}"
   ensure
     CFG = CFGS.cfg # convenienence, instead of Config.cfg.password, CFG.password
   end
@@ -52,6 +54,7 @@ module Oxidized
   class SyslogMonitor
     MSG = {
       ios:   /%SYS-(SW[0-9]+-)?5-CONFIG_I:/,
+      iosxr: /%MGBL-SYS-5-CONFIG_I/,
       junos: 'UI_COMMIT:',
       eos:   /%SYS-5-CONFIG_I:/,
       nxos:  /%VSHD-5-VSHD_SYSLOG_CONFIG_I:/,
@@ -89,6 +92,7 @@ module Oxidized
       opts[:from] = log[-1][1..-2]
       opts
     end
+    alias iosxr ios
     alias nxos ios
     alias eos ios
 
@@ -116,7 +120,8 @@ module Oxidized
     def run(io)
       loop do
         log = select [io]
-        log, ip = log.first.first, nil
+        log = log.first.first
+        ip = nil
         if @mode == :udp
           log, ip = log.recvfrom_nonblock 2000
           ip = ip.last
@@ -136,7 +141,7 @@ module Oxidized
       if Oxidized::CFG.syslogd.resolve == false
         ipaddr
       else
-        name = (Resolv.getname ipaddr.to_s rescue ipaddr)
+        name = (Resolv.getname ipaddr.to_s rescue ipaddr) # rubocop:disable Style/RedundantParentheses
         Oxidized::CFG.syslogd.dns_map.each { |re, sub| name.sub! Regexp.new(re.to_s), sub }
         name
       end

data/lib/oxidized/cli/support.rb

@@ -0,0 +1,152 @@
+require 'time'
+
+module Oxidized
+  class CLI
+    module Support
+      SENSITIVE_NAME_RE = /(password|passphrase|secret|token|enable|
+                            (private|api|access)_?key|
+                            community|credential|auth
+                          )/ix
+      ROOT_GEMS = %w[oxidized oxidized-web].freeze
+      EXPLICIT_ENV_KEYS = %w[
+        OXIDIZED_HOME
+        OXIDIZED_LOGS
+        CONFIG_RELOAD_INTERVAL
+        UPDATE_CA_CERTIFICATES
+      ].freeze
+
+      private
+
+      def show_support_details
+        print_intro
+        print_environment
+        print_config_files
+        print_rugged_support
+        print_installed_gems
+      end
+
+      def print_intro
+        os_release = read_os_release
+        runit_path = '/etc/service/oxidized/run'
+
+        puts '> :warning:'
+        puts '> The --support option is intended for diagnostic purposes and may include sensitive information.'
+        puts '> Remove any sensitive data before sharing this output.'
+        puts
+        puts '## Oxidized Support Data'
+        puts "- Timestamp: #{Time.now.utc.iso8601}"
+        puts "- Oxidized version: #{Oxidized::VERSION_FULL}"
+        puts "- OS release: #{os_release}" if os_release
+        puts "- Container hint (#{runit_path} exists): #{File.exist?(runit_path)}"
+        puts "- Ruby engine: #{defined?(RUBY_ENGINE) ? RUBY_ENGINE : 'ruby'}"
+        puts "- Ruby version: #{RUBY_VERSION}p#{RUBY_PATCHLEVEL} (#{RUBY_PLATFORM})"
+        puts "- Working directory: #{Dir.pwd}"
+        puts "- Gem paths: #{Gem.path.join(', ')}"
+        puts
+      end
+
+      def print_environment
+        puts '### Environment Variables'
+        keys = (ENV.keys.grep(/^OXIDIZED_/) + EXPLICIT_ENV_KEYS).uniq.sort
+
+        keys.each do |key|
+          next unless ENV.has_key?(key)
+
+          value = ENV.fetch(key)
+          puts key.match?(SENSITIVE_NAME_RE) ? "#{key}=[REDACTED]" : "#{key}=#{value}"
+        end
+
+        puts
+      end
+
+      def print_config_files
+        puts '### Configuration Files'
+        config_paths.each do |path|
+          config_path = File.expand_path(path)
+          exists = File.exist?(config_path)
+          puts "- #{config_path} exists: #{exists ? 'yes' : 'no'}"
+          next unless exists
+
+          print_sanitized_config(config_path)
+        end
+        puts
+      end
+
+      def print_rugged_support
+        puts '### Rugged'
+        begin
+          require 'rugged'
+          puts "- Rugged version: #{Rugged::VERSION}"
+
+          ssh_supported = Rugged.respond_to?(:features) && Rugged.features.include?(:ssh)
+          puts "- Rugged SSH support: #{ssh_supported}"
+        rescue LoadError
+          puts '- Rugged: not available'
+          puts '- Rugged SSH support: false'
+        end
+        puts
+      end
+
+      def print_installed_gems
+        puts '### Relevant Installed Gems'
+        relevant_gem_names.each do |name|
+          versions = Gem::Specification.find_all_by_name(name).sort_by(&:version).map { |s| s.version.to_s }
+          puts "- #{name} (#{versions.join(', ')})" unless versions.empty?
+        end
+      end
+
+      def relevant_gem_names
+        names = ROOT_GEMS.select { |name| Gem::Specification.any? { |s| s.name == name } }
+
+        root_specs = names.flat_map { |name| Gem::Specification.find_all_by_name(name) }
+        runtime_deps = root_specs.flat_map { |spec| spec.dependencies }
+        names.concat(runtime_deps.map(&:name))
+        names.sort.uniq
+      end
+
+      def config_paths
+        user_default = File.join(Dir.home, '.config', 'oxidized', 'config')
+        home_from_env = File.join(File.expand_path(Oxidized::Config::ROOT), 'config')
+
+        [
+          '/etc/oxidized/config',
+          user_default,
+          home_from_env
+        ].uniq
+      end
+
+      def print_sanitized_config(path)
+        content = File.read(path)
+        puts '```yaml'
+        content.each_line(chomp: true) do |line|
+          key, separator, = line.partition(':')
+
+          if separator.empty? || key.empty?
+            puts line
+            next
+          end
+
+          if key.match?(SENSITIVE_NAME_RE)
+            puts "#{key}: [REDACTED]"
+          else
+            puts line
+          end
+        end
+        puts '```'
+      rescue StandardError => e
+        puts "    <failed to read: #{e.class}: #{e.message}>"
+      end
+
+      def read_os_release
+        return nil unless File.exist?('/etc/os-release')
+
+        line = File.foreach('/etc/os-release').find { |entry| entry.start_with?('PRETTY_NAME=') }
+        return nil unless line
+
+        line.split('=', 2).last.to_s.strip.gsub(/^"|"$/, '')
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/oxidized/cli.rb

@@ -1,5 +1,11 @@
+require 'semantic_logger'
+require_relative 'cli/support'
+
 module Oxidized
   class CLI
+    include SemanticLogger::Loggable
+    include Support
+
     require 'slop'
     require 'oxidized'
     require 'English'
@@ -9,10 +15,10 @@ module Oxidized
       Process.daemon if @opts[:daemonize]
       write_pid
       begin
-        Oxidized.logger.info "Oxidized starting, running as pid #{$PROCESS_ID}"
+        logger.info "Oxidized starting, running as pid #{$PROCESS_ID}"
         Oxidized.new
-      rescue StandardError => error
-        crash error
+      rescue StandardError => e
+        crash e
         raise
       end
     end
@@ -23,14 +29,14 @@ module Oxidized
       _args, @opts = parse_opts
 
       Config.load(@opts)
-      Oxidized.setup_logger
+      Oxidized::Logger.setup
 
       @pidfile = File.expand_path(Oxidized.config.pid)
     end
 
     def crash(error)
-      Oxidized.logger.fatal "Oxidized crashed, crashfile written in #{Config::Crash}"
-      File.open Config::Crash, 'w' do |file|
+      logger.fatal "Oxidized crashed, crashfile written in #{Config::CRASH}"
+      File.open Config::CRASH, 'w' do |file|
         file.puts '-' * 50
         file.puts Time.now.utc
         file.puts error.message + ' [' + error.class.to_s + ']'
@@ -44,6 +50,9 @@ module Oxidized
       opts = Slop.parse do |opt|
         opt.on '-d', '--debug', 'turn on debugging'
         opt.on '--daemonize', 'Daemonize/fork the process'
+        opt.on '--support', 'show support diagnostics and exit'
+        opt.string '--home-dir', 'Oxidized home dir', default: nil
+        opt.string '--config-file', 'Oxidized config file', default: nil
         opt.on '-h', '--help', 'show usage' do
           puts opt
           exit
@@ -58,6 +67,12 @@ module Oxidized
           Kernel.exit
         end
       end
+
+      if opts[:support]
+        show_support_details
+        Kernel.exit
+      end
+
       [opts.arguments, opts]
     end
 

data/lib/oxidized/config/vars.rb

@@ -1,17 +1,36 @@
-module Oxidized::Config::Vars
-  # convenience method for accessing node, group or global level user variables
-  def vars(name)
-    model_name = @node.model.class.name.to_s.downcase
-    if @node.vars&.has_key?(name)
-      @node.vars[name]
-    elsif Oxidized.config.groups.has_key?(@node.group) && Oxidized.config.groups[@node.group].models.has_key(model_name) && Oxidized.config.groups[@node.group].models[model_name].vars.has_key?(name.to_s)
-      Oxidized.config.groups[@node.group].models[model_name].vars[name.to_s]
-    elsif Oxidized.config.groups.has_key?(@node.group) && Oxidized.config.groups[@node.group].vars.has_key?(name.to_s)
-      Oxidized.config.groups[@node.group].vars[name.to_s]
-    elsif Oxidized.config.models.has_key(model_name) && Oxidized.config.models[model_name].vars.has_key?(name.to_s)
-      Oxidized.config.models[model_name].vars[name.to_s]
-    elsif Oxidized.config.vars.has_key?(name.to_s)
-      Oxidized.config.vars[name.to_s]
+module Oxidized
+  class Config
+    module Vars
+      # convenience method for accessing node, group or global level user variables
+      def vars(name)
+        model_name = @node.model.class.name.to_s.downcase
+        groups = Oxidized.config.groups
+        models = Oxidized.config.models
+        group = groups[@node.group] if groups.has_key?(@node.group)
+        model = models[model_name] if models.has_key?(model_name)
+        group_model = group.models[model_name] if group&.models&.has_key?(model_name)
+
+        scopes = {
+          node:        @node.vars,
+          group_model: group_model&.vars,
+          group:       group&.vars,
+          model:       model&.vars,
+          vars:        Oxidized.config.vars
+        }
+
+        scopes.each do |scope_name, scope|
+          next unless scope&.has_key?(name.to_s)
+
+          val = scope[name.to_s]
+          if val.nil?
+            Oxidized.logger.debug "vars.rb: scope #{scope_name} has key #{name} with value nil, ignoring scope"
+          else
+            Oxidized.logger.debug "vars.rb: scope #{scope_name} has key #{name} with value #{val}, using scope"
+            return val
+          end
+        end
+        nil
+      end
     end
   end
 end

data/lib/oxidized/config.rb

@@ -4,18 +4,22 @@ module Oxidized
   class InvalidConfig < OxidizedError; end
 
   class Config
-    Root      = ENV['OXIDIZED_HOME'] || File.join(Dir.home, '.config', 'oxidized')
-    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
+    ROOT       = ENV['OXIDIZED_HOME'] || File.join(Dir.home, '.config', 'oxidized')
+    CRASH      = File.join(ENV['OXIDIZED_LOGS'] || ROOT, 'crash')
+    LOG        = File.join(ENV['OXIDIZED_LOGS'] || ROOT, 'logs')
+    INPUT_DIR  = File.join Directory, %w[lib oxidized input]
+    OUTPUT_DIR = File.join Directory, %w[lib oxidized output]
+    MODEL_DIR  = File.join Directory, %w[lib oxidized model]
+    SOURCE_DIR = File.join Directory, %w[lib oxidized source]
+    HOOK_DIR   = File.join Directory, %w[lib oxidized hook]
+    SLEEP      = 1
 
     def self.load(cmd_opts = {})
-      asetus = Asetus.new(name: 'oxidized', load: false, key_to_s: true, usrdir: Oxidized::Config::Root)
+      usrdir = File.expand_path(cmd_opts[:home_dir] || Oxidized::Config::ROOT)
+      cfgfile = cmd_opts[:config_file] || 'config'
+      # configuration file with full path as a class instance variable
+      @configfile = File.join(usrdir, cfgfile)
+      asetus = Asetus.new(name: 'oxidized', load: false, usrdir: usrdir, cfgfile: cfgfile)
       Oxidized.asetus = asetus
 
       asetus.default.username      = 'username'
@@ -23,22 +27,25 @@ module Oxidized
       asetus.default.model         = 'junos'
       asetus.default.resolve_dns   = true # if false, don't resolve DNS to IP
       asetus.default.interval      = 3600
-      asetus.default.use_syslog    = false
       asetus.default.debug         = false
+      asetus.default.run_once      = false
       asetus.default.threads       = 30
       asetus.default.use_max_threads = false
       asetus.default.timeout       = 20
+      asetus.default.timelimit     = 300
       asetus.default.retries       = 3
       asetus.default.prompt        = /^([\w.@-]+[#>]\s?)$/
-      asetus.default.rest          = '127.0.0.1:8888' # or false to disable
       asetus.default.next_adds_job = false            # if true, /next adds job, so device is fetched immmeiately
       asetus.default.vars          = {}               # could be 'enable'=>'enablePW'
       asetus.default.groups        = {}               # group level configuration
       asetus.default.group_map     = {}               # map aliases of groups to names
       asetus.default.models        = {}               # model level configuration
-      asetus.default.pid           = File.join(Oxidized::Config::Root, 'pid')
+      asetus.default.pid           = File.join(Oxidized::Config::ROOT, 'pid')
 
-      asetus.default.crash.directory = File.join(Oxidized::Config::Root, 'crashes')
+      # Extentions
+      asetus.default.extensions['oxidized-web'].load = false
+
+      asetus.default.crash.directory = File.join(Oxidized::Config::ROOT, 'crashes')
       asetus.default.crash.hostnames = false
 
       asetus.default.stats.history_size = 10
@@ -58,17 +65,21 @@ module Oxidized
 
       begin
         asetus.load # load system+user configs, merge to Config.cfg
-      rescue StandardError => error
-        raise InvalidConfig, "Error loading config: #{error.message}"
+      rescue StandardError => e
+        raise InvalidConfig, "Error loading config: #{e.message}"
       end
 
-      raise NoConfig, 'edit ~/.config/oxidized/config' if asetus.create
+      raise NoConfig, "edit #{@configfile}" if asetus.create
 
       # override if comand line flag given
       asetus.cfg.debug = cmd_opts[:debug] if cmd_opts[:debug]
 
       asetus
     end
+
+    class << self
+      attr_reader :configfile
+    end
   end
 
   class << self

data/lib/oxidized/core.rb

@@ -6,24 +6,56 @@ module Oxidized
   end
 
   class Core
+    include SemanticLogger::Loggable
+
     class NoNodesFound < OxidizedError; end
 
     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.zero?
+      raise NoNodesFound, 'source returns no usable nodes' if nodes.empty?
 
       @worker = Worker.new nodes
-      trap('HUP') { nodes.load }
-      if Oxidized.config.rest?
+      @need_reload = false
+
+      # If we receive a SIGHUP, queue a reload of the state
+      reload_proc = proc do
+        @need_reload = true
+      end
+      Signals.register_signal('HUP', reload_proc)
+
+      # Load extensions, currently only oxidized-web
+      # We have different namespaces for oxidized-web, which needs to be
+      # adressed if we need a generic way to load extensions:
+      # - gem: oxidized-web
+      # - module: Oxidized::API
+      # - path: oxidized/web
+      # - entrypoint: Oxidized::API::Web.new(nodes, configuration)
+
+      # Initialize oxidized-web if requested
+      if Oxidized.config.has_key? 'rest'
+        logger.warn(
+          'configuration: "rest" is deprecated. Migrate to ' \
+          '"extensions.oxidized-web" and remove "rest" from the configuration'
+        )
+        configuration = Oxidized.config.rest
+      elsif Oxidized.config.extensions &&
+            Oxidized.config.extensions['oxidized-web']&.load?
+        # This comment stops rubocop complaining about Style/IfUnlessModifier
+        configuration = Oxidized.config.extensions['oxidized-web']
+      end
+
+      if configuration
         begin
           require 'oxidized/web'
         rescue LoadError
-          raise OxidizedError, 'oxidized-web not found: sudo gem install oxidized-web - \
-          or disable web support by setting "rest: false" in your configuration'
+          raise OxidizedError,
+                'oxidized-web not found: install it or disable it by ' \
+                'removing "rest" and "extensions.oxidized-web" from your ' \
+                'configuration'
         end
-        @rest = API::Web.new nodes, Oxidized.config.rest
+        @rest = API::Web.new nodes, configuration
         @rest.run
       end
       run
@@ -31,9 +63,19 @@ module Oxidized
 
     private
 
+    def reload
+      logger.info("Reloading node list")
+      @worker.reload
+      @need_reload = false
+    end
+
     def run
-      Oxidized.logger.debug "lib/oxidized/core.rb: Starting the worker..."
-      @worker.work while sleep Config::Sleep
+      logger.debug "Starting the worker..."
+      loop do
+        reload if @need_reload
+        @worker.work
+        sleep Config::SLEEP
+      end
     end
   end
 end

data/lib/oxidized/hook/ciscosparkdiff.rb

@@ -14,30 +14,32 @@ class CiscoSparkDiff < Oxidized::Hook
     return unless ctx.node
     return unless ctx.event.to_s == "post_store"
 
-    log "Connecting to Cisco Spark"
+    logger.info "Connecting to Cisco Spark"
     CiscoSpark.configure do |config|
       config.api_key = cfg.accesskey
       config.proxy = cfg.proxy if cfg.has_key?('proxy')
     end
     room = CiscoSpark::Room.new(id: cfg.space)
-    log "Connected"
+    logger.info "Connected"
 
     if cfg.has_key?("diff") ? cfg.diff : true
       gitoutput = ctx.node.output.new
       diff = gitoutput.get_diff ctx.node, ctx.node.group, ctx.commitref, nil
       title = ctx.node.name.to_s
-      log "Posting diff as snippet to #{cfg.space}"
-      room.send_message CiscoSpark::Message.new(text: 'Device ' + title + ' modified:' + "\n" + diff[:patch].lines.to_a[4..-1].join)
+      logger.info "Posting diff as snippet to #{cfg.space}"
+      room.send_message CiscoSpark::Message.new(text: "Device #{title} modified:\n" +
+                                                      diff[:patch].lines.to_a[4..-1].join)
     end
 
     if cfg.message?
-      log cfg.message
-      msg = cfg.message % { node: ctx.node.name.to_s, group: ctx.node.group.to_s, commitref: ctx.commitref, model: ctx.node.model.class.name.to_s.downcase }
-      log msg
-      log "Posting message to #{cfg.space}"
+      logger.info cfg.message
+      msg = cfg.message % { node: ctx.node.name.to_s, group: ctx.node.group.to_s, commitref: ctx.commitref,
+                            model: ctx.node.model.class.name.to_s.downcase }
+      logger.info msg
+      logger.info "Posting message to #{cfg.space}"
       room.send_message CiscoSpark::Message.new(text: msg)
     end
 
-    log "Finished"
+    logger.info "Finished"
   end
 end

data/lib/oxidized/hook/exec.rb

@@ -28,7 +28,7 @@ class Exec < Oxidized::Hook
 
   def run_hook(ctx)
     env = make_env ctx
-    log "Execute: #{@cmd.inspect}", :debug
+    logger.debug "Execute: #{@cmd.inspect}"
     th = Thread.new do
       run_cmd! env
     rescue StandardError => e
@@ -38,20 +38,21 @@ class Exec < Oxidized::Hook
   end
 
   def run_cmd!(env)
-    pid, status = nil, nil
+    pid = nil
+    status = nil
     Timeout.timeout(@timeout) do
       pid = spawn env, @cmd, unsetenv_others: true
       pid, status = wait2 pid
       unless status.exitstatus.zero?
         msg = "#{@cmd.inspect} failed with exit value #{status.exitstatus}"
-        log msg, :error
+        logger.error msg
         raise msg
       end
     end
   rescue Timeout::Error
     kill "TERM", pid
     msg = "#{@cmd} timed out"
-    log msg, :error
+    logger.error msg
     raise Timeout::Error, msg
   end