oxidized 0.29.1 → 0.37.0

data/extra/device2yaml.rb

@@ -0,0 +1,259 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'net/ssh'
+require 'optparse'
+require 'etc'
+require 'timeout'
+
+# This script logs in a network device and outputs a YAML file that can be
+# used for model unit tests in spec/model/
+# For more information, see docs/DeviceSimulation.md
+
+################# Methods
+# Runs cmd in the ssh session, either im exec mode or with a tty
+# saves the output to @output
+def ssh_exec(cmd)
+  puts "\n### Sending #{cmd.dump}..."
+  @output&.puts "  #{@sequence_prepend_command}#{cmd.dump}: |-"
+
+  if @exec_mode
+    @ssh_output = @ssh.exec! cmd
+  else
+    @ses.send_data cmd
+    shell_wait
+  end
+  yaml_output('    ')
+end
+
+# Wait for the ssh command to be executed, with an idle timout @idle_timeout
+# Pressing CTRL-C exits the script
+# Pressing ESC termiates the idle timeout
+def shell_wait
+  @ssh_output = ''
+  # ssh_output gets appended by chanel.on-data (below)
+  # We store the current length of @ssh_output in @ssh_output_length
+  # if @ssh_output.length is bigger than @ssh_output_length, we got new data
+  @ssh_output_length = 0
+
+  # Keep track of time for idle timeout
+  start_time = Time.now
+
+  # Loop & wait for @idle_timeout seconds after last output
+  # 0.1 means that the loop should run at least once per 0.1 second
+  @ssh.loop(0.1) do
+    # if @ssh_output is longer than our saved length, we got new output
+    if @ssh_output_length < @ssh_output.length
+      # reset the timer and save the new output length
+      start_time = Time.now
+      @ssh_output_length = @ssh_output.length
+    end
+
+    # We wait for 0.1 seconds if a key was pressed
+    begin
+      Timeout.timeout(0.1) do
+        # Get input // this is a blocking call
+        char = $stdin.getch
+        # If ctrl-c is pressed, exit the script
+        if char == "\u0003"
+          puts '### CTRL-C pressed, exiting'
+          cleanup
+          exit
+        end
+        # If escape is pressed, terminate idle timeout
+        if char == "\e"
+          puts "\n### ESC pressed, skipping idle timeout"
+          return false
+        else
+          # if not, record the char and send the char through ssh
+          puts "\n### #{char.dump} pressed"
+          yaml_output('    ')
+          @output&.puts "  #{@sequence_prepend_command}#{char.dump}: |-"
+          @ssh_output = ''
+          start_time = Time.now
+          @ssh_output_length = @ssh_output.length
+
+          @ses.send_data char
+        end
+      end
+    rescue Timeout::Error
+      # No key pressed
+    end
+
+    # exit the loop when the @idle_timeout has been reached (false = exit)
+    Time.now - start_time < @idle_timeout
+  end
+end
+
+def yaml_output(prepend = '')
+  # Now print the collected output to @output
+  firstline = true
+
+  prepend = @sequence_prepend_output + prepend
+
+  # each_line(chomp: true) would remove \r\n, so we prefer split
+  @ssh_output.split("\n", -1).each do |line|
+    # encode line and remove the first and the trailing double quote
+    line = line.dump[1..-2]
+    if firstline
+      # Make sure the leading space of the first line (if present)
+      # is coded with \0x20 or YAML block scalars won't work
+      line.sub!(/^\A /, '\x20')
+      firstline = false
+    end
+    # Make sure trailing white spaces are coded with \0x20
+    line.gsub!(/ $/, '\x20')
+    # prepend white spaces for the yaml block scalar
+    line = prepend + line
+    @output&.puts line
+  end
+end
+
+def cleanup
+  (@ssh.close rescue true) unless @ssh.closed? # rubocop:disable Style/RedundantParentheses
+  @output&.close
+end
+
+################# Main loop
+
+# Define options
+options = {}
+@sequence_prepend_command = '- '
+@sequence_prepend_output = '  '
+
+optparse = OptionParser.new do |opts|
+  opts.banner = <<~HEREDOC
+    Usages:
+    - device2yaml.rb [user@]host -i file [options]
+    - device2yaml.rb [user@]host -c "command1
+      command2
+      command3" [options]
+
+    -i and -c are mutualy exclusive, one must be specified
+
+    [options]:
+  HEREDOC
+
+  opts.on('-c', '--commands "command list"', 'specify the commands to be run') do |cmds|
+    options[:commands] = cmds
+  end
+  opts.on('-i', '--input file', 'Specify an input file for commands to be run') do |file|
+    options[:input] = file
+  end
+  opts.on('-o', '--output file', 'Specify an output YAML-file') do |file|
+    options[:output] = file
+  end
+  opts.on('-t', '--timeout value', Integer,
+          'Specify the idle timeout beween commands (default: 5 seconds)') do |timeout|
+    options[:timeout] = timeout
+  end
+  opts.on('-e', '--exec-mode', 'Run ssh in exec mode (without tty)') { @exec_mode = true }
+  opts.on('-u', '--unordered', 'The YAML simulation should not enforce an order of the commands') do
+    @sequence_prepend_command = ''
+    @sequence_prepend_output = ''
+  end
+  opts.on '-h', '--help', 'Print this help' do
+    puts opts
+    exit
+  end
+end
+
+# Catch and parse the first argument
+if ARGV[0] && ARGV[0][0] != '-'
+  argument = ARGV.shift
+  if argument.include?('@')
+    ssh_user, ssh_host = argument.split('@')
+  else
+    ssh_user = Etc.getlogin
+    ssh_host = argument
+  end
+else
+  puts 'Missing a host to connect to...'
+  puts
+  puts optparse
+  exit 1
+end
+
+# Parse the options
+optparse.parse!
+
+# Get the commands to be run against ssh_host
+# ^ = xor = exclusive or
+unless options[:commands].nil? ^ options[:input].nil?
+  puts "Please provide commands to be run against #{ssh_host} with either option -c or -i"
+  puts
+  puts optparse
+  exit 1
+end
+
+if options[:commands]
+  ssh_commands = []
+  options[:commands].each_line(chomp: true) { |command| ssh_commands << command }
+elsif options[:input]
+  ssh_commands = File.read(options[:input]).split(/\n+|\r+/)
+end
+
+puts "Running #{ssh_commands} on #{ssh_user}@#{ssh_host}"
+# Add \n to each command
+ssh_commands.map! { |s| s + "\n" }
+
+# Defaut idle timeout: 5 seconds, as tests showed that 2 seconds is too short
+@idle_timeout = options[:timeout] || 5
+
+# We will use safe navifation (&.) to call the methods on @output only
+# if @output is not nil
+@output = options[:output] ? File.open(options[:output], 'w') : nil
+
+@ssh = Net::SSH.start(ssh_host,
+                      ssh_user,
+                      { timeout:                         10,
+                        append_all_supported_algorithms: true })
+
+@ssh_output = ''
+
+unless @exec_mode
+  @ses = @ssh.open_channel do |ch|
+    ch.on_data do |_ch, data|
+      @ssh_output += data
+      # Output the data to stdout for interactive control
+      # remove ANSI escape codes, as they can produce problems
+      # The code will be printed as '\e[123m' in the output
+      print data.gsub("\e", '\e')
+    end
+    ch.request_pty(term: 'vt100') do |_ch, success_pty|
+      raise "Can't get PTY" unless success_pty
+
+      ch.send_channel_request 'shell' do |_ch, success_shell|
+        raise "Can't get shell" unless success_shell
+      end
+    end
+    ch.on_extended_data do |_ch, _type, data|
+      $stderr.print "Error: #{data}\n"
+    end
+  end
+end
+
+# YAML begin of file
+@output&.puts '---'
+
+if @exec_mode
+  # init prompt does not exist and is empty in exec mode
+  @output&.puts 'init_prompt:'
+else
+  # get motd and first prompt
+  @output&.puts 'init_prompt: |-'
+  shell_wait
+  yaml_output '  '
+end
+
+@output&.puts 'commands:'
+
+begin
+  ssh_commands.each do |cmd|
+    ssh_exec cmd
+  end
+rescue Errno::ECONNRESET, Net::SSH::Disconnect, IOError => e
+  puts "### Connection closed with message: #{e.message}"
+end
+
+cleanup

data/extra/gitdiff-msteams.sh

@@ -15,12 +15,31 @@
 #    timeout: 120
 #
 # Add webhook to your MS Teams channel and set the next variable to the full url
+# If INCLUDE_GITHUB_LINK is set to true, there will be a button that links to GITURL in the bottom of each teams post. the commit id is added at the end of the url.
+# MAXSIZE is set to respect the 28 KB limit for teams webhooks, but you might need to change it if you modify the Adaptive Card
 
 weburl="https://contoso.webhook.office.com/webhookb2/etc etc etc"
+GITURL="https://github.example.com/My-org/oxidized/commit/"
+INCLUDE_GITHUB_LINK=false
+# Max size for summary text.
+MAXSIZE=24500
+
+if [ "$INCLUDE_GITHUB_LINK" = true ]; then
+  github_action=",
+            { \"type\": \"ActionSet\",
+              \"actions\":
+               [
+                 {
+                 \"type\": \"Action.OpenUrl\",
+                 \"title\": \"Click to see diff in github\",
+                 \"url\": \"${GITURL}${OX_REPO_COMMITREF}\"
+                 }
+               ]
+             }"
+fi
 
 postdata()
 {
-    COMMIT=$(git --bare --git-dir="${OX_REPO_NAME}" show --pretty='' --no-color "${OX_REPO_COMMITREF}" | jq --raw-input --slurp --compact-output)
     cat <<EOF
 {
    "type":"message",
@@ -77,7 +96,7 @@ postdata()
                             "size": "small"
                         }
                     ]
-                }
+                }${github_action}
            ]
          }
       }
@@ -86,6 +105,14 @@ postdata()
 EOF
 }
 
-curl -i \
--H "Content-Type: application/json" \
--X POST --data "$(postdata)" "${weburl}"
+COMMIT=$(git --bare --git-dir="${OX_REPO_NAME}" show --pretty='' --no-color "${OX_REPO_COMMITREF}" | jq --raw-input --slurp --compact-output)
+URL=""
+
+size=$(postdata | wc -c)
+if [ "$size" -gt "$MAXSIZE" ]; then
+  COMMIT=$(git --bare --git-dir="${OX_REPO_NAME}" show --pretty='' --no-color "${OX_REPO_COMMITREF}" | head -c $MAXSIZE)
+  COMMIT+="$NEWLINE...$NEWLINE Shortened because of length"
+  COMMIT=$(echo "${COMMIT}" | jq --raw-input --slurp --compact-output )
+fi
+
+curl -i -H "Content-Type: application/json" -X POST --data "$(postdata)" "${weburl}"

data/extra/hooks/modelrules.rb

@@ -0,0 +1,55 @@
+### script in ~/config/oxidized/hook/modelrules.rb ## or OXDIZED_HOME equivalent
+###
+### router.db:
+### router1:1.1.1.1:routeros::mikrotik
+### router2:2.2.2.2:ios:switch:cisco
+### router3:3.3.3.3:routeros:switch:mikrotik
+###
+### config:
+### source:
+###   default: csv
+###   csv:
+###     file: "/Users/ytti/.config/oxidized/router.db"
+###     delimiter: !ruby/regexp /:/
+###     map:
+###       name: 0
+###       ip: 1
+###       model: 2
+###       group: 3
+### hooks:
+###   somename:
+###     type: modelrules
+###     events: ["source_node_transform"]
+###     rules:
+###        - vendor: mikrotik
+###          group: switch
+###          model: eltex
+###
+### Nodes BEFORE script:
+### {name: "router1", ip: "1.1.1.1", model: "routeros", group: ""}
+### {name: "router2", ip: "2.2.2.2", model: "ios", group: "switch"}
+### {name: "router3", ip: "3.3.3.3", model: "routeros", group: "switch"}
+###
+### Nodes AFTER script:
+### {name: "router1", ip: "1.1.1.1", model: "routeros", group: ""}
+### {name: "router2", ip: "2.2.2.2", model: "ios", group: "switch"}
+### {name: "router3", ip: "3.3.3.3", model: "eltex", group: "switch"}
+class ModelRules < Oxidized::Hook
+  def validate_cfg!
+    raise KeyError, 'hook.rules is required' unless cfg.has_key?('rules')
+  end
+
+  def run_hook(ctx)
+    # node is the node[key] that we'd return without manipulation
+    node = ctx.node ## e.g. node[:ip], node[:model] - what ever config maps
+
+    ## node_raw is source specific, in CSV it is just the field number, in HTTP it is JSON
+    vendor = ctx.node_raw[4]
+
+    cfg.rules.each do |rule|
+      node[:model] = rule['model'] if node[:group] == rule['group'] && vendor == rule['vendor']
+    end
+
+    node
+  end
+end

data/extra/hooks/modelrulesadvanced.rb

@@ -0,0 +1,167 @@
+# Advanced dynamic model selection hook for Oxidized
+# --------------------------------------------------
+# This hook allows you to assign Oxidized models based on any device attributes
+# (name, vendor, group, type, IP, etc.) using flexible rules defined in the config.
+# It uses the `source_node_transform` event and works with any source (CSV, HTTP, SQL).
+#
+# The hook is designed to be generic: you can specify any field that exists in the
+# node data after source mapping (see `map` section in the source configuration).
+# Rules are evaluated in order; the first matching rule assigns its `model`.
+#
+# ⚠️ IMPORTANT: For the hook to load correctly:
+#   - The filename must match the hook type (e.g., `modelrulesadvanced.rb`).
+#   - The class name must be the CamelCase version of the filename without underscores
+#     (e.g., filename `modelrulesadvanced.rb` → class `Modelrulesadvanced`).
+#   - In the Oxidized config, specify `type: modelrulesadvanced` (the filename without .rb).
+#
+# ⚠️ DOCKER NOTE: This hook was developed and tested in a Docker container.
+#   Ensure that your hooks directory inside the container is
+#   `/home/oxidized/.config/oxidized/hook` (singular "hook"), not "hooks".
+#   In docker-compose, mount your local hooks folder to this path, e.g.:
+#   volumes:
+#     - ./extra/hooks:/home/oxidized/.config/oxidized/hook
+#
+# Example scenario with NetBox:
+#   Suppose your NetBox instance returns devices with the following data (simplified):
+#     gw-001  | Mikrotik | RB750 | ro_ud  | 192.168.0.167/24
+#     gw-002  | Mikrotik | RB750 | ro_ud  | 192.168.0.177/24
+#     gw-003  | Mikrotik | RB750 | ro_bd  | 192.168.0.178/24
+#     gw-004  | Mikrotik | RB750 | switch | 192.168.0.181/24
+#     gw-005  | Cisco    | 2960  | switch | 192.168.0.179/24
+#     gw-006  | Mikrotik | RB750 | switch | 192.168.0.180/24
+#     gw-007  | Arista   | 3456  | ro_ud  | 192.168.0.190/24
+#
+#   Desired model assignment:
+#     - gw-001 (exception by name) → asa
+#     - MikroTik in group `switch` with IP 192.168.0.180/24 → eltex
+#     - All other MikroTik → routeros
+#     - Cisco switches → ios
+#     - Arista devices → eos
+#
+# Example configuration (top-level in Oxidized config):
+#   ---
+#   username: oxidized_ssh_user
+#   password: oxidized_ssh_password
+#
+#   hooks:
+#     modelrulesadvanced:
+#       type: modelrulesadvanced
+#       events: [source_node_transform]
+#       rules:
+#         - description: "Exception: gw-001 uses ASA model"
+#           name: gw-001
+#           model: asa
+#         - description: "Mikrotik switch with IP 192.168.0.180/24 uses eltex"
+#           vendor: Mikrotik
+#           group: switch
+#           ip: 192.168.0.180/24
+#           model: eltex
+#         - description: "All other Mikrotik devices"
+#           vendor: Mikrotik
+#           model: routeros
+#         - description: "Cisco switches"
+#           vendor: Cisco
+#           group: switch
+#           model: ios
+#         - description: "Arista devices"
+#           vendor: Arista
+#           model: eos
+#
+#   resolve_dns: false
+#   interval: 3600
+#   rest: 0.0.0.0:8888
+#   debug: true   # optional – enables detailed logging from the hook
+#
+#   source:
+#     default: http
+#     http:
+#       url: http://netbox.test/api/dcim/devices/?status=active&has_primary_ip=true
+#       headers:
+#         Authorization: Token YOUR_API_TOKEN
+#       map:
+#         name: name
+#         vendor: device_type.manufacturer.name
+#         type: device_type.model
+#         group: role.slug
+#         ip: primary_ip.address
+#       secure: false
+#       hosts_location: results
+#       pagination: true
+#       pagination_key_name: next
+#
+#   output:
+#     default: file
+#     file:
+#       directory: "/home/oxidized/.config/oxidized/configs"
+#
+#   groups:
+#     ro_ud: {}
+#     ro_bd: {}
+#     switch: {}
+#
+# How it works:
+#   1. Oxidized loads node data from the source (NetBox) and applies the `map`.
+#   2. For each node, the `source_node_transform` event is triggered.
+#   3. This hook receives a context object `ctx` containing:
+#        - `ctx.node` – the mapped node attributes (hash)
+#        - `ctx.node_raw` – the original source record (useful for unmapped fields)
+#   4. The hook iterates through the rules defined in `cfg.rules`.
+#   5. For each rule, it checks that every specified key (except `model` and `description`)
+#      matches the corresponding value in `ctx.node`. Comparison is case‑insensitive and
+#      strips surrounding spaces.
+#   6. The first matching rule assigns its `model` to `ctx.node[:model]`.
+#   7. If no rule matches, the node's `model` remains unchanged.
+#   8. The modified (or original) node is returned; returning `nil` would exclude the node.
+#
+# Notes:
+#   - Rule order is crucial: place more specific rules (e.g., with IP or name) before generic ones.
+#   - The `description` field is optional and only appears in debug logs.
+#   - Any field present in `ctx.node` after mapping can be used as a match key.
+#   - For HTTP sources (NetBox), you can access additional fields via `ctx.node_raw["field"]`.
+#   - Debug logging requires `debug: true` in the global config.
+
+class Modelrulesadvanced < Oxidized::Hook
+  # Validate that the hook configuration contains a 'rules' array.
+  def validate_cfg!
+    raise KeyError, "hook.rules is required" unless cfg.has_key?("rules")
+  end
+
+  # Main hook method – called for each node during source_node_transform event.
+  def run_hook(ctx)
+    node = ctx.node
+    rules = cfg.rules || []
+
+    matched_model = nil
+    rules.each_with_index do |rule, idx|
+      match = true
+      rule.each do |key, value|
+        next if %w[model description].include?(key)
+
+        # Retrieve the corresponding value from the node (symbol or string key)
+        node_value = node[key.to_sym] || node[key.to_s]
+        if node_value.to_s.strip.downcase != value.to_s.strip.downcase
+          match = false
+          break
+        end
+      end
+      next unless match
+
+      matched_model = rule["model"]
+      desc = rule["description"] ? " (#{rule['description']})" : ""
+      logger.debug "ModelRulesAdvanced: rule #{idx + 1}#{desc} matched -> #{matched_model}"
+      break
+    end
+
+    if matched_model
+      old_model = node[:model] || node["model"]
+      node[:model] = matched_model
+      logger.debug "ModelRulesAdvanced: changed model from #{old_model.inspect} to #{matched_model.inspect}"
+    else
+      # rubocop:disable Layout/LineLength
+      logger.debug "ModelRulesAdvanced: no rule matched, keeping existing model: #{node[:model] || node['model'].inspect}"
+      # rubocop:enable Layout/LineLength
+    end
+
+    node
+  end
+end

data/extra/hooks/srcipmap.rb

@@ -0,0 +1,54 @@
+### script in ~/config/oxidized/hook/srcipmap.rb ## or OXDIZED_HOME equivalent
+###
+### router.db:
+### router1:1.1.1.1:cisco:c7200:10.10.10.1:somerole
+### router2:2.2.2.2:juniper:mx80:10.10.10.2:wlc
+### router3:3.3.3.3:juniper:mx2020:10.10.10.3:anotherrole
+###
+### config:
+### source:
+###   default: csv
+###   csv:
+###    file: "/Users/ytti/.config/oxidized/router.db"
+###    delimiter: !ruby/regexp /:/
+###    map:
+###      name: 0
+###      ip: 1
+###      model: 2
+### model_map:
+###   juniper: junos
+###   cisco: ios
+### hooks:
+###   somename:
+###    type: srcipmap
+###    events: ["source_node_transform"]
+###
+###
+###
+### Nodes BEFORE script:
+### {name: "router1", ip: "1.1.1.1", model: "ios"}
+### {name: "router2", ip: "2.2.2.2", model: "junos"}
+### {name: "router3", ip: "3.3.3.3", model: "junos"
+###
+### Nodes AFTER script:
+### {name: "router1", ip: "1.1.1.1", model: "ios"}
+### {name: "router2", ip: "10.10.10.2", model: "junos"}
+### {name: "router3", ip: "3.3.3.3", model: "junos"}
+
+class SrcIpMap < Oxidized::Hook
+  def run_hook(ctx)
+    # node is the node[key] that we'd return without manipulation
+    node = ctx.node
+
+    ## node_raw is source specific, in CSV it is just the field number
+    _platform = ctx.node_raw[3]
+    oob_ip = ctx.node_raw[4]
+    role = ctx.node_raw[5]
+
+    ### the magic
+    node[:ip] = oob_ip if role == 'wlc'
+
+    ### remember to return the manipulated object, nil if you want to ignore loading node
+    node
+  end
+end

data/extra/nagios_check_failing_nodes.rb

@@ -10,7 +10,7 @@ pending = false
 critical_nodes = []
 pending_nodes = []
 
-json = JSON.parse(open("http://localhost:8888/nodes.json").read)
+json = JSON.parse(URI("http://localhost:8888/nodes.json").open(&:read))
 json.each do |node|
   next if !ARGV.empty? && (ARGV[0] != node['name'])
 

data/extra/oxidized.runit

@@ -2,4 +2,4 @@
 [ ! -d /home/oxidized/.config/oxidized ] && mkdir -p /home/oxidized/.config/oxidized
 [ -f /home/oxidized/.config/oxidized/pid ] && rm /home/oxidized/.config/oxidized/pid
 chown -R oxidized:oxidized /home/oxidized/.config/oxidized
-exec setuser oxidized oxidized
+exec gosu oxidized oxidized

data/extra/rest_client.rb

@@ -6,7 +6,7 @@ module Oxidized
     require 'asetus'
 
     class Config
-      Root = Root = ENV['OXIDIZED_HOME'] || File.join(Dir.home, '.config', 'oxidized')
+      ROOT = ENV['OXIDIZED_HOME'] || File.join(Dir.home, '.config', 'oxidized')
     end
 
     CFGS = Asetus.new name: 'oxidized', load: false, key_to_s: true
@@ -14,8 +14,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}"
     end
 
     restcfg = CFGS.cfg.rest
@@ -38,7 +38,8 @@ module Oxidized
 
     def next(opt)
       data = JSON.dump opt
-      @web.put PATH + '/node/next/' + opt[:name].to_s, data
+      headers = { 'content-type': 'application/json' }
+      @web.put PATH + '/node/next/' + opt[:name].to_s, data, headers
     end
   end
 end