oxidized 0.20.0 → 0.28.0

data/extra/syslog.rb

@@ -27,45 +27,46 @@ require 'resolv'
 require_relative 'rest_client'
 
 module Oxidized
-  
   require 'asetus'
   class Config
-    Root      = File.join ENV['HOME'], '.config', 'oxidized'
+    Root = File.join ENV['HOME'], '.config', 'oxidized'
   end
 
-  CFGS = Asetus.new :name=>'oxidized', :load=>false, :key_to_s=>true
+  CFGS = Asetus.new name: 'oxidized', load: false, key_to_s: true
   CFGS.default.syslogd.port        = 514
   CFGS.default.syslogd.file        = 'messages'
   CFGS.default.syslogd.resolve     = true
+  CFGS.default.syslogd.dns_map     = {
+    '(.*)\.strip\.this\.domain\.com' => '\\1',
+    '(.*)\.also\.this\.net'          => '\\1'
+  }
 
   begin
     CFGS.load
-  rescue => error
+  rescue StandardError => error
     raise InvalidConfig, "Error loading config: #{error.message}"
   ensure
-    CFG = CFGS.cfg  # convenienence, instead of Config.cfg.password, CFG.password
+    CFG = CFGS.cfg # convenienence, instead of Config.cfg.password, CFG.password
   end
 
   class SyslogMonitor
-    NAME_MAP = {
-      /(.*)\.ip\.tdc\.net/ => '\1',
-      /(.*)\.ip\.fi/       => '\1',
-    }
     MSG = {
-      :ios   => /%SYS-(SW[0-9]+-)?5-CONFIG_I:/,
-      :junos => 'UI_COMMIT:',
-      :eos   => /%SYS-5-CONFIG_I:/,
-      :nxos  => /%VSHD-5-VSHD_SYSLOG_CONFIG_I:/,
-    }
+      ios:   /%SYS-(SW[0-9]+-)?5-CONFIG_I:/,
+      junos: 'UI_COMMIT:',
+      eos:   /%SYS-5-CONFIG_I:/,
+      nxos:  /%VSHD-5-VSHD_SYSLOG_CONFIG_I:/,
+      aruba: 'Notice-Type=\'Running'
+    }.freeze
 
     class << self
-      def udp port=Oxidized::CFG.syslogd.port, listen=0
+      def udp(port = Oxidized::CFG.syslogd.port, listen = 0)
         io = UDPSocket.new
         io.bind listen, port
         new io, :udp
       end
-      def file syslog_file=Oxidized::CFG.syslogd.file
-        io = open syslog_file, 'r'
+
+      def file(syslog_file = Oxidized::CFG.syslogd.file)
+        io = File.open syslog_file, 'r'
         io.seek 0, IO::SEEK_END
         new io, :file
       end
@@ -73,43 +74,47 @@ module Oxidized
 
     private
 
-    def initialize io, mode=:udp
+    def initialize(io, mode = :udp)
       @mode = mode
       run io
     end
 
-    def rest opt
+    def rest(opt)
       Oxidized::RestClient.next opt
     end
 
-    def ios ip, log, i
+    def ios(log, index, **opts)
       # TODO: we need to fetch 'ip/name' in mode == :file here
-      user = log[i+5]
-      from = log[-1][1..-2]
-      rest( :user => user, :from => from, :model => 'ios', :ip => ip,
-            :name => getname(ip) )
+      opts[:user] = log[index + 5]
+      opts[:from] = log[-1][1..-2]
+      opts
     end
+    alias nxos ios
+    alias eos ios
 
-    def jnpr ip, log, i
+    def junos(log, index, **opts)
       # TODO: we need to fetch 'ip/name' in mode == :file here
-      user = log[i+2][1..-2]
-      msg  = log[(i+6)..-1].join(' ')[10..-2]
-      msg  = nil if msg == 'none'
-      rest( :user => user, :msg => msg, :model => 'jnpr', :ip => ip,
-            :name => getname(ip) )
+      opts[:user] = log[index + 2][1..-2]
+      opts[:msg] = log[(index + 6)..-1].join(' ')[10..-2]
+      opts.delete(:msg) if opts[:msg] == 'none'
+      opts
+    end
+
+    def aruba(log, index, **opts)
+      opts.merge user: log[index + 2].split('=')[4].split(',')[0][1..-2]
     end
 
-    def handle_log log, ip
+    def handle_log(log, ipaddr)
       log = log.to_s.split ' '
-      if i = log.find_index { |e| e.match( MSG[:ios] ) }
-        ios ip, log,  i
-      elsif i = log.index(MSG[:junos])
-        jnpr ip, log, i
+      index, vendor = MSG.find do |key, value|
+        index = log.find_index { |e| e.match value }
+        break index, key if index
       end
+      rest send(vendor, log, index, ip: ipaddr, name: getname(ipaddr), model: vendor.to_s) if index
     end
 
-    def run io
-      while true
+    def run(io)
+      loop do
         log = select [io]
         log, ip = log.first.first, nil
         if @mode == :udp
@@ -127,12 +132,12 @@ module Oxidized
       end
     end
 
-    def getname ip
+    def getname(ipaddr)
       if Oxidized::CFG.syslogd.resolve == false
-        ip
+        ipaddr
       else
-        name = (Resolv.getname ip.to_s rescue ip)
-        NAME_MAP.each { |re, sub| name.sub! re, sub }
+        name = (Resolv.getname ipaddr.to_s rescue ipaddr)
+        Oxidized::CFG.syslogd.dns_map.each { |re, sub| name.sub! Regexp.new(re.to_s), sub }
         name
       end
     end
@@ -140,4 +145,4 @@ module Oxidized
 end
 
 Oxidized::SyslogMonitor.udp
-#Oxidized::SyslogMonitor.file '/var/log/poop'
+# Oxidized::SyslogMonitor.file '/var/log/poop'

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,53 +41,62 @@ module Oxidized
     end
 
     def parse_opts
-      opts = Slop.new(:help=>true) do
-        on 'd', 'debug', 'turn on debugging'
-        on 'daemonize',  'Daemonize/fork the process'
-        on 'v', 'version', 'show version' do
-          puts Oxidized::VERSION
+      opts = Slop.parse do |opt|
+        opt.on '-d', '--debug', 'turn on debugging'
+        opt.on '--daemonize', 'Daemonize/fork the process'
+        opt.on '-h', '--help', 'show usage' do
+          puts opt
+          exit
+        end
+        opt.on '--show-exhaustive-config', 'output entire configuration, including defaults' do
+          asetus = Config.load
+          puts asetus.to_yaml asetus.cfg
+          Kernel.exit
+        end
+        opt.on '-v', '--version', 'show version' do
+          puts Oxidized::VERSION_FULL
           Kernel.exit
         end
       end
-      [opts.parse!, opts]
+      [opts.arguments, 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
     rescue Errno::ESRCH

data/lib/oxidized/config/vars.rb

@@ -1,19 +1,14 @@
 module Oxidized::Config::Vars
   # convenience method for accessing node, group or global level user variables
-  # nil values will be ignored
-  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
+  def vars(name)
+    if @node.vars&.has_key?(name)
+      @node.vars[name]
+    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(@node.model.class.name.to_s.downcase) && Oxidized.config.models[@node.model.class.name.to_s.downcase].vars.has_key?(name.to_s)
+      Oxidized.config.models[@node.model.class.name.to_s.downcase].vars[name.to_s]
+    elsif Oxidized.config.vars.has_key?(name.to_s)
+      Oxidized.config.vars[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
-    end
-    r ||= Oxidized.config.vars[name.to_s] if Oxidized.config.vars.has_key?(name.to_s)
-    r
   end
 end

data/lib/oxidized/config.rb

@@ -4,22 +4,23 @@ 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={})
+    def self.load(cmd_opts = {})
       asetus = Asetus.new(name: 'oxidized', load: false, key_to_s: true)
       Oxidized.asetus = asetus
 
       asetus.default.username      = 'username'
       asetus.default.password      = 'password'
       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
@@ -34,21 +35,27 @@ module Oxidized
       asetus.default.models        = {}               # model level configuration
       asetus.default.pid           = File.join(Oxidized::Config::Root, 'pid')
 
-      asetus.default.input.default    = 'ssh, telnet'
-      asetus.default.input.debug      = false # or String for session log file
-      asetus.default.input.ssh.secure = false # complain about changed certs
+      asetus.default.crash.directory = File.join(Oxidized::Config::Root, 'crashes')
+      asetus.default.crash.hostnames = false
+
+      asetus.default.stats.history_size = 10
+      asetus.default.input.default      = 'ssh, telnet'
+      asetus.default.input.debug        = false # or String for session log file
+      asetus.default.input.ssh.secure   = false # complain about changed certs
+      asetus.default.input.ftp.passive  = true  # ftp passive mode
+      asetus.default.input.utf8_encoded = true  # configuration is utf8 encoded or ascii-8bit
 
       asetus.default.output.default = 'file'  # file, git
       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/core.rb

@@ -1,6 +1,6 @@
 module Oxidized
   class << self
-    def new *args
+    def new(*args)
       Core.new args
     end
   end
@@ -8,12 +8,13 @@ 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
-      @worker      = Worker.new nodes
+      nodes = Nodes.new
+      raise NoNodesFound, 'source returns no usable nodes' if nodes.size.zero?
+
+      @worker = Worker.new nodes
       trap('HUP') { nodes.load }
       if Oxidized.config.rest?
         begin
@@ -22,7 +23,7 @@ module Oxidized
           raise OxidizedError, 'oxidized-web not found: sudo gem install oxidized-web - \
           or disable web support by setting "rest: false" in your configuration'
         end
-        @rest        = API::Web.new nodes, Oxidized.config.rest
+        @rest = API::Web.new nodes, Oxidized.config.rest
         @rest.run
       end
       run
@@ -32,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/awssns.rb

@@ -10,18 +10,17 @@ 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({
+    topic.publish(
       message: message.to_json
-    })
+    )
   end
-
 end

data/lib/oxidized/hook/ciscosparkdiff.rb

@@ -0,0 +1,43 @@
+require 'cisco_spark'
+
+# defaults to posting a diff, if messageformat is supplied them a message will be posted too
+# diff defaults to true
+# Modified from slackdiff
+
+class CiscoSparkDiff < Oxidized::Hook
+  def validate_cfg!
+    raise KeyError, 'hook.accesskey is required' unless cfg.has_key?('accesskey')
+    raise KeyError, 'hook.space is required' unless cfg.has_key?('space')
+  end
+
+  def run_hook(ctx)
+    return unless ctx.node
+    return unless ctx.event.to_s == "post_store"
+
+    log "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"
+
+    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)
+    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}"
+      room.send_message CiscoSpark::Message.new(text: msg)
+    end
+
+    log "Finished"
+  end
+end

data/lib/oxidized/hook/exec.rb

@@ -12,40 +12,37 @@ 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
       raise "invalid cmd value" unless @cmd.is_a?(String) || @cmd.is_a?(Array)
     end
-
   rescue RuntimeError => e
     raise ArgumentError,
-      "#{self.class.name}: configuration invalid: #{e.message}"
+          "#{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}"
@@ -53,34 +50,32 @@ class Exec < Oxidized::Hook
         raise msg
       end
     end
-  rescue TimeoutError
+  rescue Timeout::Error
     kill "TERM", pid
     msg = "#{@cmd} timed out"
     log msg, :error
-    raise TimeoutError, msg
+    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_EVENT" => ctx.event.to_s,
+        "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,8 +18,8 @@ class GithubRepo < Oxidized::Hook
     result = repo.fetch('origin', [repo.head.name], credentials: credentials)
     log result.inspect, :debug
 
-    unless result[:total_deltas] > 0
-      log "nothing recieved after fetch", :debug
+    unless result[:total_deltas].positive?
+      log "nothing received after fetch", :debug
       return
     end
 
@@ -34,27 +34,27 @@ 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
-    @credentials ||= if cfg.has_key?('username') && cfg.has_key?('password')
-      log "Using https auth", :debug
-      Rugged::Credentials::UserPassword.new(username: cfg.username, password: cfg.password)
-    else
-      if cfg.has_key?('publickey') && cfg.has_key?('privatekey')
-        log "Using ssh auth with key", :debug
-        Rugged::Credentials::SshKey.new(username: 'git', publickey: File.expand_path(cfg.publickey), privatekey: File.expand_path(cfg.privatekey))
+    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)
+      elsif cfg.has_key?('publickey') && cfg.has_key?('privatekey')
+        log "Authenticating using ssh keys as '#{git_user}'", :debug
+        Rugged::Credentials::SshKey.new(username: git_user, publickey: File.expand_path(cfg.publickey), privatekey: File.expand_path(cfg.privatekey), passphrase: ENV["OXIDIZED_SSH_PASSPHRASE"])
       else
-        log "Using ssh auth with agentforwarding", :debug
-        Rugged::Credentials::SshKeyFromAgent.new(username: 'git')
+        log "Authenticating using ssh agent as '#{git_user}'", :debug
+        Rugged::Credentials::SshKeyFromAgent.new(username: git_user)
       end
     end
   end

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