oxidized 0.29.1 → 0.37.0

data/lib/oxidized/model/vyos.rb

@@ -0,0 +1,37 @@
+class Vyos < Oxidized::Model
+  using Refinements
+
+  # VyOS model #
+  # Vyos is a Fork of Vyatta and is being actively developed.
+  # https://vyos.org/
+
+  prompt /^\S+@\S+(:~\$|>) $/
+  clean :escape_codes
+
+  cmd :all do |cfg|
+    cfg.lines.to_a[1..-2].join
+  end
+
+  cmd :secret do |cfg|
+    cfg.gsub! /secret (\S+).*/, 'secret <secret removed>'
+    cfg.gsub! /password (\S+).*/, 'password <secret removed>'
+    cfg.gsub! /snmp community (\S+)/, 'snmp community <secret removed>'
+    cfg.gsub! /snmp trap-target ([^\s\\]*) community (\S+)/, 'snmp trap-target \1 community <secret removed>'
+    cfg.gsub! /preshared-key (\S+).*/, 'preshared-key <secret removed>'
+    cfg.gsub! /private key (\S+).*/, 'private key <secret removed>'
+    cfg.gsub! /private-key (\S+).*/, 'private-key <secret removed>'
+    # password in URLs like protocol://user:password@domain.tld/
+    cfg.gsub! /([a-z]+:\/\/[^:\s]+:)\S+@/, '\1<secret removed>@'
+    cfg
+  end
+
+  cmd 'show version' do |cfg|
+    comment cfg
+  end
+
+  cmd 'show configuration commands | no-more'
+
+  cfg :ssh do
+    pre_logout 'exit'
+  end
+end

data/lib/oxidized/model/xos.rb

@@ -12,6 +12,13 @@ class XOS < Oxidized::Model
     cfg.each_line.to_a[1..-2].map { |line| line.delete("\r").rstrip }.join("\n") + "\n"
   end
 
+  cmd :secret do |cfg|
+    cfg.gsub! /^(configure (radius|radius-accounting) (netlogin|mgmt-access) (primary|secondary) shared-secret encrypted).+/, '\\1 <secret hidden>'
+    cfg.gsub! /^(configure account admin encrypted).+/, '\\1 <secret hidden>'
+    cfg.gsub! /^(create account (admin|user) (.+) encrypted).+/, '\\1 <secret hidden>'
+    cfg
+  end
+
   cmd 'show version' do |cfg|
     comment cfg
   end
@@ -26,7 +33,9 @@ class XOS < Oxidized::Model
 
   cmd 'show switch' do |cfg|
     cfg.gsub! /Next periodic save on.*/, ''
-    comment cfg.each_line.reject { |line| line.match(/Time:/) || line.match(/boot/i) || line.match(/Next periodic/) }.join
+    comment cfg.each_line.reject { |line|
+      line.match(/Time:/) || line.match(/boot/i) || line.match(/Next periodic/)
+    }.join
   end
 
   cmd 'show configuration' do |cfg|

data/lib/oxidized/model/zhoneolt.rb

@@ -5,7 +5,7 @@ class ZhoneOLT < Oxidized::Model
 
   # the prompt can be anything on zhone, but it defaults to 'zXX>' and we
   # always use hostname>
-  prompt /^(\r*[\w.@():-]+[>]\s?)$/
+  prompt /^(\r*[\w.@():-]+>\s?)$/
   comment '# '
 
   cmd :secret do |cfg|
@@ -36,7 +36,9 @@ class ZhoneOLT < Oxidized::Model
   end
 
   cmd 'ethrpshow' do |cfg|
-    cfg = cfg.each_line.select { |line| line.match /Vendor (Name|OUI|Part|Revision)|Serial Number|Manufacturing Date/ }.join
+    cfg = cfg.each_line.select do |line|
+      line.match /Vendor (Name|OUI|Part|Revision)|Serial Number|Manufacturing Date/
+    end.join
     comment cfg
   end
 

data/lib/oxidized/model/zynos.rb

@@ -1,12 +1,76 @@
 class ZyNOS < Oxidized::Model
   using Refinements
 
-  # Used in Zyxel DSLAMs, such as SAM1316
+  prompt /^([\w.@()\-<]+[#>]\s?)$/
+  # if there is something you can not identify after prompt, uncomment next line and comment previous line
+  # prompt /^([\w.@()\-<]+[#>]\s?).*$/
 
   comment '! '
 
-  cmd 'config-0'
+  # Used in Zyxel DSLAMs, such as SAM1316. Uncomment next line to enable ftp.
+  # cmd 'config-0'
 
-  cfg :ftp do
+  # replace next line control sequence with a new line
+  expect /(\e\[1M\e\[\??\d+(;\d+)*[A-Za-z]\e\[1L)|(\eE)/ do |data, re|
+    data.gsub re, "\n"
+  end
+
+  # replace all used vt100 control sequences
+  expect /\e\[\??\d+(;\d+)*[A-Za-z]/ do |data, re|
+    data.gsub re, ''
+  end
+
+  # ignore copyright motd
+  expect /^(Copyright .*)\n^([\w.@()\-<]+[#>]\s?)$/ do
+    send '\n'
+    ""
+  end
+
+  cmd :all do |cfg|
+    cfg = cfg.gsub /^\r/, ''
+    # Additional filtering for elder switches sending vt100 control chars via telnet
+    cfg.gsub! /\e\[\??\d+(;\d+)*[A-Za-z]/, ''
+    cfg
+  end
+
+  # remove snmp community, username, password and admin-password
+  cmd :secret do |cfg|
+    cfg.gsub! /^(snmp-server get-community) \S+(.*)/, '\\1 <secret hidden> \\2'
+    cfg.gsub! /^(snmp-server set-community) \S+(.*)/, '\\1 <secret hidden> \\2'
+    cfg.gsub! /^(logins username) \S+(.*) (password) \S+(.*)/, '\\1 <secret hidden> \\2 \\3 <secret hidden> \\4'
+    cfg.gsub! /^(admin-password) \S+(.*)/, '\\1 <secret hidden> \\2'
+    cfg.gsub! /^(password) \S+(.*) (privilege \S+)/, '\\1 <secret hidden> \\2 \\3'
+    cfg
+  end
+
+  cmd 'show version' do |cfg|
+    comment cfg
+  end
+
+  cmd 'show system-information' do |cfg|
+    cfg.gsub! /^([Ss]ystem up [Tt]ime\s*:)(.*)/, '\\1 <time removed>'
+    comment cfg
+  end
+
+  cmd 'show running-config' do |cfg|
+    cfg = cfg.split("\n")[4..-2].join("\n")
+    cfg
+  end
+
+  cfg :telnet do
+    username /^User name:/i
+    password /^Password:/i
+  end
+
+  cfg :telnet, :ssh do
+    post_login do
+      if vars(:enable) == true
+        cmd "enable"
+      elsif vars(:enable)
+        cmd "enable", /^[pP]assword:/
+        cmd vars(:enable)
+      end
+    end
+    pre_logout 'exit'
   end
 end

data/lib/oxidized/model/zynosadsl.rb

@@ -0,0 +1,14 @@
+class ZyNOSADSL < Oxidized::Model
+  using Refinements
+
+  # Used in Zyxel ADSL, such as AAM1212-51
+
+  prompt /^.*>\s?$/
+  comment ';; '
+
+  cmd 'config show all nopause'
+
+  cfg :telnet do
+    password /^Password:/i
+  end
+end

data/lib/oxidized/model/zynoscli.rb

@@ -30,7 +30,7 @@ class ZyNOSCLI < Oxidized::Model
           expect /[pP]assword:\s?$/
           send vars(:enable) + "\n"
         end
-        expect /^.+[#]$/
+        expect /^.+\#$/
       end
     end
     pre_logout 'exit'

data/lib/oxidized/model/zynosgs.rb

@@ -18,6 +18,8 @@ class ZyNOSGS < Oxidized::Model
     # Remove garbage vt100 control sequences
     # Backspace 0x07 char or escape char + control chars
     cfg.gsub! /[\b]|\e\[A|\e\[2K/, ''
+    # Remove empty lines
+    cfg.gsub! "\n\n", "\n"
     cfg
   end
 

data/lib/oxidized/model/zynosmgs.rb

@@ -0,0 +1,32 @@
+class ZyNOSMGS < Oxidized::Model
+  using Refinements
+
+  PROMPT = /^(\w.*)>(.*)?$/
+  # Used in Zyxel MGS Series switches
+
+  prompt PROMPT
+  comment '! '
+
+  cmd 'show version' do |cfg|
+    clear_output cfg
+  end
+
+  cmd 'show running-config' do |cfg|
+    clear_output cfg
+  end
+
+  cfg :telnet do
+    username /^User\s?name(\(1-32 chars\))?:/i
+    password /^Password(\(1-32 chars\))?:/i
+  end
+
+  cfg :telnet, :ssh do
+    pre_logout 'exit'
+  end
+
+  private
+
+  def clear_output(output)
+    output.gsub PROMPT, ''
+  end
+end

data/lib/oxidized/node.rb

@@ -1,20 +1,23 @@
 module Oxidized
   require 'resolv'
-  require 'ostruct'
   require_relative 'node/stats'
   class MethodNotFound < OxidizedError; end
   class ModelNotFound  < OxidizedError; end
 
   class Node
-    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
+    include SemanticLogger::Loggable
+
+    attr_reader :name, :ip, :model, :input, :output, :group, :auth, :prompt, :timeout, :vars, :last, :repo
+    attr_accessor :running, :user, :email, :msg, :from, :stats, :retry, :err_type, :err_reason, :nexted
     alias running? running
+    alias nexted? nexted
 
+    # 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?
@@ -25,47 +28,52 @@ module Oxidized
       @output = resolve_output opt
       @auth = resolve_auth opt
       @prompt = resolve_prompt opt
-      @vars = opt[:vars]
+      @timeout = resolve_timeout opt
+      @vars = opt[:vars] || {}
       @stats = Stats.new
       @retry = 0
       @repo = resolve_repo opt
       @err_type = nil
       @err_reason = nil
+      @nexted = false
 
       # model instance needs to access node instance
       @model.node = self
     end
 
     def run
-      status, config = :fail, 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
-        next unless @model.cfg[cfg_name] && (not @model.cfg[cfg_name].empty?)
-
-        @model.input = input = input.new
-        if (config = run_input(input))
-          Oxidized.logger.debug "lib/oxidized/node.rb: #{input.class.name} ran for #{name} successfully"
-          status = :success
-          break
+      status = :fail
+      config = Oxidized::Model::Outputs.new
+      input_sequence = @model.class.input_sequence(@input)
+
+      input_sequence.each do |sequence|
+        status = :fail
+        sequence_config = nil
+        sequence.each do |input|
+          @model.input = input = input.new
+          if (sequence_config = run_input(input))
+            logger.debug "#{input.class.name} ran for #{name} successfully"
+            status = :success
+            break
+          else
+            logger.debug "#{input.class.name} failed for #{name}"
+            status = :no_connection
+          end
+        end
+        if status == :success
+          config.merge! sequence_config
         else
-          Oxidized.logger.debug "lib/oxidized/node.rb: #{input.class.name} failed for #{name}"
-          status = :no_connection
+          config = nil
+          break
         end
       end
+
       @model.input = nil
       [status, config]
     end
 
     def run_input(input)
-      rescue_fail = {}
-      [input.class::RescueFail, input.class.superclass::RescueFail].each do |hash|
-        hash.each do |level, errors|
-          errors.each do |err|
-            rescue_fail[err] = level
-          end
-        end
-      end
+      rescue_fail = input.class.rescue_fail
       begin
         input.connect(self) && input.get
       rescue *rescue_fail.keys => err
@@ -75,24 +83,31 @@ 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 => err
+      rescue StandardError => e
+        # Send a message in debug mode in case we are not able to create a crashfile
+        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)
 
         File.open File.join(crashdir, crashfile), 'w' do |fh|
           fh.puts Time.now.utc
-          fh.puts err.message + ' [' + err.class.to_s + ']'
+          fh.puts e.message + ' [' + e.class.to_s + ']'
           fh.puts '-' * 50
-          fh.puts err.backtrace
+          fh.puts e.backtrace
         end
-        Oxidized.logger.error '%s raised %s with msg "%s", %s saved' % [ip, err.class, err.message, crashfile]
-        @err_type = err.class.to_s
-        @err_reason = err.message.to_s
+        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
       end
     end
@@ -120,14 +135,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
@@ -148,6 +159,10 @@ module Oxidized
       opt[:prompt] || @model.prompt || Oxidized.config.prompt
     end
 
+    def resolve_timeout(opt)
+      resolve_key :timeout, opt, Oxidized.config.timeout
+    end
+
     def resolve_auth(opt)
       # Resolve configured username/password
       {
@@ -158,8 +173,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
@@ -167,7 +185,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
@@ -175,7 +196,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
@@ -198,33 +219,47 @@ module Oxidized
     end
 
     def resolve_key(key, opt, global = nil)
-      # resolve key, first get global, then get group then get node config
+      # 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
-      value   = global
-      Oxidized.logger.debug "node.rb: resolving node key '#{key}', with passed global value of '#{value}' and node value '#{opt[key_sym]}'"
+      model_name = @model.class.name.to_s.downcase
+      logger.debug "resolving node key '#{key}', with passed global value of '#{global}' " \
+                   "and node value '#{opt[key_sym]}'"
 
-      # global
-      if (not value) && 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"
-      end
+      # Node
+      if opt[key_sym]
+        value = opt[key_sym]
+        logger.debug "setting node key '#{key}' to value '#{value}' from node"
 
-      # group
-      if Oxidized.config.groups.has_key?(@group) && Oxidized.config.groups[@group].has_key?(key_str)
+      # 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)
+        value = Oxidized.config.groups[@group].models[model_name][key_str]
+        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"
-      end
+        logger.debug "setting node key '#{key}' to value '#{value}' from group"
 
-      # model
-      if Oxidized.config.models.has_key?(@model.class.name.to_s.downcase) && Oxidized.config.models[@model.class.name.to_s.downcase].has_key?(key_str)
-        value = Oxidized.config.models[@model.class.name.to_s.downcase][key_str]
-        Oxidized.logger.debug "node.rb: setting node key '#{key}' to value '#{value}' from model"
-      end
+      # 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]
+        logger.debug "setting node key '#{key}' to value '#{value}' from model"
 
-      # node
-      value = opt[key_sym] || value
-      Oxidized.logger.debug "node.rb: returning node key '#{key}' with value '#{value}'"
+      # Global passed
+      elsif global
+        value = global
+        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]
+        logger.debug "setting node key '#{key}' to value '#{value}' from global"
+      end
       value
     end
 

data/lib/oxidized/nodes.rb

@@ -1,10 +1,12 @@
 module Oxidized
   require 'ipaddr'
   require 'oxidized/node'
-  class Oxidized::NotSupported < OxidizedError; end
-  class Oxidized::NodeNotFound < OxidizedError; end
+  class NotSupported < OxidizedError; end
+  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
@@ -21,22 +23,25 @@ module Oxidized
           begin
             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]
+          rescue ModelNotFound => e
+            logger.error "node %s raised %s with message '%s'" % [node, e.class, e.message]
+          rescue Resolv::ResolvError => e
+            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
 
     def node_want?(node_want, node)
       return true unless node_want
 
+      # rubocop:disable Style/RedundantParentheses
       node_want_ip = (IPAddr.new(node_want) rescue false)
       name_is_ip   = (IPAddr.new(node[:name]) rescue false)
+      # rubocop:enable Style/RedundantParentheses
       # rubocop:todo Lint/DuplicateBranch
       if name_is_ip && (node_want_ip == node[:name])
         true
@@ -61,6 +66,9 @@ module Oxidized
       end
     end
 
+    # Returns the configuration of group/node_name
+    #
+    # #fetch is called by oxidzed-web
     def fetch(node_name, group)
       yield_node_output(node_name) do |node, output|
         output.fetch node, group
@@ -69,8 +77,9 @@ module Oxidized
 
     # @param node [String] name of the node moved into the head of array
     def next(node, opt = {})
-      return unless waiting.find_node_index(node)
+      return if running.find_index(node)
 
+      logger.info "Add node #{node} to running jobs"
       with_lock do
         n = del node
         n.user = opt['user']
@@ -79,8 +88,10 @@ module Oxidized
         n.from = opt['from']
         # set last job to nil so that the node is picked for immediate update
         n.last = nil
+        # set nexted to true so that the node will not be skipped with interval 0
+        n.nexted = true
         put n
-        jobs.want += 1 if Oxidized.config.next_adds_job?
+        jobs.increment if Oxidized.config.next_adds_job?
       end
     end
     alias top next
@@ -95,9 +106,12 @@ 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) || raise(Oxidized::NodeNotFound, "unable to find '#{node}'")
+      find_index(node) || raise(NodeNotFound, "unable to find '#{node}'")
     end
 
+    # Returns all stored versions of group/node_name
+    #
+    # Called by oxidized-web
     def version(node_name, group)
       yield_node_output(node_name) do |node, output|
         output.version node, group
@@ -116,6 +130,10 @@ module Oxidized
       end
     end
 
+    def find_index(node)
+      index { |e| [e.name, e.ip].include? node }
+    end
+
     private
 
     def initialize(opts = {})
@@ -129,12 +147,8 @@ module Oxidized
       end
     end
 
-    def with_lock(&block)
-      @mutex.synchronize(&block)
-    end
-
-    def find_index(node)
-      index { |e| [e.name, e.ip].include? node }
+    def with_lock(...)
+      @mutex.synchronize(...)
     end
 
     # @param node node which is removed from nodes list
@@ -160,13 +174,18 @@ module Oxidized
     # @param [Array] nodes Array of nodes used to replace+update old
     def update_nodes(nodes)
       old = dup
+      # load the Array "nodes" in self (the class Nodes inherits Array)
       replace(nodes)
       each do |node|
         if (i = old.find_node_index(node.name))
           node.stats = old[i].stats
           node.last  = old[i].last
         end
-      rescue Oxidized::NodeNotFound
+      rescue NodeNotFound
+        # Do nothing:
+        # when a node is not found, we have nothing to do:
+        # it has already been loaded by replace(nodes) and there are no
+        # stats to copy
       end
       sort_by! { |x| x.last.nil? ? Time.new(0) : x.last.end }
     end
@@ -174,8 +193,10 @@ module Oxidized
     def yield_node_output(node_name)
       with_lock do
         node = find { |n| n.name == node_name }
+        raise(NodeNotFound, "unable to find '#{node_name}'") if node.nil?
+
         output = node.output.new
-        raise Oxidized::NotSupported unless output.respond_to? :fetch
+        raise NotSupported unless output.respond_to? :fetch
 
         yield node, output
       end