├── .ruby-version
├── Gemfile
├── extra
    ├── oxidized.runit
    ├── oxidized.supervisord
    ├── auto-reload-config.runit
    ├── oxidized.service
    ├── oxidized.upstart
    ├── oxidized.nginx
    ├── rvm.oxidized.upstart
    ├── oxidized.apache2
    ├── nagios_check_failing_nodes.rb
    ├── rest_client.rb
    ├── oxidized.init.d
    ├── oxidized.init
    ├── oxidized-report-git-commits
    └── syslog.rb
├── lib
    ├── oxidized
    │   ├── version.rb
    │   ├── model
    │   │   ├── zynos.rb
    │   │   ├── apc_aos.rb
    │   │   ├── alvarion.rb
    │   │   ├── netonix.rb
    │   │   ├── netscaler.rb
    │   │   ├── airos.rb
    │   │   ├── pfsense.rb
    │   │   ├── corianttmos.rb
    │   │   ├── opengear.rb
    │   │   ├── edgeos.rb
    │   │   ├── firewareos.rb
    │   │   ├── saos.rb
    │   │   ├── vyatta.rb
    │   │   ├── coriant8600.rb
    │   │   ├── fiberdriver.rb
    │   │   ├── routeros.rb
    │   │   ├── fabricos.rb
    │   │   ├── vrp.rb
    │   │   ├── datacom.rb
    │   │   ├── edgeswitch.rb
    │   │   ├── aos.rb
    │   │   ├── quantaos.rb
    │   │   ├── outputs.rb
    │   │   ├── isam.rb
    │   │   ├── panos.rb
    │   │   ├── mtrlrfs.rb
    │   │   ├── dlink.rb
    │   │   ├── supermicro.rb
    │   │   ├── fujitsupy.rb
    │   │   ├── nos.rb
    │   │   ├── nxos.rb
    │   │   ├── ftos.rb
    │   │   ├── catos.rb
    │   │   ├── dnos.rb
    │   │   ├── xos.rb
    │   │   ├── mlnxos.rb
    │   │   ├── iosxr.rb
    │   │   ├── masteros.rb
    │   │   ├── screenos.rb
    │   │   ├── cx.rb
    │   │   ├── br6910.rb
    │   │   ├── eos.rb
    │   │   ├── casa.rb
    │   │   ├── gaiaos.rb
    │   │   ├── aireos.rb
    │   │   ├── junos.rb
    │   │   ├── c4cmts.rb
    │   │   ├── hatteras.rb
    │   │   ├── ciscosmb.rb
    │   │   ├── aos7.rb
    │   │   ├── tplink.rb
    │   │   ├── comware.rb
    │   │   ├── zhoneolt.rb
    │   │   ├── hpebladesystem.rb
    │   │   ├── fortios.rb
    │   │   ├── tmos.rb
    │   │   ├── procurve.rb
    │   │   ├── powerconnect.rb
    │   │   ├── cumulus.rb
    │   │   ├── asa.rb
    │   │   ├── ipos.rb
    │   │   ├── trango.rb
    │   │   ├── ios.rb
    │   │   ├── planet.rb
    │   │   ├── ironware.rb
    │   │   ├── timos.rb
    │   │   ├── acos.rb
    │   │   ├── aosw.rb
    │   │   └── model.rb
    │   ├── hook
    │   │   ├── noophook.rb
    │   │   ├── awssns.rb
    │   │   ├── slackdiff.rb
    │   │   ├── exec.rb
    │   │   └── githubrepo.rb
    │   ├── output
    │   │   ├── output.rb
    │   │   ├── file.rb
    │   │   ├── http.rb
    │   │   └── git.rb
    │   ├── input
    │   │   ├── input.rb
    │   │   ├── tftp.rb
    │   │   ├── ftp.rb
    │   │   ├── cli.rb
    │   │   ├── ssh.rb
    │   │   └── telnet.rb
    │   ├── source
    │   │   ├── source.rb
    │   │   ├── csv.rb
    │   │   ├── sql.rb
    │   │   └── http.rb
    │   ├── config
    │   │   └── vars.rb
    │   ├── job.rb
    │   ├── string.rb
    │   ├── node
    │   │   └── stats.rb
    │   ├── core.rb
    │   ├── jobs.rb
    │   ├── manager.rb
    │   ├── hook.rb
    │   ├── cli.rb
    │   ├── config.rb
    │   ├── worker.rb
    │   ├── nodes.rb
    │   └── node.rb
    └── oxidized.rb
├── .travis.yml
├── bin
    ├── console
    └── oxidized
├── spec
    ├── spec_helper.rb
    ├── cli_spec.rb
    ├── input
    │   └── ssh_spec.rb
    ├── nodes_spec.rb
    ├── node_spec.rb
    └── githubrepo_spec.rb
├── Gemfile.lock
├── Dockerfile
├── Rakefile
├── TODO.md
├── .gitignore
├── oxidized.gemspec
└── CHANGELOG.md


/.ruby-version:
--------------------------------------------------------------------------------
1 | 2.1.8
2 | 


--------------------------------------------------------------------------------
/Gemfile:
--------------------------------------------------------------------------------
1 | source 'https://rubygems.org'
2 | gemspec
3 | 


--------------------------------------------------------------------------------
/extra/oxidized.runit:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 | exec setuser root oxidized
3 | 


--------------------------------------------------------------------------------
/lib/oxidized/version.rb:
--------------------------------------------------------------------------------
1 | module Oxidized
2 |   VERSION = '0.19.0'
3 | end
4 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
1 | language: ruby
2 | sudo: false
3 | cache: bundler
4 | rvm:
5 |   - 2.1.6
6 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/zynos.rb:
--------------------------------------------------------------------------------
 1 | class ZyNOS < Oxidized::Model
 2 | 
 3 |   # Used in Zyxel DSLAMs, such as SAM1316
 4 | 
 5 |   comment  '! '
 6 | 
 7 |   cmd 'config-0'
 8 | 
 9 |   cfg :ftp do
10 |   end
11 | 
12 | end
13 | 


--------------------------------------------------------------------------------
/bin/console:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env ruby
 2 | 
 3 | lib = File.expand_path('../../lib', __FILE__)
 4 | $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 5 | 
 6 | require 'oxidized'
 7 | require 'pry'
 8 | 
 9 | Pry.start
10 | 


--------------------------------------------------------------------------------
/lib/oxidized/hook/noophook.rb:
--------------------------------------------------------------------------------
 1 | class NoopHook < Oxidized::Hook
 2 |   def validate_cfg!
 3 |     log "Validate config"
 4 |   end
 5 | 
 6 |   def run_hook ctx
 7 |     log "Run hook with context: #{ctx}"
 8 |   end
 9 | end
10 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/apc_aos.rb:
--------------------------------------------------------------------------------
 1 | class Apc_aos < Oxidized::Model
 2 | 
 3 |   cmd 'config.ini' do |cfg|
 4 |     cfg.gsub! /^; Configuration file\, generated on.*/, ''
 5 |   end
 6 | 
 7 |   cfg :ftp do
 8 |   end
 9 | 
10 | end
11 | 
12 | 


--------------------------------------------------------------------------------
/lib/oxidized/output/output.rb:
--------------------------------------------------------------------------------
 1 | module Oxidized
 2 |   class Output
 3 |     class NoConfig < OxidizedError; end
 4 | 
 5 |     def cfg_to_str cfg
 6 |       cfg.select{ |h| h[:type]=='cfg' }.map{ |h| h[:data] }.join
 7 |     end
 8 | 
 9 |   end
10 | end
11 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/alvarion.rb:
--------------------------------------------------------------------------------
 1 | class Alvarion < Oxidized::Model
 2 | 
 3 |   # Used in Alvarion wisp equipment
 4 | 
 5 |   # Run this command as an instance of Model so we can access node
 6 |   pre do
 7 |     cmd "#{node.auth[:password]}.cfg"
 8 |   end
 9 | 
10 | 
11 |   cfg :tftp {}
12 | 
13 | end
14 | 


--------------------------------------------------------------------------------
/extra/oxidized.supervisord:
--------------------------------------------------------------------------------
 1 | # by @MrRJ45 at issues #45
 2 | 
 3 | [program:oxidized]
 4 | command=/usr/local/bin/oxidized
 5 | autostart=true
 6 | autorestart=true
 7 | user=oxidized
 8 | stderr_logfile=/var/log/oxidized.err.log
 9 | stdout_logfile=/var/log/oxidized.out.log
10 | environment=HOME='/home/oxidized/'
11 | 


--------------------------------------------------------------------------------
/extra/auto-reload-config.runit:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | if [ -z "$CONFIG_RELOAD_INTERVAL" ]; then
 4 |     # Just stop and do nothing
 5 |     read
 6 | fi
 7 | 
 8 | while true; do
 9 |     sleep $CONFIG_RELOAD_INTERVAL
10 |     echo "Reloading config..."
11 |     curl -s http://localhost:8888/reload?format=json -O /dev/null
12 | done
13 | 


--------------------------------------------------------------------------------
/extra/oxidized.service:
--------------------------------------------------------------------------------
 1 | #For debian 8 put it in /lib/systemd/system/
 2 | #and call it with systemctl start oxidized.service
 3 | 
 4 | [Unit]
 5 | Description=Oxidized - Network Device Configuration Backup Tool
 6 | 
 7 | [Service]
 8 | ExecStart=/usr/local/bin/oxidized
 9 | User=oxidized
10 | 
11 | [Install]
12 | WantedBy=multi-user.target
13 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/netonix.rb:
--------------------------------------------------------------------------------
 1 | class Netonix < Oxidized::Model
 2 |   prompt /^[\w\s.@_\/:-]+#/
 3 | 
 4 |   cmd :all do |cfg|
 5 |     cfg.each_line.to_a[1..-2].join
 6 |   end
 7 | 
 8 |   cmd 'cat config.json;echo'
 9 | 
10 |   cfg :ssh do
11 |     post_login 'cmdline'
12 |     pre_logout 'exit'
13 |     pre_logout 'exit'
14 |   end
15 | end
16 | 


--------------------------------------------------------------------------------
/bin/oxidized:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env ruby
 2 | 
 3 | 
 4 | # FIX ME, killing oxidized needs -9
 5 | trap("INT") { exit } # sinatra will otherwise steal this from us
 6 | 
 7 | begin
 8 |   require 'oxidized/cli'
 9 |   Oxidized::CLI.new.run
10 | rescue => error
11 |   warn "#{error}"
12 |   debug = Oxidied.config.debug rescue true
13 |   raise if debug
14 | end
15 | 


--------------------------------------------------------------------------------
/extra/oxidized.upstart:
--------------------------------------------------------------------------------
 1 | # by @andrewpwade in issue #45
 2 | 
 3 | start on started networking
 4 | 
 5 | respawn
 6 | 
 7 | setuid oxidized
 8 | setgid oxidized
 9 | 
10 | chdir /home/oxidized
11 | 
12 | env HOME=/home/oxidized
13 | 
14 | pre-start script
15 |     test -x /usr/local/bin/oxidized || { stop; exit 0; }
16 | end script
17 | 
18 | exec /usr/local/bin/oxidized
19 | 


--------------------------------------------------------------------------------
/extra/oxidized.nginx:
--------------------------------------------------------------------------------
 1 | server {
 2 |         listen 80;
 3 |         listen [::]:80;
 4 | 
 5 |         server_name oxidized.example.com;
 6 | 
 7 |         location / {
 8 |                 proxy_pass http://127.0.0.1:8888/;
 9 |         }
10 | 
11 |         access_log /var/log/nginx/access_oxidized.log;
12 |         error_log /var/log/nginx/error_oxidized.log;
13 | }
14 | 
15 | 


--------------------------------------------------------------------------------
/extra/rvm.oxidized.upstart:
--------------------------------------------------------------------------------
 1 | start on started networking
 2 | 
 3 | respawn
 4 | 
 5 | setuid oxidized
 6 | setgid oxidized
 7 | 
 8 | chdir /home/oxidized
 9 | 
10 | env HOME=/home/oxidized
11 | 
12 | pre-start script
13 | 	test -x /usr/local/rvm/wrappers/ruby-2.1.2/oxidized || { stop; exit 0; }
14 | end script
15 | 
16 | script
17 | 	exec /usr/local/rvm/wrappers/ruby-2.1.2/oxidized
18 | end script


--------------------------------------------------------------------------------
/extra/oxidized.apache2:
--------------------------------------------------------------------------------
 1 | <VirtualHost *:80>
 2 | 	# Place in sites-available
 3 | 	
 4 |     ServerAdmin admin@example.com
 5 |     ServerName oxidized.example.com
 6 |     ServerAlias oxidized
 7 | 
 8 |     ProxyPass /  http://127.0.0.1:8888/
 9 |     ProxyPassReverse / http://127.0.0.1:8888/
10 | 
11 |     ErrorLog /var/log/apache2/oxidized_error.log
12 |     CustomLog /var/log/apache2/oxidized_access.log combined
13 | 
14 | </VirtualHost>
15 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/netscaler.rb:
--------------------------------------------------------------------------------
 1 | class NetScaler < Oxidized::Model
 2 | 
 3 |   prompt /^\>\s*$/
 4 |   comment '# '
 5 | 
 6 |   cmd :all do |cfg|
 7 |     cfg.each_line.to_a[1..-3].join
 8 |   end
 9 | 
10 |   cmd 'show version' do |cfg|
11 |     comment cfg
12 |   end
13 | 
14 |   cmd 'show hardware' do |cfg|
15 |     comment cfg
16 |   end
17 | 
18 |   cmd 'show ns ns.conf'
19 | 
20 |   cfg :ssh do
21 |     pre_logout 'exit'
22 |   end
23 | 
24 | end
25 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/airos.rb:
--------------------------------------------------------------------------------
 1 | class Airos < Oxidized::Model
 2 |   # Ubiquiti AirOS circa 5.x
 3 |   
 4 |   prompt /^[^#]+# /
 5 |   
 6 |   cmd 'cat /etc/board.info' do |cfg|
 7 |     cfg.split("\n").map { |line| "# #{line}" }.join("\n") + "\n"
 8 |   end
 9 |   
10 |   cmd 'sort /tmp/system.cfg'
11 |   
12 |   cmd :secret do |cfg|
13 |     cfg.gsub! /^(users\.\d+\.password|snmp\.community)=.+/, "# \\1=<hidden>"
14 |     cfg
15 |   end
16 | 
17 |   cfg :ssh do
18 |     exec true
19 |   end
20 | end
21 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/pfsense.rb:
--------------------------------------------------------------------------------
 1 | class PfSense < Oxidized::Model
 2 | 
 3 |   # use other use than 'admin' user, 'admin' user cannot get ssh/exec. See issue #535
 4 |   
 5 |   cmd :all do |cfg|
 6 |     cfg.each_line.to_a[1..-2].join
 7 |   end
 8 |   
 9 |   cmd 'cat /cf/conf/config.xml' do |cfg|
10 |     cfg.gsub! /\s<revision>\s*.*\s*<time>\d*<\/time>\s*.*\s*<\/revision>/, ''
11 |     cfg
12 |   end
13 |   
14 |   cfg :ssh do
15 |     exec true
16 |     pre_logout 'exit'
17 |   end
18 |  
19 | end
20 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/corianttmos.rb:
--------------------------------------------------------------------------------
 1 | class CoriantTmos < Oxidized::Model
 2 | 
 3 |   comment '# '
 4 |   
 5 |   prompt /^[^\s#]+#\s$/
 6 | 
 7 |   cmd 'show node extensive' do |cfg|
 8 |     comment cfg
 9 |   end
10 | 
11 |   cmd 'show run' do |cfg|
12 |     cfg
13 |   end
14 | 
15 |   cfg :telnet do
16 |     username /^Login:\s$/
17 |     password /^Password:\s$/
18 |   end
19 | 
20 |   cfg :telnet, :ssh do
21 |     pre_logout 'exit'
22 |     post_login 'enable config terminal length 0'
23 |   end
24 |   
25 | end
26 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/opengear.rb:
--------------------------------------------------------------------------------
 1 | class OpenGear < Oxidized::Model
 2 | 
 3 |   comment  '# '
 4 |   
 5 |   prompt /^(\$\s)?$/
 6 | 
 7 |   cmd :secret do |cfg|
 8 |     cfg.gsub!(/password (\S+)/, 'password <secret removed>')
 9 |     cfg.gsub!(/community (\S+)/, 'community <secret removed>')
10 |     cfg
11 |   end
12 | 
13 |   cmd('cat /etc/version') { |cfg| comment cfg }
14 | 
15 |   cmd 'config -g config'
16 | 
17 |   cfg :ssh do
18 |     exec true  # don't run shell, run each command in exec channel
19 |   end
20 | 
21 | end
22 | 


--------------------------------------------------------------------------------
/lib/oxidized/input/input.rb:
--------------------------------------------------------------------------------
 1 | module Oxidized
 2 |   class PromptUndetect < OxidizedError; end
 3 |   class Input
 4 |     include Oxidized::Config::Vars
 5 | 
 6 |     RescueFail = {
 7 |       :debug => [
 8 |         Errno::ECONNREFUSED,
 9 |       ],
10 |       :warn => [
11 |         IOError,
12 |         PromptUndetect,
13 |         Timeout::Error,
14 |         Errno::ECONNRESET,
15 |         Errno::EHOSTUNREACH,
16 |         Errno::ENETUNREACH,
17 |         Errno::EPIPE,
18 |         Errno::ETIMEDOUT,
19 |       ],
20 |     }
21 |   end
22 | end
23 | 


--------------------------------------------------------------------------------
/lib/oxidized/source/source.rb:
--------------------------------------------------------------------------------
 1 | module Oxidized
 2 |   class Source
 3 |     class NoConfig < OxidizedError; end
 4 | 
 5 |     def initialize
 6 |       @map = (Oxidized.config.model_map or {})
 7 |     end
 8 | 
 9 |     def map_model model
10 |       @map.has_key?(model) ? @map[model] : model
11 |     end
12 | 
13 |     def node_var_interpolate var
14 |        case var
15 |        when "nil"   then nil
16 |        when "false" then false
17 |        when "true"  then true
18 |        else var
19 |        end
20 |     end
21 | 
22 |   end
23 | end
24 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/edgeos.rb:
--------------------------------------------------------------------------------
 1 | class Edgeos < Oxidized::Model
 2 | 
 3 |   # EdgeOS #
 4 | 
 5 |   prompt /\@.*?\:~\$\s/
 6 | 
 7 |   cmd :all do |cfg|
 8 |     cfg = cfg.lines.to_a[1..-2].join
 9 |   end
10 | 
11 |   cmd :secret do |cfg|
12 |     cfg.gsub! /community (\S+) {/, 'community <hidden> {'
13 |     cfg
14 |   end
15 | 
16 |   cmd 'show configuration | no-more'
17 | 
18 |   cfg :telnet do
19 |     username  /login:\s/
20 |     password  /^Password:\s/
21 |   end
22 | 
23 |   cfg :telnet, :ssh do
24 |     pre_logout 'exit'
25 |   end
26 | 
27 | end
28 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/firewareos.rb:
--------------------------------------------------------------------------------
 1 | class FirewareOS < Oxidized::Model
 2 | 
 3 |   prompt /^\[?\w*\]?\w*<?\w*>?#\s*$/
 4 |   comment  '-- '
 5 | 
 6 |   cmd :all do |cfg|
 7 |     cfg.each_line.to_a[1..-2].join
 8 |   end
 9 | 
10 |   cmd 'show sysinfo' do |cfg|
11 |     # avoid commits due to uptime
12 |     cfg = cfg.each_line.select { |line| not line.match /(.*time.*)|(.*memory.*)|(.*cpu.*)/ }
13 |     cfg = cfg.join
14 |     comment cfg
15 |   end
16 | 
17 |   cmd 'export config to console'
18 | 
19 |   cfg :ssh do
20 |     pre_logout 'exit'
21 |   end
22 | 
23 | end
24 | 
25 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/saos.rb:
--------------------------------------------------------------------------------
 1 | class SAOS < Oxidized::Model
 2 | 
 3 |   # Ciena SAOS switch
 4 |   # used for 6.x devices
 5 |  
 6 |   comment  '! '
 7 | 
 8 |   cmd :all do |cfg|
 9 |     cfg.each_line.to_a[1..-2].join
10 |   end
11 | 
12 |   cmd 'configuration show' do |cfg|
13 |     cfg
14 |   end
15 | 
16 |   cfg :telnet do
17 |     username /login:/
18 |     password /assword:/
19 |   end
20 | 
21 |   cfg :telnet, :ssh do
22 |     post_login 'system shell set more off'
23 |     post_login 'system shell session set more off'
24 |     pre_logout 'exit'
25 |   end
26 | end
27 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/vyatta.rb:
--------------------------------------------------------------------------------
 1 | class Vyatta < Oxidized::Model
 2 | 
 3 |   # Brocade Vyatta / VyOS model #
 4 |   
 5 |   prompt /\@.*?\:~\$\s/
 6 | 
 7 |   cmd :all do |cfg|
 8 |     cfg = cfg.lines.to_a[1..-2].join
 9 |   end
10 | 
11 |   cmd :secret do |cfg|
12 |     cfg.gsub! /community (\S+) {/, 'community <hidden> {'
13 |     cfg
14 |   end
15 | 
16 |   cmd 'show configuration | no-more'
17 | 
18 |   cfg :telnet do
19 |     username  /login:\s/
20 |     password  /^Password:\s/
21 |   end
22 | 
23 |   cfg :telnet, :ssh do
24 |     pre_logout 'exit'
25 |   end
26 | 
27 | end
28 | 


--------------------------------------------------------------------------------
/lib/oxidized/config/vars.rb:
--------------------------------------------------------------------------------
 1 | module Oxidized::Config::Vars
 2 |   # convenience method for accessing node, group or global level user variables
 3 |   # nil values will be ignored
 4 |   def vars name
 5 |     r = @node.vars[name] unless @node.vars.nil?
 6 |     if Oxidized.config.groups.has_key?(@node.group)
 7 |       if Oxidized.config.groups[@node.group].vars.has_key?(name.to_s)
 8 |         r ||= Oxidized.config.groups[@node.group].vars[name.to_s]
 9 |       end
10 |     end
11 |     r ||= Oxidized.config.vars[name.to_s] if Oxidized.config.vars.has_key?(name.to_s)
12 |     r
13 |   end
14 | end
15 | 
16 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/coriant8600.rb:
--------------------------------------------------------------------------------
 1 | class Coriant8600 < Oxidized::Model
 2 | 
 3 |   comment '# '
 4 |   
 5 |   prompt /^[^\s#>]+[#>]$/
 6 | 
 7 |   cmd 'show hw-inventory' do |cfg|
 8 |     comment cfg
 9 |   end
10 | 
11 |   cmd 'show flash' do |cfg|
12 |     comment cfg
13 |   end
14 |   
15 |   cmd 'show run' do |cfg|
16 |     cfg
17 |   end
18 | 
19 |   cfg :telnet do
20 |     username /^user name:$/
21 |     password /^password:$/
22 |   end
23 |   
24 |   cfg :telnet, :ssh do
25 |     pre_logout 'exit'
26 |     post_login 'enable'
27 |     post_login 'terminal more off'
28 |   end
29 | 
30 | end
31 | 


--------------------------------------------------------------------------------
/spec/spec_helper.rb:
--------------------------------------------------------------------------------
 1 | require 'minitest/autorun'
 2 | require 'mocha/mini_test'
 3 | require 'oxidized'
 4 | 
 5 | Oxidized.mgr = Oxidized::Manager.new
 6 | 
 7 | def stub_oxidized_ssh
 8 |   Oxidized::SSH.any_instance.stubs(:connect).returns(true)
 9 |   Oxidized::SSH.any_instance.stubs(:node).returns(@node)
10 |   Oxidized::SSH.any_instance.expects(:cmd).at_least(1).returns("this is a command output\nModel: mx960")
11 |   Oxidized::SSH.any_instance.stubs(:connect_cli).returns(true)
12 |   Oxidized::SSH.any_instance.stubs(:disconnect).returns(true)
13 |   Oxidized::SSH.any_instance.stubs(:disconnect_cli).returns(true)
14 | end
15 | 


--------------------------------------------------------------------------------
/spec/cli_spec.rb:
--------------------------------------------------------------------------------
 1 | require 'spec_helper'
 2 | require 'oxidized/cli'
 3 | 
 4 | describe Oxidized::CLI do
 5 |   before { @original = ARGV }
 6 |   after  { ARGV.replace @original }
 7 | 
 8 |   %w[-v --version].each do |option|
 9 |     describe option do
10 |       before { ARGV.replace([option]) }
11 | 
12 |       it 'prints the version and exits' do
13 |         Oxidized::Config.expects(:load)
14 |         Oxidized.expects(:setup_logger)
15 |         File.expects(:expand_path)
16 |         Kernel.expects(:exit)
17 | 
18 |         assert_output("#{Oxidized::VERSION}\n") { Oxidized::CLI.new }
19 |       end
20 |     end
21 |   end
22 | end
23 | 


--------------------------------------------------------------------------------
/lib/oxidized/job.rb:
--------------------------------------------------------------------------------
 1 | module Oxidized
 2 |   class Job < Thread
 3 |     attr_reader :start, :end, :status, :time, :node, :config
 4 |     def initialize(node)
 5 |       @node         = node
 6 |       @start        = Time.now.utc
 7 |       super do
 8 |         Oxidized.logger.debug "lib/oxidized/job.rb: Starting fetching process for #{@node.name} at #{Time.now.utc}"
 9 |         @status, @config = @node.run
10 |         @end             = Time.now.utc
11 |         @time            = @end - @start
12 |         Oxidized.logger.debug "lib/oxidized/job.rb: Config fetched for #{@node.name} at #{@end}"
13 |       end
14 |     end
15 |   end
16 | end
17 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/fiberdriver.rb:
--------------------------------------------------------------------------------
 1 | class FiberDriver < Oxidized::Model
 2 |   prompt /\w+#/
 3 |   comment "! "
 4 | 
 5 |   cmd :all do |cfg|
 6 |     cfg.each_line.to_a[1..-2].join
 7 |   end
 8 |   cmd 'show inventory' do |cfg|
 9 |     comment cfg
10 |   end
11 | 
12 |   cmd "show running-config" do |cfg|
13 |     cfg.each_line.to_a[3..-1].join
14 |     cfg.gsub! /^Building configuration.*$/, ''
15 |     cfg.gsub! /^Current configuration:.*$$/, ''
16 |     cfg.gsub! /^! Configuration saved on .*$/, ''
17 |     cfg
18 |   end
19 | 
20 |   cfg :ssh do
21 |     post_login 'terminal length 0'
22 |     post_login 'terminal width 512'
23 |     pre_logout 'exit'
24 |   end
25 | end
26 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/routeros.rb:
--------------------------------------------------------------------------------
 1 | class RouterOS < Oxidized::Model
 2 |   prompt /\[\w+@\S+(\s?\S+)*\]\s?>\s?$/
 3 |   comment "# "
 4 | 
 5 |   cmd '/system routerboard print' do |cfg|
 6 |     comment cfg
 7 |   end
 8 | 
 9 |   cmd '/export' do |cfg|
10 |     cfg.gsub! /\x1B\[([0-9]{1,3}((;[0-9]{1,3})*)?)?[m|K]/, '' # strip ANSI colours
11 |     cfg.gsub! /\\\r\n\s+/, ''   # strip new line
12 |     cfg = cfg.split("\n").select { |line| not line[/^\#\s\w{3}\/\d{2}\/\d{4}.*$/] }
13 |     cfg.join("\n") + "\n"
14 |   end
15 | 
16 |   cfg :telnet do
17 |     username /^Login:/
18 |     password /^Password:/
19 |   end
20 | 
21 |   cfg :ssh do
22 |     exec true
23 |   end
24 | end
25 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/fabricos.rb:
--------------------------------------------------------------------------------
 1 | class FabricOS < Oxidized::Model
 2 | 
 3 |   # Brocade Fabric OS model #
 4 |   ## FIXME: Only ssh exec mode support, no telnet, no ssh screenscraping
 5 | 
 6 |   prompt /^([\w]+:+[\w]+[>]\s)$/
 7 |   comment  '# '
 8 | 
 9 |   cmd 'chassisShow' do |cfg|
10 |     comment cfg.each_line.reject { |line| line.match /Time Awake:/ or line.match /Power Usage \(Watts\):/ or line.match /Time Alive:/ or line.match /Update:/ }.join
11 |   end
12 | 
13 |   cmd 'configShow -all' do |cfg|
14 |     cfg = cfg.each_line.reject { |line| line.match /date = /}.join
15 |     cfg
16 |   end
17 | 
18 |   cfg :ssh do
19 |     exec true  # don't run shell, run each command in exec channel
20 |   end
21 | 
22 | end
23 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/vrp.rb:
--------------------------------------------------------------------------------
 1 | class VRP < Oxidized::Model
 2 |   # Huawei VRP
 3 |   
 4 |   prompt /^(<[\w.-]+>)$/
 5 |   comment '# '
 6 | 
 7 |   cmd :all do |cfg|
 8 |     cfg.each_line.to_a[1..-2].join
 9 |   end
10 |  
11 |   cfg :telnet do
12 |     username /^Username:$/
13 |     password /^Password:$/
14 |   end
15 | 
16 |   cfg :telnet, :ssh do 
17 |     post_login 'screen-length 0 temporary'
18 |     pre_logout 'quit'
19 |   end
20 | 
21 |   cmd 'display version' do |cfg|
22 |     cfg = cfg.each_line.select {|l| not l.match /uptime/ }.join
23 |     comment cfg
24 |   end
25 | 
26 |   cmd 'display device' do |cfg|
27 |     comment cfg
28 |   end
29 | 
30 |   cmd 'display current-configuration all' do |cfg|
31 |     cfg
32 |   end
33 |   
34 | end
35 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/datacom.rb:
--------------------------------------------------------------------------------
 1 | class DataCom < Oxidized::Model
 2 | 
 3 |   comment '! '
 4 | 
 5 |   expect /^--More--\s+$/ do |data, re|
 6 |     send ' '
 7 |     data.sub re, ''
 8 |   end
 9 | 
10 |   cmd :all do |cfg|
11 |     cfg.each_line.to_a[1..-2].join
12 |     cfg.cut_head.cut_tail
13 |   end
14 | 
15 |   cmd 'show firmware' do |cfg|
16 |     comment cfg
17 |   end
18 | 
19 |   cmd 'show system' do |cfg|
20 |     comment cfg
21 |   end
22 | 
23 |   cmd 'show running-config' do |cfg|
24 |     cfg.cut_head
25 |   end
26 | 
27 |   cfg :ssh do
28 |     password /^Password:\s$/
29 |     pre_logout 'exit'
30 |   end
31 | 
32 |   cfg :telnet do
33 |     username /login:\s$/
34 |     password /^Password:\s$/
35 |     pre_logout 'exit'
36 |   end
37 | 
38 | end
39 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/edgeswitch.rb:
--------------------------------------------------------------------------------
 1 | class EdgeSwitch < Oxidized::Model
 2 | 
 3 | # Ubiquiti EdgeSwitch #
 4 | 
 5 |   comment '!'
 6 | 
 7 |   prompt /\(.*\)\s[#>]/
 8 | 
 9 |   cmd 'show running-config' do |cfg|
10 |     cfg.each_line.to_a[2..-2].reject { |line| line.match /System Up Time.*/ or line.match /Current SNTP Synchronized Time.*/ }.join
11 |   end
12 | 
13 |   cfg :telnet do
14 |     username /User(name)?:\s?/
15 |     password /^Password:\s?/
16 |   end
17 | 
18 |   cfg :telnet, :ssh do
19 |     post_login do
20 |       if vars :enable
21 |         send "enable\n"
22 |         cmd vars(:enable)
23 |       else
24 |         cmd 'enable'
25 |       end
26 |       cmd 'terminal length 0'
27 |     end
28 |     pre_logout 'quit'
29 |     pre_logout 'n'
30 |   end
31 | 
32 | end
33 | 


--------------------------------------------------------------------------------
/lib/oxidized/hook/awssns.rb:
--------------------------------------------------------------------------------
 1 | require 'aws-sdk'
 2 | 
 3 | class AwsSns < Oxidized::Hook
 4 |   def validate_cfg!
 5 |     raise KeyError, 'hook.region is required' unless cfg.has_key?('region')
 6 |     raise KeyError, 'hook.topic_arn is required' unless cfg.has_key?('topic_arn')
 7 |   end
 8 | 
 9 |   def run_hook(ctx)
10 |     sns = Aws::SNS::Resource.new(region: cfg.region)
11 |     topic = sns.topic(cfg.topic_arn)
12 |     message = {
13 |       :event => ctx.event.to_s
14 |     }
15 |     if ctx.node
16 |       message.merge!(
17 |         :group => ctx.node.group.to_s,
18 |         :model => ctx.node.model.class.name.to_s.downcase,
19 |         :node => ctx.node.name.to_s
20 |       )
21 |     end
22 |     topic.publish({
23 |       message: message.to_json
24 |     })
25 |   end
26 | 
27 | end
28 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/aos.rb:
--------------------------------------------------------------------------------
 1 | class AOS < Oxidized::Model
 2 | 
 3 |   # Alcatel-Lucent Operating System
 4 |   # used in OmniSwitch
 5 |  
 6 |   comment  '! '
 7 | 
 8 |   cmd :all do |cfg|
 9 |     cfg.each_line.to_a[1..-2].join
10 |   end
11 | 
12 |   cmd 'show system' do |cfg|
13 |     cfg = cfg.each_line.find{|line|line.match 'Description'}
14 |     comment cfg.to_s.strip
15 |   end
16 | 
17 |   cmd 'show chassis' do |cfg|
18 |     comment cfg
19 |   end
20 | 
21 |   cmd 'show hardware info' do |cfg|
22 |     comment cfg
23 |   end
24 | 
25 |   cmd 'show configuration snapshot' do |cfg|
26 |     cfg
27 |   end
28 | 
29 |   cfg :telnet do
30 |     username /^login : /
31 |     password /^password : /
32 |   end
33 | 
34 |   cfg :telnet, :ssh do
35 |     pre_logout 'exit'
36 |   end
37 | 
38 | end
39 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/quantaos.rb:
--------------------------------------------------------------------------------
 1 | class QuantaOS < Oxidized::Model
 2 | 
 3 |   prompt /^\((\w|\S)+\) (>|#)$/
 4 |   comment '! '
 5 |   
 6 |   cmd 'show run' do |cfg|
 7 |     cfg.each_line.select do |line|
 8 |       not line.match /^!.*$/ and
 9 |       not line.match /^\((\w|\S)+\) (>|#)$/ and
10 |       not line.match /^show run$/
11 |     end.join
12 |   end
13 | 
14 |   cfg :telnet do
15 |     username /^Username:/
16 |     password /^Password:/
17 |   end
18 | 
19 |   cfg :telnet, :ssh do
20 |     post_login do
21 |       send "enable\n"
22 |       if vars :enable
23 |         cmd vars(:enable)
24 |       else
25 |         cmd ""
26 |       end
27 |     end
28 |     post_login 'terminal length 0'
29 |     pre_logout do
30 |       send "quit\n"
31 |       send "n\n"
32 |     end
33 |   end
34 | 
35 | end
36 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/outputs.rb:
--------------------------------------------------------------------------------
 1 | module Oxidized
 2 |   class Model
 3 |     class Outputs
 4 | 
 5 |       def to_cfg
 6 |         type_to_str(nil)
 7 |       end
 8 | 
 9 |       def type_to_str want_type
10 |         type(want_type).map { |out| out }.join
11 |       end
12 | 
13 |       def << output
14 |         @outputs << output
15 |       end
16 | 
17 |       def unshift output
18 |         @outputs.unshift output
19 |       end
20 | 
21 |       def all
22 |         @outputs
23 |       end
24 | 
25 |       def type type
26 |         @outputs.select { |out| out.type==type }
27 |       end
28 | 
29 |       def types
30 |         @outputs.map { |out| out.type }.uniq.compact
31 |       end
32 | 
33 |       private
34 | 
35 |       def initialize
36 |         @outputs = []
37 |       end
38 | 
39 |     end
40 |   end
41 | end
42 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/isam.rb:
--------------------------------------------------------------------------------
 1 | class ISAM < Oxidized::Model
 2 |   #Alcatel ISAM 7302/7330 FTTN
 3 |   
 4 |   prompt /^([\w.:@-]+>#\s)$/
 5 |   comment '# '
 6 | 
 7 |   cmd :all do |cfg|
 8 |     cfg.each_line.to_a[1..-2].join
 9 |   end
10 | 
11 |   cfg :telnet do 
12 |     username /^login:\s*/
13 |     password /^password:\s*/
14 |   end
15 | 
16 |   cfg :telnet, :ssh do
17 |     post_login 'environment prompt "%n># "'
18 |     post_login 'environment mode batch'
19 |     post_login 'environment inhibit-alarms print no-more'
20 |     pre_logout 'logout'
21 |   end
22 |   
23 |   cmd 'show software-mngt oswp detail' do |cfg|
24 |     comment cfg
25 |   end
26 | 
27 |   cmd 'show equipment slot detail' do |cfg|
28 |     comment cfg
29 |   end
30 | 
31 |   cmd 'info configure flat' do |cfg|
32 |     cfg
33 |   end
34 | 
35 | end
36 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/panos.rb:
--------------------------------------------------------------------------------
 1 | class PanOS < Oxidized::Model
 2 | 
 3 |   # PaloAlto PAN-OS model #
 4 | 
 5 |   comment  '! '
 6 | 
 7 |   prompt /^[\w.\@:\(\)-]+>\s?$/
 8 | 
 9 |   cmd :all do |cfg|
10 |     cfg.each_line.to_a[2..-3].join
11 |   end
12 | 
13 |   cmd 'show system info' do |cfg|
14 |     cfg.gsub! /^(up)?time:\ .*$/, ''
15 |     cfg.gsub! /^app-.*?:\ .*$/, ''
16 |     cfg.gsub! /^av-.*?:\ .*$/, ''
17 |     cfg.gsub! /^threat-.*?:\ .*$/, ''
18 |     cfg.gsub! /^wildfire-.*?:\ .*$/, ''
19 |     cfg.gsub! /^wf-private.*?:\ .*$/, ''
20 |     cfg.gsub! /^url-filtering.*?:\ .*$/, ''
21 |     cfg.gsub! /^global-.*?:\ .*$/, ''
22 |     comment cfg
23 |   end
24 | 
25 |   cmd 'show config running' do |cfg|
26 |     cfg
27 |   end
28 | 
29 |   cfg :ssh do
30 |     post_login 'set cli pager off'
31 |     pre_logout 'exit'
32 |   end
33 | end
34 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/mtrlrfs.rb:
--------------------------------------------------------------------------------
 1 | class Mtrlrfs < Oxidized::Model
 2 | 
 3 |   # Motorola RFS/Extreme WM
 4 | 
 5 |   comment  '# '
 6 | 
 7 |   cmd :all do |cfg|
 8 |     # xos inserts leading \r characters and other trailing white space.
 9 |     # this deletes extraneous \r and trailing white space.
10 |     cfg.each_line.to_a[1..-2].map{|line|line.delete("\r").rstrip}.join("\n") + "\n"
11 |   end
12 | 
13 |   cmd 'show version' do |cfg|
14 |     comment cfg
15 |   end
16 | 
17 |   cmd 'show licenses' do |cfg|
18 |     comment cfg
19 |   end
20 | 
21 |   cmd 'show running-config'
22 | 
23 |   cfg :telnet do
24 |     username /^login:/
25 |     password /^\r*password:/
26 |   end
27 | 
28 |   cfg :telnet, :ssh do
29 |     post_login 'terminal length 0'
30 |     pre_logout do
31 |       send "exit\n"
32 |       send "n\n"
33 |     end
34 |   end
35 | 
36 | end
37 | 
38 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/dlink.rb:
--------------------------------------------------------------------------------
 1 | class Dlink < Oxidized::Model
 2 |   # D-LINK Switches
 3 | 
 4 |   prompt /^(\r*[\w.@():-]+[#>]\s?)$/
 5 |   comment '# '
 6 | 
 7 |   cmd :secret do |cfg|
 8 |     cfg.gsub! /^(create snmp community) \S+/, '\\1 <removed>'
 9 |     cfg.gsub! /^(create snmp group) \S+/, '\\1 <removed>'
10 |     cfg
11 |   end
12 | 
13 |   cmd :all do |cfg|
14 |     cfg.each_line.to_a[2..-2].map{|line|line.delete("\r").rstrip}.join("\n") + "\n"
15 |   end
16 | 
17 |   cmd 'show switch' do |cfg|
18 |     comment cfg
19 |   end
20 | 
21 |   cmd 'show vlan' do |cfg|
22 |     comment cfg
23 |   end
24 | 
25 |   cmd 'show config current'
26 | 
27 |   cfg :telnet do
28 |     username /\r*username:/
29 |     password /\r*password:/
30 |   end
31 | 
32 |   cfg :telnet, :ssh do
33 |     post_login 'disable clipaging'
34 |     pre_logout 'logout'
35 |   end
36 | end
37 | 


--------------------------------------------------------------------------------
/extra/nagios_check_failing_nodes.rb:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env ruby
 2 | 
 3 | ## contrib via https://github.com/ytti/oxidized/issues/67
 4 | 
 5 | require 'open-uri'
 6 | require 'json'
 7 | 
 8 | critical = false
 9 | pending = false
10 | critical_nodes = []
11 | pending_nodes = []
12 | 
13 | json = JSON.load(open("http://localhost:8888/nodes.json"))
14 | json.each do |node|
15 |   if not node['last'].nil?
16 |     if node['last']['status'] != 'success'
17 |       critical_nodes << node['name']
18 |       critical = true
19 |     end
20 |   else
21 |     pending_nodes << node['name']
22 |     pending = true
23 |   end
24 | end
25 | 
26 | if critical
27 |   puts '[CRIT] Unable to backup: ' + critical_nodes.join(',')
28 |   exit 2
29 | elsif pending
30 |   puts '[WARN] Pending backup: ' + pending_nodes.join(',')
31 |   exit 1
32 | else
33 |   puts '[OK] Backup of all nodes completed successfully.'
34 |   exit 0
35 | end
36 | 


--------------------------------------------------------------------------------
/Gemfile.lock:
--------------------------------------------------------------------------------
 1 | PATH
 2 |   remote: .
 3 |   specs:
 4 |     oxidized (0.18.0)
 5 |       asetus (~> 0.1)
 6 |       net-ssh (~> 3.0.2)
 7 |       net-telnet
 8 |       rugged (~> 0.21, >= 0.21.4)
 9 |       slop (~> 3.5)
10 | 
11 | GEM
12 |   remote: https://rubygems.org/
13 |   specs:
14 |     asetus (0.3.0)
15 |     coderay (1.1.0)
16 |     metaclass (0.0.4)
17 |     method_source (0.8.2)
18 |     minitest (5.9.0)
19 |     mocha (1.1.0)
20 |       metaclass (~> 0.0.1)
21 |     net-ssh (3.0.2)
22 |     net-telnet (0.1.1)
23 |     pry (0.10.3)
24 |       coderay (~> 1.1.0)
25 |       method_source (~> 0.8.1)
26 |       slop (~> 3.4)
27 |     rake (10.5.0)
28 |     rugged (0.23.3)
29 |     slop (3.6.0)
30 | 
31 | PLATFORMS
32 |   ruby
33 | 
34 | DEPENDENCIES
35 |   bundler (~> 1.10)
36 |   minitest (~> 5.8)
37 |   mocha (~> 1.1)
38 |   oxidized!
39 |   pry (~> 0)
40 |   rake (~> 10.0)
41 | 
42 | BUNDLED WITH
43 |    1.11.2
44 | 


--------------------------------------------------------------------------------
/lib/oxidized/string.rb:
--------------------------------------------------------------------------------
 1 | module Oxidized
 2 |   # Used in models, contains convenience methods
 3 |   class String < String
 4 |     attr_accessor :type, :cmd, :name
 5 | 
 6 |     # @return [Oxidized::String] copy of self with last line removed
 7 |     def cut_tail
 8 |       Oxidized::String.new each_line.to_a[0..-2].join
 9 |     end
10 | 
11 |     # @return [Oxidized::String] copy of self with first line removed
12 |     def cut_head
13 |       Oxidized::String.new each_line.to_a[1..-1].join
14 |     end
15 | 
16 |     # sets @cmd and @name unless @name is already set
17 |     def set_cmd command
18 |       @cmd  = command
19 |       @name ||= @cmd.strip.gsub(/\s+/, '_')
20 |     end
21 | 
22 |     def initialize str=''
23 |       super
24 |       if str.class == Oxidized::String
25 |         @cmd  = str.cmd
26 |         @name = str.name
27 |         @type = str.type
28 |       end
29 |     end
30 | 
31 |   end
32 | end
33 | 


--------------------------------------------------------------------------------
/lib/oxidized/node/stats.rb:
--------------------------------------------------------------------------------
 1 | module Oxidized
 2 |   class Node
 3 |     class Stats
 4 |       MAX_STAT = 10
 5 | 
 6 |       # @param [Job] job job whose information add to stats
 7 |       # @return [void]
 8 |       def add job
 9 |         stat = {
10 |           :start  => job.start,
11 |           :end    => job.end,
12 |           :time   => job.time,
13 |         }
14 |         @stats[job.status] ||= []
15 |         @stats[job.status].shift if @stats[job.status].size > MAX_STAT
16 |         @stats[job.status].push stat
17 |       end
18 | 
19 |       # @param [Symbol] status stats for specific status
20 |       # @return [Hash,Array] Hash of stats for every status or Array of stats for specific status
21 |       def get status=nil
22 |         status ? @stats[status] : @stats
23 |       end
24 | 
25 |       private
26 | 
27 |       def initialize
28 |         @stats = {}
29 |       end
30 | 
31 |     end
32 |   end
33 | end
34 | 


--------------------------------------------------------------------------------
/Dockerfile:
--------------------------------------------------------------------------------
 1 | FROM phusion/baseimage:0.9.18
 2 | MAINTAINER Samer Abdel-Hafez <sam@arahant.net>
 3 | 
 4 | RUN add-apt-repository ppa:brightbox/ruby-ng && \
 5 | 	apt-get update && \
 6 |   apt-get install -y ruby2.3 ruby2.3-dev libsqlite3-dev libssl-dev pkg-config make cmake libssh2-1-dev git g++
 7 | 
 8 | RUN mkdir -p /tmp/oxidized
 9 | COPY . /tmp/oxidized/
10 | WORKDIR /tmp/oxidized
11 | 
12 | RUN gem build oxidized.gemspec
13 | RUN gem install oxidized-*.gem
14 | 
15 | # web interface
16 | RUN gem install oxidized-web --no-ri --no-rdoc
17 | 
18 | # dependencies for hooks
19 | RUN gem install aws-sdk
20 | RUN gem install slack-api
21 | 
22 | RUN rm -rf /tmp/oxidized
23 | 
24 | RUN apt-get remove -y ruby-dev pkg-config make cmake
25 | 
26 | RUN apt-get -y autoremove
27 | 
28 | ADD extra/oxidized.runit /etc/service/oxidized/run
29 | ADD extra/auto-reload-config.runit /etc/service/auto-reload-config/run
30 | 
31 | VOLUME ["/root/.config/oxidized"]
32 | EXPOSE 8888/tcp
33 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/supermicro.rb:
--------------------------------------------------------------------------------
 1 | class Supermicro < Oxidized::Model
 2 |   comment  '! '
 3 | 
 4 |   cmd :secret do |cfg|
 5 |     cfg.gsub!(/password \d+ (\S+).*/, '<secret removed>')
 6 |     cfg.gsub!(/community (\S+)/, 'community <hidden>')
 7 |     cfg
 8 |   end
 9 | 
10 |   cmd :all do |cfg|
11 |      cfg.each_line.to_a[2..-2].join
12 |   end
13 | 
14 |   cmd 'show running-config'
15 | 
16 |   cmd 'show access-list tcam-utilization' do |cfg|
17 |     comment cfg
18 |   end
19 | 
20 |   cmd 'show memory' do |cfg|
21 |     comment cfg
22 |   end
23 | 
24 |   cmd 'show system' do |cfg|
25 |     comment cfg
26 |   end
27 | 
28 |   cmd 'show version' do |cfg|
29 |     comment cfg
30 |   end
31 | 
32 |   cmd 'show watchdog' do |cfg|
33 |     comment cfg
34 |   end
35 | 
36 |   cfg :telnet do
37 |     username /^Username:/
38 |     password /^Password:/
39 |   end
40 | 
41 |   cfg :telnet, :ssh do
42 |     post_login 'terminal length 0'
43 |     pre_logout 'exit'
44 |   end
45 | end


--------------------------------------------------------------------------------
/Rakefile:
--------------------------------------------------------------------------------
 1 | require 'bundler/gem_tasks'
 2 | require 'rake/testtask'
 3 | 
 4 | gemspec = eval(File.read(Dir['*.gemspec'].first))
 5 | file    = [gemspec.name, gemspec.version].join('-') + '.gem'
 6 | 
 7 | desc 'Validate gemspec'
 8 | task :gemspec do
 9 |   gemspec.validate
10 | end
11 | 
12 | desc 'Run minitest'
13 | task :test do
14 |   Rake::TestTask.new do |t|
15 |     t.libs << 'spec'
16 |     t.test_files = FileList['spec/**/*_spec.rb']
17 |     t.warning = true
18 |     t.verbose = true
19 |   end
20 | end
21 | 
22 | ## desc 'Install gem'
23 | ## task :install => :build do
24 | ##   system "sudo -Es sh -c \'umask 022; gem install gems/#{file}\'"
25 | ## end
26 | 
27 | desc 'Remove gems'
28 | task :clean do
29 |   FileUtils.rm_rf 'pkg'
30 | end
31 | 
32 | desc 'Tag the release'
33 | task :tag do
34 |   system "git tag #{gemspec.version}"
35 | end
36 | 
37 | desc 'Push to rubygems'
38 | task :push => :tag do
39 |   system "gem push pkg/#{file}"
40 | end
41 | 
42 | task default: :test
43 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/fujitsupy.rb:
--------------------------------------------------------------------------------
 1 | class FujitsuPY < Oxidized::Model
 2 | 
 3 |   prompt /^(\([\w.-]*\)\s#|^\S+\#\s)$/
 4 |   comment  '! '
 5 | 
 6 |   cmd :all do |cfg|
 7 |     cfg.each_line.to_a[1..-2].join
 8 |   end
 9 | 
10 | # 1Gbe switch
11 |   cmd 'show version' do |cfg|
12 |     cfg.gsub! /^(<ERROR> : 2 : format error)$/, ''
13 |     comment cfg
14 |   end
15 | 
16 | # 10Gbe switch
17 |   cmd 'show system information' do |cfg|
18 |     cfg.gsub! /^Current-time : [\w\s:]*$/, ''
19 |     cfg.gsub! /^(\s{33}\^)$/, ''
20 |     cfg.gsub! /^(\% Invalid input detected at '\^' marker.)$/, ''
21 |     comment cfg
22 |   end
23 | 
24 |   cmd 'show running-config' do |cfg|
25 |     cfg
26 |   end
27 | 
28 |   cfg :telnet do
29 |     username /^Username:/
30 |     password /^Password:/
31 |   end
32 | 
33 |   cfg :telnet, :ssh do
34 |     post_login 'no pager'
35 |     post_login 'terminal pager disable'
36 |     pre_logout do
37 |       send "quit\n"
38 |       send "n\n"
39 |     end
40 |   end
41 | 
42 | end
43 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/nos.rb:
--------------------------------------------------------------------------------
 1 | class NOS < Oxidized::Model
 2 | 
 3 |   # Brocade Network Operating System
 4 | 
 5 |   prompt /^(?:\e\[..h)?[\w.-]+# $/
 6 |   comment  '! '
 7 | 
 8 |   cmd :all do |cfg|
 9 |     cfg.each_line.to_a[1..-2].join
10 |   end
11 | 
12 |   cmd 'show version' do |cfg|
13 |     comment cfg
14 |   end
15 | 
16 |   cmd 'show inventory' do |cfg|
17 |     comment cfg
18 |   end
19 | 
20 |   cmd 'show license' do |cfg|
21 |     comment cfg
22 |   end
23 | 
24 |   cmd 'show chassis' do |cfg|
25 |     comment cfg.each_line.reject { |line| line.match /Time/ or line.match /Update/ }.join
26 |   end
27 | 
28 |   cfg 'show system' do |cfg|
29 |     comment cfg.each_line.reject { |line| line.match /Time/ or line.match /speed/ }
30 |   end
31 | 
32 |   cmd 'show running-config | nomore'
33 | 
34 |   cfg :telnet do
35 |     username /^.* login: /
36 |     password /^Password:/
37 |   end
38 | 
39 |   cfg :telnet, :ssh do
40 |     post_login 'terminal length 0'
41 |     #post_login 'terminal width 0'
42 |     pre_logout 'exit'
43 |   end
44 | 
45 | end
46 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/nxos.rb:
--------------------------------------------------------------------------------
 1 | class NXOS < Oxidized::Model
 2 | 
 3 |   prompt /^(\r?[\w.@_()-]+[#]\s?)$/
 4 |   comment '! '
 5 | 
 6 |   cmd :secret do |cfg|
 7 |     cfg.gsub! /^(snmp-server community).*/, '\\1 <configuration removed>'
 8 |     cfg.gsub! /^(snmp-server user (\S+) (\S+) auth (\S+)) (\S+) (priv) (\S+)/, '\\1 <configuration removed> '
 9 |     cfg.gsub! /^(username \S+ password \d) (\S+)/, '\\1 <secret hidden>'
10 |     cfg.gsub! /^(radius-server key).*/, '\\1 <secret hidden>'
11 |     cfg
12 |   end
13 |   
14 |   cmd 'show version' do |cfg|
15 |     cfg = cfg.each_line.take_while { |line| not line.match(/uptime/i) }
16 |     comment cfg.join ""
17 |   end
18 | 
19 |   cmd 'show inventory' do |cfg|
20 |     comment cfg
21 |   end 
22 | 
23 |   cmd 'show running-config' do |cfg|
24 |     cfg.gsub! /^!Time:[^\n]*\n/, ''
25 |   end
26 | 
27 |   cfg :ssh, :telnet do
28 |     post_login 'terminal length 0'
29 |     pre_logout 'exit'
30 |   end
31 | 
32 |   cfg :telnet do
33 |     username /^login:/
34 |     password /^Password:/
35 |   end
36 | end
37 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/ftos.rb:
--------------------------------------------------------------------------------
 1 | class FTOS  < Oxidized::Model
 2 | 
 3 |   # Force10 FTOS model #
 4 | 
 5 |   comment  '! '
 6 | 
 7 |   cmd :all do |cfg|
 8 |     cfg.each_line.to_a[2..-2].join
 9 |   end
10 | 
11 |   cmd :secret do |cfg| 
12 |     cfg.gsub! /^(snmp-server community).*/, '\\1 <configuration removed>'
13 |     cfg.gsub! /secret (\d+) (\S+).*/, '<secret hidden>'
14 |     cfg
15 |   end
16 | 
17 |   cmd 'show inventory' do |cfg|
18 |     comment cfg
19 |   end
20 | 
21 |   cmd 'show inventory media' do |cfg|
22 |     comment cfg
23 |   end
24 | 
25 |   cmd 'show running-config' do |cfg|
26 |     cfg = cfg.each_line.to_a[3..-1].join
27 |     cfg
28 |   end
29 | 
30 |   cfg :telnet do
31 |     username /^Login:/
32 |     password /^Password:/
33 |   end
34 | 
35 |   cfg :telnet, :ssh do
36 |     post_login 'terminal length 0'
37 |     post_login 'terminal width 0'
38 |     if vars :enable
39 |       post_login do
40 |         send "enable\n"
41 |         send vars(:enable) + "\n"
42 |       end
43 |     end
44 |     pre_logout 'exit'
45 |   end
46 | 
47 | end
48 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/catos.rb:
--------------------------------------------------------------------------------
 1 | class Catos < Oxidized::Model
 2 | 
 3 |   prompt /^[\w.@-]+>\s?(\(enable\) )?$/
 4 |   comment '# '
 5 | 
 6 |   cmd :all do |cfg|
 7 |     cfg.each_line.to_a[1..-2].join
 8 |   end
 9 | 
10 |   cmd 'show system' do |cfg|
11 |     cfg = cfg.gsub /(\s+)\d+,\d+:\d+:\d+(\s+)/, '\1X\2'
12 |     comment cfg
13 |   end
14 | 
15 |   cmd 'show version' do |cfg|
16 |     cfg = cfg.gsub /\d+(K)/, 'X\1'
17 |     cfg = cfg.gsub /^(Uptime is ).*/, '\1X'
18 |     comment cfg
19 |   end
20 | 
21 |   cmd 'show conf all' do |cfg|
22 |     cfg = cfg.sub /^(#time: ).*/, '\1X'
23 |     cfg.each_line.drop_while { |line| not line.match /^begin/ }.join
24 |   end
25 | 
26 |   cfg :telnet do
27 |     username /^Username: /
28 |     password /^Password:/
29 |   end
30 | 
31 |   cfg :telnet, :ssh do
32 |     post_login 'set length 0'
33 |     # preferred way to handle additional passwords
34 |     if vars :enable
35 |       post_login do
36 |         send "enable\n"
37 |         cmd vars(:enable)
38 |       end
39 |     end
40 |     pre_logout 'exit'
41 |   end
42 | 
43 | end
44 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/dnos.rb:
--------------------------------------------------------------------------------
 1 | class DNOS  < Oxidized::Model
 2 | 
 3 |   # Force10 DNOS model #
 4 | 
 5 |   comment  '! '
 6 | 
 7 |   cmd :all do |cfg|
 8 |     cfg.each_line.to_a[2..-2].join
 9 |   end
10 | 
11 |   cmd :secret do |cfg| 
12 |     cfg.gsub! /^(snmp-server community).*/, '\\1 <configuration removed>'
13 |     cfg.gsub! /secret (\d+) (\S+).*/, '<secret hidden>'
14 |     cfg
15 |   end
16 | 
17 |   cmd 'show inventory' do |cfg|
18 |     comment cfg
19 |   end
20 | 
21 |   cmd 'show inventory media' do |cfg|
22 |     comment cfg
23 |   end
24 | 
25 |   cmd 'show running-config' do |cfg|
26 |     cfg = cfg.each_line.to_a[3..-1].join
27 |     cfg
28 |   end
29 | 
30 |   cfg :telnet do
31 |     username /^Login:/
32 |     password /^Password:/
33 |   end
34 | 
35 |   cfg :telnet, :ssh do
36 |     if vars :enable
37 |       post_login do
38 |         send "enable\n"
39 |         cmd vars(:enable)
40 |       end
41 |     end
42 |     post_login 'terminal length 0'
43 |     post_login 'terminal width 0'
44 |     pre_logout 'exit'
45 |     pre_logout 'exit'    
46 |   end
47 | 
48 | end
49 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/xos.rb:
--------------------------------------------------------------------------------
 1 | class XOS < Oxidized::Model
 2 | 
 3 |   # Extreme Networks XOS
 4 | 
 5 |   prompt /^*?[\w .-]+# $/
 6 |   comment  '# '
 7 | 
 8 |   cmd :all do |cfg|
 9 |     # xos inserts leading \r characters and other trailing white space.
10 |     # this deletes extraneous \r and trailing white space.
11 |     cfg.each_line.to_a[1..-2].map{|line|line.delete("\r").rstrip}.join("\n") + "\n"
12 |   end
13 | 
14 |   cmd 'show version' do |cfg|
15 |     comment cfg
16 |   end
17 | 
18 |   cmd 'show diagnostics' do |cfg|
19 |     comment cfg
20 |   end
21 | 
22 |   cmd 'show licenses' do |cfg|
23 |     comment cfg
24 |   end
25 | 
26 |   cmd 'show switch'do |cfg|
27 |     comment cfg.each_line.reject { |line| line.match /Time:/ or line.match /boot/i }.join
28 |   end
29 | 
30 |   cmd 'show configuration'
31 | 
32 |   cfg :telnet do
33 |     username /^login:/
34 |     password /^\r*password:/
35 |   end
36 | 
37 |   cfg :telnet, :ssh do
38 |     post_login 'disable clipaging'
39 |     pre_logout do
40 |       send "exit\n"
41 |       send "n\n"
42 |     end
43 |   end
44 | 
45 | end
46 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/mlnxos.rb:
--------------------------------------------------------------------------------
 1 | class MLNXOS < Oxidized::Model
 2 | 
 3 |   prompt /([\w.@()-\[:\s\]]+[#>]\s)$/
 4 |   comment  '## '
 5 |   
 6 |   # Pager Handling
 7 |   expect /.+lines\s\d+\-\d+([\s]|\/\d+\s\(END\)\s).+$/ do |data, re|
 8 |     send ' '
 9 |     data.sub re, ''
10 |   end
11 | 
12 |   cmd :all do |cfg|
13 |     cfg.gsub! /\[\?1h=\r/, '' # Pager Handling
14 |     cfg.gsub! /\r\[K/,'' # Pager Handling
15 |     cfg.gsub! /\s/, '' # Linebreak Handling
16 |     cfg = cfg.lines.to_a[2..-3].join
17 |   end
18 | 
19 |   cmd :secret do |cfg|
20 |     cfg.gsub! /(snmp-server community).*/, '   <snmp-server community configuration removed>'
21 |     cfg.gsub! /username (\S+) password (\d+) (\S+).*/, '<secret hidden>'
22 |     cfg
23 |   end
24 | 
25 |   cmd 'show version' do |cfg|
26 |     comment cfg
27 |   end
28 | 
29 |   cmd 'show inventory' do |cfg|
30 |     comment cfg
31 |   end
32 | 
33 |   cmd 'enable'
34 | 
35 |   cmd 'show running-config' do |cfg|
36 |     cfg
37 |   end
38 | 
39 |   cfg :ssh do
40 |     password /^Password:\s*/
41 |     pre_logout 'exit'
42 |   end
43 | end
44 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/iosxr.rb:
--------------------------------------------------------------------------------
 1 | class IOSXR < Oxidized::Model
 2 | 
 3 |   # IOS XR model #
 4 | 
 5 |   prompt /^(\r?[\w.@:\/-]+[#>]\s?)$/
 6 |   comment  '! '
 7 | 
 8 |   cmd :all do |cfg|
 9 |     cfg.each_line.to_a[2..-2].join
10 |   end
11 | 
12 |   cmd :secret do |cfg| 
13 |     cfg.gsub! /^(snmp-server community).*/, '\\1 <configuration removed>'
14 |     cfg.gsub! /secret (\d+) (\S+).*/, '<secret hidden>'
15 |     cfg
16 |   end
17 | 
18 |   cmd 'show inventory' do |cfg|
19 |     comment cfg
20 |   end
21 | 
22 |   cmd 'show platform' do |cfg|
23 |     comment cfg
24 |   end
25 | 
26 |   cmd 'show running-config' do |cfg|
27 |     cfg = cfg.each_line.to_a[3..-1].join
28 |     cfg
29 |   end
30 | 
31 |   cfg :telnet do
32 |     username /^Username:/
33 |     password /^\r?Password:/
34 |   end
35 | 
36 |   cfg :telnet, :ssh do
37 |     post_login 'terminal length 0'
38 |     post_login 'terminal width 0'
39 |     if vars :enable
40 |       post_login do
41 |         send "enable\n"
42 |         send vars(:enable) + "\n"
43 |       end
44 |     end
45 |     pre_logout 'exit'
46 |   end
47 | 
48 | end
49 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/masteros.rb:
--------------------------------------------------------------------------------
 1 | class MasterOS < Oxidized::Model
 2 | 
 3 |   # MRV MasterOS model #
 4 | 
 5 | comment '!'
 6 | 
 7 |   cmd :secret do |cfg|
 8 |     cfg.gsub! /^(snmp-server community).*/, '\\1 <configuration removed>'
 9 |     cfg.gsub! /username (\S+) password encrypted (\S+) class (\S+).*/, '<secret hidden>'
10 |     cfg
11 |   end
12 | 
13 |   cmd :all do |cfg|
14 |     cfg.each_line.to_a[1..-2].join
15 |     cfg.gsub /^(! Configuration ).*/, '!'
16 |   end
17 | 
18 |   cmd 'show inventory' do |cfg|
19 |     cfg = cfg.each_line.to_a[0..-2].join
20 |     comment cfg
21 |   end
22 | 
23 |   cmd 'show plugins' do |cfg|
24 |     comment cfg
25 |   end
26 | 
27 |   cmd 'show hw-config' do |cfg|
28 |     comment cfg
29 |   end
30 | 
31 |   cmd 'show running-config' do |cfg|
32 |     cfg = cfg.each_line.to_a[3..-1].join
33 |     cfg
34 |   end
35 | 
36 |   cfg :telnet, :ssh do
37 |     post_login 'no pager'
38 |     if vars :enable
39 |       post_login do
40 |         send "enable\n"
41 |         send vars(:enable) + "\n"
42 |       end
43 |     end
44 |     pre_logout 'exit'
45 |   end
46 | 
47 | end
48 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/screenos.rb:
--------------------------------------------------------------------------------
 1 | class ScreenOS  < Oxidized::Model
 2 | 
 3 |   # Netscreen ScreenOS model #
 4 | 
 5 |   comment  '! '
 6 | 
 7 |   prompt /^[\w.:\(\)-]+->\s?$/
 8 | 
 9 |   cmd :all do |cfg|
10 |     cfg.each_line.to_a[2..-2].join
11 |   end
12 | 
13 |   cmd :secret do |cfg| 
14 |     cfg.gsub! /^(set admin name) .*|^(set admin password) .*/, '\\1 <removed>'
15 |     cfg.gsub! /^(set admin user .* password) .* (.*)/, '\\1 <removed> \\2'
16 |     cfg.gsub! /(secret|password|preshare) .*/, '\\1 <secret hidden>'
17 |     cfg
18 |   end
19 | 
20 |   cmd 'get system' do |cfg|
21 |     cfg.gsub! /^Date\ .*\n/, ''
22 |     cfg.gsub! /^Up\ .*\n/, ''
23 |     cfg.gsub! /(current bw ).*/, '\\1 <removed>'
24 |     comment cfg
25 |   end
26 | 
27 |   cmd 'get config' do |cfg|
28 |     cfg = cfg.each_line.to_a[3..-1].join
29 |     cfg
30 |   end
31 | 
32 |   cfg :telnet do
33 |     username '/^login:/'
34 |     password '/^password:/'
35 |   end
36 | 
37 |   cfg :telnet, :ssh do
38 |     post_login 'set console page 0'
39 |     pre_logout do
40 |       send "exit\n"
41 |       send "n"
42 |     end
43 |   end
44 | 
45 | end
46 | 


--------------------------------------------------------------------------------
/TODO.md:
--------------------------------------------------------------------------------
 1 | # refactor core
 2 |   * move state from memory to disk, sqlite probably
 3 |   * allows us to retain stats etc over restart
 4 |   * simplifies code
 5 |   * keep only running nodes in memory
 6 |   * negligible I/O cost, as majority is I/O wait getting config
 7 | 
 8 | # separate login to owon package
 9 |   * oxidized-script is not only use-case
10 |   * it would be good to have minimal package used to login to routers
11 |   * oxidized just one consumer of that functionality
12 |   * what to do with models, we need model to know how to login. Should models be separated to another package? oxidized-core, oxidized-models and oxidized-login?
13 |   * how can we allow interactive login in oxidized-login? With functional VTY etc? REPL loop in input/ssh and input/telnet?
14 | 
15 | # thread number
16 |   * think about algo
17 |   * if job ended later than now-iteration have rand(node.size) == 0 to add thread
18 |   * if now is less than job_ended+iteration same chance to remove thread?
19 |   * should we try to avoid max threads from being hit? (like maybe non-success thread is pulling average?)
20 | 
21 | # docs, testing
22 |   * yard docs
23 |   * minitest tests
24 | 


--------------------------------------------------------------------------------
/lib/oxidized/input/tftp.rb:
--------------------------------------------------------------------------------
 1 | module Oxidized
 2 |   require 'stringio'
 3 |   require_relative 'cli'
 4 |   
 5 |   begin
 6 |     require 'net/tftp'
 7 |   rescue LoadError
 8 |     raise OxidizedError, 'net/tftp not found: sudo gem install net-tftp'
 9 |   end
10 |   
11 |   class TFTP < Input
12 |     
13 |     include Input::CLI
14 |     
15 |     # TFTP utilizes UDP, there is not a connection. We simply specify an IP and send/receive data.
16 |     def connect node
17 |       @node       = node
18 | 
19 |       @node.model.cfg['tftp'].each { |cb| instance_exec(&cb) }
20 |       @log = File.open(Oxidized::Config::Log + "/#{@node.ip}-tftp", 'w') if Oxidized.config.input.debug?
21 |       @tftp = Net::TFTP.new @node.ip
22 |     end
23 | 
24 |     def cmd file
25 |       Oxidized.logger.debug "TFTP: #{file} @ #{@node.name}"
26 |       config = StringIO.new
27 |       @tftp.getbinary file, config
28 |       config.rewind
29 |       config.read
30 |     end
31 |     
32 |     private
33 |     
34 |     def disconnect
35 |       # TFTP uses UDP, there is no connection to close
36 |     ensure
37 |       @log.close if Oxidized.config.input.debug?
38 |     end
39 | 
40 |   end
41 | end
42 | 


--------------------------------------------------------------------------------
/lib/oxidized/core.rb:
--------------------------------------------------------------------------------
 1 | module Oxidized
 2 |   class << self
 3 |     def new *args
 4 |       Core.new args
 5 |     end
 6 |   end
 7 | 
 8 |   class Core
 9 |     class NoNodesFound < OxidizedError; end
10 | 
11 |     def initialize args
12 |       Oxidized.mgr = Manager.new
13 |       Oxidized.Hooks = HookManager.from_config(Oxidized.config)
14 |       nodes        = Nodes.new
15 |       raise NoNodesFound, 'source returns no usable nodes' if nodes.size == 0
16 |       @worker      = Worker.new nodes
17 |       trap('HUP') { nodes.load }
18 |       if Oxidized.config.rest?
19 |         begin
20 |           require 'oxidized/web'
21 |         rescue LoadError
22 |           raise OxidizedError, 'oxidized-web not found: sudo gem install oxidized-web - \
23 |           or disable web support by setting "rest: false" in your configuration'
24 |         end
25 |         @rest        = API::Web.new nodes, Oxidized.config.rest
26 |         @rest.run
27 |       end
28 |       run
29 |     end
30 | 
31 |     private
32 | 
33 |     def run
34 |       Oxidized.logger.debug "lib/oxidized/core.rb: Starting the worker..."
35 |       while true
36 |         @worker.work
37 |         sleep Config::Sleep
38 |       end
39 |     end
40 |   end
41 | end
42 | 


--------------------------------------------------------------------------------
/lib/oxidized/hook/slackdiff.rb:
--------------------------------------------------------------------------------
 1 | require 'slack'
 2 | 
 3 | class SlackDiff < Oxidized::Hook
 4 |   def validate_cfg!
 5 |     raise KeyError, 'hook.token is required' unless cfg.has_key?('token')
 6 |     raise KeyError, 'hook.channel is required' unless cfg.has_key?('channel')
 7 |   end
 8 | 
 9 |   def run_hook(ctx)
10 |     if ctx.node
11 |       if ctx.event.to_s == "post_store"
12 |         log "Connecting to slack"
13 |         client = Slack::Client.new token: cfg.token
14 |         client.auth_test
15 |         log "Connected"
16 |         gitoutput = ctx.node.output.new
17 |         diff = gitoutput.get_diff ctx.node, ctx.node.group, ctx.commitref, nil
18 |         title = "#{ctx.node.name.to_s} #{ctx.node.group.to_s} #{ctx.node.model.class.name.to_s.downcase}"
19 |         log "Posting diff as snippet to #{cfg.channel}"
20 |         client.files_upload(channels: cfg.channel, as_user: true,
21 |                              content: diff[:patch].lines.to_a[4..-1].join,
22 |                              filetype: "diff",
23 |                              title: title,
24 |                              filename: "change"
25 |                             )
26 |         log "Finished"
27 |       end
28 |     end
29 |   end
30 | end
31 | 


--------------------------------------------------------------------------------
/extra/rest_client.rb:
--------------------------------------------------------------------------------
 1 | module Oxidized
 2 |   class RestClient
 3 |     require 'net/http'
 4 |     require 'json'
 5 |     require 'uri'
 6 |     require 'asetus'
 7 | 
 8 |     class Config
 9 |       Root      = Root = ENV['OXIDIZED_HOME'] || File.join(ENV['HOME'], '.config', 'oxidized')
10 |     end
11 | 
12 |     CFGS = Asetus.new :name=>'oxidized', :load=>false, :key_to_s=>true
13 |     CFGS.default.rest = '127.0.0.1:8888'
14 | 
15 |     begin
16 |       CFGS.load
17 |     rescue => error
18 |       raise InvalidConfig, "Error loading config: #{error.message}"
19 |     end
20 | 
21 |     restcfg = CFGS.cfg.rest
22 |     unless restcfg.match(/^http:\/\//)
23 |       restcfg.insert(0, 'http://')
24 |     end
25 | 
26 |     HOST = URI(restcfg).host
27 |     PORT = URI(restcfg).port
28 |     PATH = URI(restcfg).path
29 | 
30 |     class << self
31 |       def next opt={}, host=HOST, port=PORT
32 |         web = new host, port
33 |         web.next opt
34 |       end
35 |     end
36 | 
37 |     def initialize host=HOST, port=PORT
38 |       @web = Net::HTTP.new host, port
39 |     end
40 | 
41 |     def next opt
42 |       data = JSON.dump opt
43 |       @web.put PATH + '/node/next/' + opt[:name].to_s, data
44 |     end
45 | 
46 |   end
47 | end
48 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/cx.rb:
--------------------------------------------------------------------------------
 1 | class CX < Oxidized::Model
 2 | 
 3 |   # Infinera Cloud Xpress model #
 4 | 
 5 |   prompt /(^.*[#>] .*$)|(^Login:$)/
 6 | 
 7 |   comment '! '
 8 | 
 9 |   expect /^\s*-- More --\s+.*$/ do |data, re|
10 |     send ' '
11 |     data.sub re, ''
12 |   end
13 | 
14 |   cmd :all do |cfg|
15 |     cfg.each_line.to_a[1..-2].join
16 |   end
17 | 
18 |   cmd :secret do |cfg|
19 |     cfg.gsub! /^(\s+ community).*/, '\\1 <configuration removed>'
20 |     cfg
21 |   end
22 | 
23 |   cmd 'show inventory' do |cfg|
24 |     comment cfg
25 |   end
26 | 
27 |   cmd 'show running-config' do |cfg|
28 |     cfg
29 |   end
30 | 
31 |   cfg :telnet, :ssh do
32 |     # save username and password for second login
33 |     auth = self.node.auth.dup
34 | 
35 |     # set node auth for first login
36 |     self.node.auth[:username] = 'cliuser'
37 |     self.node.auth[:password] = nil
38 | 
39 |     if vars :enable
40 |       post_login do
41 |         send auth[:username] + "\n"
42 |         expect /^Enter Password :\s+$/
43 |         send auth[:password] + "\n"
44 |         expect /.*Password ExpireDays.*/
45 |         send "enable\n"
46 |         expect self.node.prompt
47 |       end
48 |     end
49 |     pre_logout 'exit'
50 |   end
51 | 
52 | end
53 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/br6910.rb:
--------------------------------------------------------------------------------
 1 | 
 2 | class BR6910 < Oxidized::Model
 3 | 
 4 |   prompt /^Vty-[0-9]\#$/
 5 |   comment  '! '
 6 | 
 7 |   # not possible to disable paging prior to show running-config
 8 |   expect /^((.*)Others to exit ---(.*))$/ do |data, re|
 9 |     send 'a'
10 |     data.sub re, ''
11 |   end
12 | 
13 |   cmd :all do |cfg|
14 |     # sometimes br6910s inserts arbitrary whitespace after commands are
15 |     # issued on the CLI, from run to run.  this normalises the output.
16 |     cfg.each_line.to_a[1..-2].drop_while { |e| e.match /^\s+$/ }.join
17 |   end
18 | 
19 |   cmd 'show version' do |cfg|
20 |     comment cfg
21 |   end
22 | 
23 |   # show flash is not possible on a brocade 6910, do dir instead 
24 |   # to see flash contents (includes config file names)
25 |   cmd 'dir' do |cfg|
26 |     comment cfg
27 |   end
28 | 
29 |   cmd 'show running-config' do |cfg|
30 |     arr = cfg.each_line.to_a
31 |     arr[2..-1].join unless arr.length < 2
32 |   end
33 | 
34 |   cfg :telnet do
35 |     username /^Username:/
36 |     password /^Password:/
37 |   end
38 | 
39 |   # post login and post logout 
40 |   cfg :telnet, :ssh do
41 |     post_login ''
42 |     pre_logout 'exit'
43 |   end
44 | 
45 | end
46 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/eos.rb:
--------------------------------------------------------------------------------
 1 | class EOS < Oxidized::Model
 2 | 
 3 |   # Arista EOS model #
 4 | 
 5 |   prompt /^.+[#>]\s?$/
 6 | 
 7 |   comment  '! '
 8 | 
 9 |   cmd :all do |cfg|
10 |      cfg.each_line.to_a[1..-2].join
11 |   end
12 | 
13 |   cmd :secret do |cfg|
14 |      cfg.gsub! /^(snmp-server community).*/, '\\1 <configuration removed>'
15 |      cfg.gsub! /username (\S+) privilege (\d+) (\S+).*/, '<secret hidden>'
16 |      cfg.gsub! /^(enable secret).*/, '\\1 <configuration removed>'
17 |      cfg.gsub! /^(tacacs-server key \d+).*/, '\\1 <configuration removed>'
18 |      cfg
19 |   end
20 | 
21 |   cmd 'show inventory | no-more' do |cfg|
22 |     comment cfg
23 |   end
24 | 
25 |   cmd 'show running-config | no-more | exclude ! Time:' do |cfg|
26 |     cfg
27 |   end
28 | 
29 |   cfg :telnet, :ssh do
30 |     if vars :enable
31 |       post_login do
32 |         send "enable\n"
33 |         # Interpret enable: true as meaning we won't be prompted for a password
34 |         unless vars(:enable).is_a? TrueClass
35 |           expect /[pP]assword:\s?$/
36 |           send vars(:enable) + "\n"
37 |         end
38 |         expect /^.+[#>]\s?$/
39 |       end
40 |       post_login 'terminal length 0'
41 |     end
42 |     pre_logout 'exit'
43 |   end
44 | 
45 | end
46 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | *.gem
 2 | *.rbc
 3 | /.config
 4 | /coverage/
 5 | /InstalledFiles
 6 | /pkg/
 7 | /spec/reports/
 8 | /spec/examples.txt
 9 | /test/tmp/
10 | /test/version_tmp/
11 | /tmp/
12 | 
13 | # Used by dotenv library to load environment variables.
14 | # .env
15 | 
16 | ## Specific to RubyMotion:
17 | .dat*
18 | .repl_history
19 | build/
20 | *.bridgesupport
21 | build-iPhoneOS/
22 | build-iPhoneSimulator/
23 | 
24 | ## Specific to RubyMotion (use of CocoaPods):
25 | #
26 | # We recommend against adding the Pods directory to your .gitignore. However
27 | # you should judge for yourself, the pros and cons are mentioned at:
28 | # https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
29 | #
30 | # vendor/Pods/
31 | 
32 | ## Documentation cache and generated files:
33 | /.yardoc/
34 | /_yardoc/
35 | /doc/
36 | /rdoc/
37 | 
38 | ## Environment normalization:
39 | /.bundle/
40 | /vendor/bundle
41 | /lib/bundler/man/
42 | 
43 | # for a library or gem, you might want to ignore these files since the code is
44 | # intended to run in multiple environments; otherwise, check them in:
45 | # Gemfile.lock
46 | # .ruby-version
47 | # .ruby-gemset
48 | 
49 | # unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
50 | .rvmrc
51 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/casa.rb:
--------------------------------------------------------------------------------
 1 | class Casa < Oxidized::Model
 2 |   # Casa Systems CMTS
 3 | 
 4 |   prompt /^([\w.@()-]+[#>]\s?)$/
 5 |   comment '! '
 6 | 
 7 |   cmd :secret do |cfg|
 8 |     cfg.gsub! /^(snmp community) \S+/, '\\1 <configuration removed>'
 9 |     cfg.gsub! /^(snmp comm-tbl) \S+ \S+/, '\\1 <removed> <removed>'
10 |     cfg.gsub! /^(console-password encrypted) \S+/, '\\1 <secret hidden>'
11 |     cfg.gsub! /^(password encrypted) \S+/, '\\1 <secret hidden>'
12 |     cfg.gsub! /^(tacacs-server key) \S+/, '\\1 <secret hidden>'
13 |     cfg
14 |   end
15 | 
16 |   cmd :all do |cfg|
17 |     cfg.each_line.to_a[1..-2].join
18 |   end
19 | 
20 |   cmd 'show system' do |cfg|
21 |     comment cfg.each_line.reject { |line| line.match /^\s+System (Time|Uptime): / }.join
22 |   end
23 | 
24 |   cmd 'show version' do |cfg|
25 |     comment cfg
26 |   end
27 | 
28 |   cmd 'show run'
29 | 
30 |   cfg :telnet do
31 |     username /^Username:/
32 |     password /^Password:/
33 |   end
34 | 
35 |   cfg :telnet, :ssh do
36 |     post_login 'page-off'
37 |     # preferred way to handle additional passwords
38 |     if vars :enable
39 |       post_login do
40 |         send "enable\n"
41 |         cmd vars(:enable)
42 |       end
43 |     end
44 |     pre_logout 'logout'
45 |   end
46 | end
47 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/gaiaos.rb:
--------------------------------------------------------------------------------
 1 | class GaiaOS < Oxidized::Model
 2 | 
 3 |   # CheckPoint - Gaia OS Model
 4 |   
 5 |   # Gaia Prompt
 6 |   prompt /^([\[\]\w.@:-]+[#>]\s?)$/
 7 | 
 8 |   # Comment tag
 9 |   comment  '# '
10 | 
11 | 
12 |   cmd :all do |cfg|
13 |     cfg = cfg.each_line.to_a[1..-2].join
14 |   end
15 | 
16 |   cmd :secret do |cfg|
17 |     cfg.gsub! /^(set expert-password-hash ).*/, '\1<EXPERT PASSWORD REMOVED>'
18 |     cfg.gsub! /^(set user \S+ password-hash ).*/,'\1<USER PASSWORD REMOVED>'
19 |     cfg.gsub! /^(set ospf .* secret ).*/,'\1<OSPF KEY REMOVED>'
20 |     cfg.gsub! /^(set snmp community )(.*)( read-only.*)/,'\1<SNMP COMMUNITY REMOVED>\3'
21 |     cfg.gsub! /^(add snmp .* community )(.*)(\S?.*)/,'\1<SNMP COMMUNITY REMOVED>\3'
22 |     cfg.gsub! /(auth|privacy)(-pass-phrase-hashed )(\S*)/,'\1-pass-phrase-hashed <SNMP PASS-PHRASE REMOVED>'
23 |     cfg
24 |   end
25 | 
26 |   cmd 'show asset all' do |cfg|
27 |     comment cfg
28 |   end
29 | 
30 |   cmd 'show version all' do |cfg|
31 |     comment cfg
32 |   end
33 | 
34 |   cmd 'show configuration' do |cfg|
35 |     cfg.gsub! /^# Exported by \S+ on .*/, '# '
36 |     cfg
37 |   end
38 | 
39 | 
40 |   cfg :ssh do
41 |     # User shell must be /etc/cli.sh
42 |     post_login 'set clienv rows 0'
43 |     pre_logout 'exit'
44 |   end
45 | 
46 | end
47 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/aireos.rb:
--------------------------------------------------------------------------------
 1 | class Aireos < Oxidized::Model
 2 | 
 3 |   # AireOS (at least I think that is what it's called, hard to find data)
 4 |   # Used in Cisco WLC 5500
 5 | 
 6 |   comment  '# '     ## this complains too, can't find real comment char
 7 |   prompt /^\([^\)]+\)\s>/
 8 | 
 9 |   cmd :all do |cfg|
10 |     cfg.each_line.to_a[1..-2].join
11 |   end
12 | 
13 |   ##show sysinfo?
14 |   ##show switchconfig?
15 | 
16 |   cmd 'show udi' do |cfg|
17 |     cfg = comment clean cfg
18 |     cfg << "\n"
19 |   end
20 | 
21 |   cmd 'show boot' do |cfg|
22 |     cfg = comment clean cfg
23 |     cfg << "\n"
24 |   end
25 | 
26 |   cmd 'show run-config commands' do |cfg|
27 |     clean cfg
28 |   end
29 | 
30 |   cfg :telnet, :ssh do
31 |     username /^User:\s*/
32 |     password /^Password:\s*/
33 |     post_login 'config paging disable'
34 |   end
35 | 
36 |   cfg :telnet, :ssh do
37 |     pre_logout do
38 |       send "logout\n"
39 |       send "n"
40 |     end
41 |   end
42 | 
43 |   def clean cfg
44 |     out = []
45 |     cfg.each_line do |line|
46 |       next if line.match /^\s*$/
47 |       next if line.match /rogue (adhoc|client) alert [\da-f]{2}:/
48 |       line = line[1..-1] if line[0] == "\r"
49 |       out << line.strip
50 |     end
51 |     out = out.join "\n"
52 |     out << "\n"
53 |   end
54 | 
55 | end
56 | 


--------------------------------------------------------------------------------
/lib/oxidized/input/ftp.rb:
--------------------------------------------------------------------------------
 1 | module Oxidized
 2 |   require 'net/ftp'
 3 |   require 'timeout'
 4 |   require_relative 'cli'
 5 | 
 6 |   class FTP < Input
 7 |     RescueFail = {
 8 |       :debug => [
 9 |         #Net::SSH::Disconnect,
10 |       ],
11 |       :warn => [
12 |         #RuntimeError,
13 |         #Net::SSH::AuthenticationFailed,
14 |       ],
15 |     }
16 |     include Input::CLI
17 | 
18 |     def connect node
19 |       @node       = node
20 |       @node.model.cfg['ftp'].each { |cb| instance_exec(&cb) }
21 |       @log = File.open(Oxidized::Config::Log + "/#{@node.ip}-ftp", 'w') if Oxidized.config.input.debug?
22 |       @ftp = Net::FTP.new @node.ip, @node.auth[:username], @node.auth[:password]
23 |       connected?
24 |     end
25 | 
26 |     def connected?
27 |       @ftp and not @ftp.closed?
28 |     end
29 | 
30 |     def cmd file
31 |       Oxidized.logger.debug "FTP: #{file} @ #{@node.name}"
32 |       @ftp.getbinaryfile file, nil
33 |     end
34 | 
35 |     # meh not sure if this is the best way, but perhaps better than not implementing send
36 |     def send my_proc
37 |       my_proc.call
38 |     end
39 | 
40 |     def output
41 |       ""
42 |     end
43 | 
44 |     private
45 | 
46 |     def disconnect
47 |       @ftp.close
48 |     #rescue Errno::ECONNRESET, IOError
49 |     ensure
50 |       @log.close if Oxidized.config.input.debug?
51 |     end
52 | 
53 |   end
54 | end
55 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/junos.rb:
--------------------------------------------------------------------------------
 1 | class JunOS < Oxidized::Model
 2 | 
 3 |   comment  '# '
 4 | 
 5 |   def telnet
 6 |     @input.class.to_s.match(/Telnet/)
 7 |   end
 8 | 
 9 |   cmd :all do |cfg|
10 |     cfg = cfg.lines.to_a[1..-2].join if screenscrape
11 |     cfg.lines.map { |line| line.rstrip }.join("\n") + "\n"
12 |   end
13 | 
14 |   cmd :secret do |cfg|
15 |     cfg.gsub!(/encrypted-password (\S+).*/, '<secret removed>')
16 |     cfg.gsub!(/community (\S+) {/, 'community <hidden> {')
17 |     cfg
18 |   end
19 | 
20 |   cmd 'show configuration | display omit'
21 | 
22 |   cmd 'show version' do |cfg|
23 |     @model = $1 if cfg.match(/^Model: (\S+)/)
24 |     comment cfg
25 |   end
26 | 
27 |   post do
28 |     out = ''
29 |     case @model
30 |     when 'mx960'
31 |       out << cmd('show chassis fabric reachability')  { |cfg| comment cfg }
32 |     when /^(ex22|ex33|ex4|ex8|qfx)/
33 |       out << cmd('show virtual-chassis') { |cfg| comment cfg }
34 |     end
35 |     out
36 |   end
37 | 
38 |   cmd('show chassis hardware') { |cfg| comment cfg }
39 | 
40 |   cfg :telnet do
41 |     username(/^login:/)
42 |     password(/^Password:/)
43 |   end
44 | 
45 |   cfg :ssh do
46 |     exec true  # don't run shell, run each command in exec channel
47 |   end
48 | 
49 |   cfg :telnet, :ssh do
50 |     post_login 'set cli screen-length 0'
51 |     post_login 'set cli screen-width 0'
52 |     pre_logout 'exit'
53 |   end
54 | 
55 | end
56 | 


--------------------------------------------------------------------------------
/lib/oxidized.rb:
--------------------------------------------------------------------------------
 1 | require 'fileutils'
 2 | 
 3 | module Oxidized
 4 |   class OxidizedError < StandardError; end
 5 | 
 6 |   Directory = File.expand_path(File.join(File.dirname(__FILE__), '../'))
 7 | 
 8 |   require 'oxidized/version'
 9 |   require 'oxidized/string'
10 |   require 'oxidized/config'
11 |   require 'oxidized/config/vars'
12 |   require 'oxidized/worker'
13 |   require 'oxidized/nodes'
14 |   require 'oxidized/manager'
15 |   require 'oxidized/hook'
16 |   require 'oxidized/core'
17 | 
18 |   def self.asetus
19 |     @@asetus
20 |   end
21 | 
22 |   def self.asetus=(val)
23 |     @@asetus = val
24 |   end
25 | 
26 |   def self.config
27 |     asetus.cfg
28 |   end
29 | 
30 |   def self.logger
31 |     @@logger
32 |   end
33 | 
34 |   def self.logger=(val)
35 |     @@logger = val
36 |   end
37 | 
38 |   def self.setup_logger
39 |     FileUtils.mkdir_p(Config::Log) unless File.directory?(Config::Log)
40 |     self.logger = if config.has_key?('use_syslog') && config.use_syslog
41 |                     require 'syslog/logger'
42 |                     Syslog::Logger.new('oxidized')
43 |                   else
44 |                     require 'logger'
45 |                     if config.has_key?('log')
46 |                       Logger.new(File.expand_path(config.log))
47 |                     else
48 |                       Logger.new(STDERR)
49 |                     end
50 |                   end
51 |     logger.level = Logger::INFO unless config.debug
52 |   end
53 | end
54 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/c4cmts.rb:
--------------------------------------------------------------------------------
 1 | class C4CMTS < Oxidized::Model
 2 | 
 3 |   # Arris C4 CMTS
 4 | 
 5 |   prompt /^([\w.@:\/-]+[#>]\s?)$/
 6 |   comment  '! '
 7 | 
 8 |   cmd :all do |cfg|
 9 |     cfg.each_line.to_a[1..-2].map{|line|line.delete("\r").rstrip}.join("\n") + "\n"
10 |   end
11 | 
12 |   cmd :secret do |cfg| 
13 |     cfg.gsub! /(.+)\s+encrypted-password\s+\w+\s+(.*)/, '\\1 <secret hidden> \\2'
14 |     cfg.gsub! /(snmp-server community)\s+".*"\s+(.*)/, '\\1 <secret hidden> \\2'
15 |     cfg.gsub! /(tacacs.*\s+key)\s+".*"\s+(.*)/, '\\1 <secret hidden> \\2'
16 |     cfg.gsub! /(cable authstring)\s+\w+\s+(.*)/, '\\1 <secret hidden> \\2'
17 |     cfg
18 |   end
19 | 
20 |   cmd 'show environment' do |cfg|
21 |     cfg.gsub! /\s+[\-\d]+\s+C\s+[\(\s\d]+\s+\F\)/, ''	# remove temperature readings
22 |     cfg.each_line.to_a[1..-2].join
23 |     comment cfg
24 |   end
25 | 
26 |   cmd 'show version' do |cfg|
27 |     # remove uptime readings at char 55 and beyond
28 |     cfg = cfg.each_line.map{|line|line.rstrip.slice(0..54)}.join("\n") + "\n"
29 |     comment cfg
30 |   end
31 | 
32 |   cmd 'show running-config' do |cfg|
33 |     cfg = cfg.each_line.to_a[1..-2].join
34 |     cfg
35 |   end
36 | 
37 |   cfg :telnet do
38 |     username /^Username:/
39 |     password /^Password:/
40 |   end
41 | 
42 |   cfg :telnet, :ssh do
43 |     if vars :enable
44 |       post_login do
45 |         send "enable\n"
46 |         send vars(:enable) + "\n"
47 |       end
48 |     end
49 |     pre_logout 'exit'
50 |   end
51 | 
52 | end
53 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/hatteras.rb:
--------------------------------------------------------------------------------
 1 | class Hatteras < Oxidized::Model
 2 |   # Hatteras Networks
 3 | 
 4 |   prompt /^(\r?[\w.@()-]+[#>]\s?)$/
 5 |   comment '# '
 6 | 
 7 |   expect /WARNING: System configuration changes will be lost when the device restarts./ do |data, re|
 8 |     send "y\r"
 9 |     data.sub re, ''
10 |   end
11 | 
12 | 
13 |   cmd :secret do |cfg|
14 |     cfg.gsub! /^(community) \S+/, '\\1 "<configuration removed>"'
15 |     cfg.gsub! /^(communityString) "\S+"/, '\\1 "<configuration removed>"'
16 |     cfg.gsub! /^(key) "\S+"/, '\\1 "<secret hidden>"'
17 |     cfg
18 |   end
19 | 
20 |   cmd :all do |cfg|
21 |     cfg.each_line.to_a[1..-2].join
22 |   end
23 | 
24 |   cmd "show switch\r" do |cfg|
25 |     cfg = cfg.each_line.reject { |line| line.match /Switch uptime|Switch temperature|Last reset reason/ or
26 |                                           line.match /TermCpuUtil|^\s+\^$|ERROR: Bad command/ }.join
27 |     comment cfg
28 |   end
29 | 
30 |   cmd "show card\r" do |cfg|
31 |     cfg = cfg.each_line.reject { |line| line.match /Card uptime|Card temperature|Last reset reason/ or
32 |                                           line.match /TermCpuUtil|^\s+\^$|ERROR: Bad command/ }.join
33 |     comment cfg
34 |   end
35 | 
36 |   cmd "show sfp *\r" do |cfg|
37 |     comment cfg
38 |   end
39 | 
40 |   cmd "show config run\r" do |cfg|
41 |     cfg
42 |   end
43 | 
44 |   cfg :telnet do
45 |     username /^Login:/
46 |     password /^Password:/
47 |   end
48 | 
49 |   cfg :telnet, :ssh do
50 |     pre_logout "logout\r"
51 |   end
52 | end
53 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/ciscosmb.rb:
--------------------------------------------------------------------------------
 1 | class CiscoSMB < Oxidized::Model
 2 | 
 3 |   # Cisco Small Business 200, 300, 500, and ESW2 series switches
 4 |   # http://www.cisco.com/c/en/us/support/switches/small-business-300-series-managed-switches/products-release-notes-list.html
 5 | 
 6 |   prompt /^\r?([\w.@()-]+[#>]\s?)$/
 7 |   comment  '! '
 8 | 
 9 |   cmd :all do |cfg|
10 |     lines = cfg.each_line.to_a[1..-2]
11 |     # Remove \r from beginning of response
12 |     lines[0].gsub!(/^\r.*?/, '') if lines.length > 0
13 |     lines.join
14 |   end
15 | 
16 |   cmd :secret do |cfg|
17 |     cfg.gsub! /^(snmp-server community).*/, '\\1 <configuration removed>'
18 |     cfg.gsub! /username (\S+) privilege (\d+) (\S+).*/, '<secret hidden>'
19 |     cfg
20 |   end
21 | 
22 |   cmd 'show version' do |cfg|
23 |     comment cfg
24 |   end
25 | 
26 |   cmd 'show running-config' do |cfg|
27 |     cfg = cfg.each_line.to_a[0..-1].join
28 |     cfg.gsub! /^Current configuration : [^\n]*\n/, ''
29 |     cfg.sub! /^(ntp clock-period).*/, '! \1'
30 |     cfg.gsub! /^\ tunnel\ mpls\ traffic-eng\ bandwidth[^\n]*\n*(
31 |                   (?:\ [^\n]*\n*)*
32 |                   tunnel\ mpls\ traffic-eng\ auto-bw)/mx, '\1'
33 |     cfg
34 |   end
35 | 
36 |   cfg :telnet, :ssh do
37 |     username /^User ?[nN]ame:/
38 |     password /^\r?Password:$/
39 |     post_login 'terminal datadump' # Disable pager
40 |     post_login 'terminal width 0'
41 |     post_login 'terminal len 0'
42 |     pre_logout 'exit' #exit returns to previous priv level, no way to quit from exec(#)
43 |     pre_logout 'exit'
44 |   end
45 | 
46 | end
47 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/aos7.rb:
--------------------------------------------------------------------------------
 1 | class AOS7 < Oxidized::Model
 2 | 
 3 |   # Alcatel-Lucent Operating System Version 7 (Linux based)
 4 |   # used in OmniSwitch 6900/10k
 5 |  
 6 |   comment  '! '
 7 | 
 8 |   cmd :all do |cfg, cmdstring|
 9 |     new_cfg = comment "COMMAND: #{cmdstring}\n"
10 |     new_cfg << cfg.each_line.to_a[1..-2].join
11 |   end
12 | 
13 |   cmd 'show system' do |cfg|
14 |     cfg = cfg.each_line.find{|line|line.match 'Description'}
15 |     comment cfg.to_s.strip + "\n"
16 |   end
17 | 
18 |   cmd 'show chassis' do |cfg|
19 |     # check for virtual chassis existence
20 |     @slave_vcids = cfg.scan(/Chassis ID (\d+) \(Slave\)/).flatten
21 |     @master_vcid = $1 if cfg.match /Chassis ID (\d+) \(Master\)/
22 |     comment cfg
23 |   end
24 | 
25 |   cmd 'show hardware-info' do |cfg|
26 |     comment cfg
27 |   end
28 | 
29 |   cmd 'show running-directory' do |cfg|
30 |     comment cfg
31 |   end
32 | 
33 |   cmd 'show configuration snapshot' do |cfg|
34 |     cfg
35 |   end
36 | 
37 |   pre do
38 |     cfg = []
39 |     if @master_vcid
40 |       # add slave VC boot config as comment
41 |       @slave_vcids.each do |id|
42 |         cfg << comment("vc_boot.cfg for slave chassis #{id}")
43 |         cfg << comment(cmd("show configuration vcm-snapshot chassis-id #{id}"))
44 |       end
45 |       cfg << cmd("show configuration vcm-snapshot chassis-id #{@master_vcid}")
46 |     end
47 |     cfg.join "\n"
48 |   end
49 | 
50 |   cfg :telnet do
51 |     username /^login : /
52 |     password /^Password : /
53 |   end
54 | 
55 |   cfg :telnet, :ssh do
56 |     pre_logout 'exit'
57 |   end
58 | end
59 | 


--------------------------------------------------------------------------------
/spec/input/ssh_spec.rb:
--------------------------------------------------------------------------------
 1 | require 'spec_helper'
 2 | require 'oxidized/input/ssh'
 3 | 
 4 | describe Oxidized::SSH do
 5 |   before(:each) do
 6 |     Oxidized.asetus = Asetus.new
 7 |     Oxidized.setup_logger
 8 |     Oxidized::Node.any_instance.stubs(:resolve_repo)
 9 |     Oxidized::Node.any_instance.stubs(:resolve_input)
10 |     Oxidized::Node.any_instance.stubs(:resolve_output)
11 |     @node = Oxidized::Node.new(name: 'example.com',
12 |                                input: 'ssh',
13 |                                output: 'git',
14 |                                model: 'junos',
15 |                                username: 'alma',
16 |                                password: 'armud',
17 |                                vars: {ssh_proxy: 'test.com'})
18 | 
19 |   end
20 | 
21 |   describe "#connect" do
22 |     it "should use proxy command when proxy host given" do
23 |       ssh = Oxidized::SSH.new
24 | 
25 |       model = mock()
26 |       model.expects(:cfg).returns({'ssh' => []})
27 |       @node.expects(:model).returns(model)
28 | 
29 |       proxy = mock()
30 |       Net::SSH::Proxy::Command.expects(:new).with("ssh test.com -W %h:%p").returns(proxy)
31 |       Net::SSH.expects(:start).with('93.184.216.34', 'alma', {:port => 22, :password => 'armud', :timeout => Oxidized.config.timeout,
32 |                                     :paranoid => Oxidized.config.input.ssh.secure, :auth_methods => ['none', 'publickey', 'password', 'keyboard-interactive'],
33 |                                     :number_of_password_prompts => 0, :proxy => proxy})
34 | 
35 |       ssh.instance_variable_set("@exec", true)
36 |       ssh.connect(@node)
37 |     end
38 |   end
39 | end
40 | 


--------------------------------------------------------------------------------
/oxidized.gemspec:
--------------------------------------------------------------------------------
 1 | # coding: utf-8
 2 | lib = File.expand_path('../lib', __FILE__)
 3 | $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 4 | require 'oxidized/version'
 5 | 
 6 | Gem::Specification.new do |s|
 7 |   s.name              = 'oxidized'
 8 |   s.version           = Oxidized::VERSION
 9 |   s.licenses          = %w( Apache-2.0 )
10 |   s.platform          = Gem::Platform::RUBY
11 |   s.authors           = [ 'Saku Ytti', 'Samer Abdel-Hafez', 'Anton Aksola' ]
12 |   s.email             = %w( saku@ytti.fi sam@arahant.net aakso@iki.fi)
13 |   s.homepage          = 'http://github.com/ytti/oxidized'
14 |   s.summary           = 'feeble attempt at rancid'
15 |   s.description       = 'software to fetch configuration from network devices and store them'
16 |   s.rubyforge_project = s.name
17 |   s.files             = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
18 |   s.executables       = %w( oxidized )
19 |   s.require_path      = 'lib'
20 | 
21 |   s.required_ruby_version =           '>= 2.0.0'
22 |   s.add_runtime_dependency 'asetus',  '~> 0.1'
23 |   s.add_runtime_dependency 'slop',    '~> 3.5'
24 |   s.add_runtime_dependency 'net-ssh', '~> 3.0.2'
25 |   s.add_runtime_dependency 'rugged',  '~> 0.21',  '>= 0.21.4'
26 | 
27 |   if defined?(RUBY_VERSION) && RUBY_VERSION > '2.3'
28 |       s.add_runtime_dependency 'net-telnet'
29 |   end
30 | 
31 |   s.add_development_dependency 'pry',      '~> 0'
32 |   s.add_development_dependency 'bundler',  '~> 1.10'
33 |   s.add_development_dependency 'rake',     '~> 10.0'
34 |   s.add_development_dependency 'minitest', '~> 5.8'
35 |   s.add_development_dependency 'mocha',    '~> 1.1'
36 | end
37 | 


--------------------------------------------------------------------------------
/lib/oxidized/input/cli.rb:
--------------------------------------------------------------------------------
 1 | module Oxidized
 2 |   class Input
 3 |     module CLI
 4 |       attr_reader :node
 5 | 
 6 |       def initialize
 7 |         @post_login = []
 8 |         @pre_logout = []
 9 |         @username, @password, @exec = nil
10 |       end
11 | 
12 |       def get
13 |         connect_cli
14 |         d = node.model.get
15 |         disconnect
16 |         d
17 |       rescue PromptUndetect
18 |         disconnect
19 |         raise
20 |       end
21 | 
22 |       def connect_cli
23 |         Oxidized.logger.debug "lib/oxidized/input/cli.rb: Running post_login commands at #{node.name}"
24 |         @post_login.each do |command, block|
25 |           Oxidized.logger.debug "lib/oxidized/input/cli.rb: Running post_login command: #{command.inspect}, block: #{block.inspect} at #{node.name}"
26 |           block ? block.call : (cmd command)
27 |         end
28 |       end
29 | 
30 |       def disconnect_cli
31 |         Oxidized.logger.debug "lib/oxidized/input/cli.rb Running pre_logout commands at #{node.name}"
32 |         @pre_logout.each { |command, block| block ? block.call : (cmd command, nil) }
33 |       end
34 | 
35 |       def post_login _post_login=nil, &block
36 |         unless @exec
37 |           @post_login << [_post_login, block]
38 |         end
39 |       end
40 | 
41 |       def pre_logout _pre_logout=nil, &block
42 |         unless @exec
43 |           @pre_logout <<  [_pre_logout, block]
44 |         end
45 |       end
46 | 
47 |       def username re=/^(Username|login)/
48 |         @username or @username = re
49 |       end
50 | 
51 |       def password re=/^Password/
52 |         @password or @password = re
53 |       end
54 | 
55 |     end
56 |   end
57 | end
58 | 


--------------------------------------------------------------------------------
/lib/oxidized/source/csv.rb:
--------------------------------------------------------------------------------
 1 | module Oxidized
 2 | class CSV < Source
 3 |   def initialize
 4 |     @cfg = Oxidized.config.source.csv
 5 |     super
 6 |   end
 7 | 
 8 |   def setup
 9 |     if @cfg.empty?
10 |       Oxidized.asetus.user.source.csv.file      = File.join(Config::Root, 'router.db')
11 |       Oxidized.asetus.user.source.csv.delimiter = /:/
12 |       Oxidized.asetus.user.source.csv.map.name  = 0
13 |       Oxidized.asetus.user.source.csv.map.model = 1
14 |       Oxidized.asetus.user.source.csv.gpg       = false
15 |       Oxidized.asetus.save :user
16 |       raise NoConfig, 'no source csv config, edit ~/.config/oxidized/config'
17 |     end
18 |     require 'gpgme' if @cfg.gpg?
19 |   end
20 | 
21 |   def load
22 |     nodes = []
23 |     file = File.expand_path(@cfg.file)
24 |     file = if @cfg.gpg?
25 |       crypto = GPGME::Crypto.new password: @cfg.gpg_password
26 |       crypto.decrypt(file).to_s
27 |     else
28 |       open(file)
29 |     end  
30 |     file.each_line do |line|
31 |       next if line.match(/^\s*#/)
32 |       data  = line.chomp.split(@cfg.delimiter, -1)
33 |       next if data.empty?
34 |       # map node parameters
35 |       keys = {}
36 |       @cfg.map.each do |key, position|
37 |         keys[key.to_sym] = node_var_interpolate data[position]
38 |       end
39 |       keys[:model] = map_model keys[:model] if keys.key? :model
40 | 
41 |       # map node specific vars
42 |       vars = {}
43 |       @cfg.vars_map.each do |key, position|
44 |         vars[key.to_sym] = node_var_interpolate data[position]
45 |       end
46 |       keys[:vars] = vars unless vars.empty?
47 | 
48 |       nodes << keys
49 |     end
50 |     nodes
51 |   end
52 | 
53 | end
54 | end
55 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/tplink.rb:
--------------------------------------------------------------------------------
 1 | class TPLink < Oxidized::Model
 2 | 
 3 |   # tp-link prompt
 4 |   prompt /^\r?([\w.@()-]+[#>]\s?)$/
 5 |   comment  '! '
 6 | 
 7 |   # handle paging
 8 |   # workaround for sometimes missing whitespaces with "\s?"
 9 |   expect /Press\s?any\s?key\s?to\s?continue\s?\(Q\s?to\s?quit\)/ do |data, re|
10 |    send ' '
11 |    data.sub re, ''
12 |   end
13 | 
14 |   # send carriage return because \n with the command is not enough
15 |   # checks if line ends with prompt >,# or \r,\nm otherwise send \r
16 |   expect /[^>#\r\n]$/ do |data, re|
17 |    send "\r"
18 |    data.sub re, ''
19 |   end
20 | 
21 |   cmd :all do |cfg|
22 |     # normalize linefeeds
23 |     cfg.gsub! /(\r|\r\n|\n\r)/,"\n"
24 |     # remove empty lines
25 |     cfg.each_line.reject { |line| line.match /^[\r\n\s\u0000#]+$/ }.join
26 |   end
27 | 
28 |   cmd :secret do |cfg|
29 |     cfg.gsub! /^(snmp-server community).*/, '\\1 <configuration removed>'
30 |     cfg.gsub! /secret (\d+) (\S+).*/, '<secret hidden>'
31 |     cfg
32 |   end
33 | 
34 |   cmd 'show system-info'  do |cfg|
35 |     comment cfg.each_line.to_a[3..-3].join
36 |   end
37 | 
38 |   cmd 'show running-config' do |cfg|
39 |     lines = cfg.each_line.to_a[1..-1]
40 |     # cut config after "end"
41 |     lines[0..lines.index("end\n")].join
42 |   end
43 | 
44 |   cfg :telnet, :ssh do
45 |     username /^User ?[nN]ame:/
46 |     password /^\r?Password:/
47 |   end
48 | 
49 |   cfg :telnet, :ssh do
50 |     if vars :enable
51 |       post_login do
52 |         send "enable\r"
53 |         cmd vars(:enable)
54 |       end
55 |     end
56 | 
57 |     pre_logout do
58 |       send "exit\r"
59 |       send "logout\r"
60 |     end
61 | 
62 |   end
63 | 
64 | end
65 | 
66 | 


--------------------------------------------------------------------------------
/lib/oxidized/output/file.rb:
--------------------------------------------------------------------------------
 1 | module Oxidized
 2 | class OxidizedFile < Output
 3 |   require 'fileutils'
 4 | 
 5 |   attr_reader :commitref
 6 | 
 7 |   def initialize
 8 |     @cfg = Oxidized.config.output.file
 9 |   end
10 | 
11 |   def setup
12 |     if @cfg.empty?
13 |       Oxidized.asetus.user.output.file.directory = File.join(Config::Root, 'configs')
14 |       Oxidized.asetus.save :user
15 |       raise NoConfig, 'no output file config, edit ~/.config/oxidized/config'
16 |     end
17 |   end
18 | 
19 |   def store node, outputs, opt={}
20 |     file = File.expand_path @cfg.directory
21 |     if opt[:group]
22 |       file = File.join File.dirname(file), opt[:group]
23 |     end
24 |     FileUtils.mkdir_p file
25 |     file = File.join file, node
26 |     open(file, 'w') { |fh| fh.write outputs.to_cfg }
27 |     @commitref = file
28 |   end
29 | 
30 |   def fetch node, group
31 |     cfg_dir   = File.expand_path @cfg.directory
32 |     node_name = node.name
33 | 
34 |     if group # group is explicitly defined by user
35 |       cfg_dir = File.join File.dirname(cfg_dir), group
36 |       File.read File.join(cfg_dir, node_name)
37 |     else
38 |       if File.exists? File.join(cfg_dir, node_name) # node configuration file is stored on base directory
39 |         File.read File.join(cfg_dir, node_name)
40 |       else
41 |         path = Dir.glob(File.join(File.dirname(cfg_dir), '**', node_name)).first # fetch node in all groups
42 |         File.read path
43 |       end
44 |     end
45 |   rescue Errno::ENOENT
46 |     return nil
47 |   end
48 | 
49 |   def version node, group
50 |     # not supported
51 |     []
52 |   end
53 | 
54 |   def get_version node, group, oid
55 |     'not supported'
56 |   end
57 | 
58 | end
59 | end
60 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/comware.rb:
--------------------------------------------------------------------------------
 1 | class Comware < Oxidized::Model
 2 |   # HP (A-series)/H3C/3Com Comware
 3 |   
 4 |   # sometimes the prompt might have a leading nul
 5 |   prompt /^\0*(<[\w.-]+>)$/
 6 |   comment '# '
 7 | 
 8 |   # example how to handle pager
 9 |   #expect /^\s*---- More ----$/ do |data, re|
10 |   #  send ' '
11 |   #  data.sub re, ''
12 |   #end
13 | 
14 |   cmd :all do |cfg|
15 |     #cfg.gsub! /^.*\e\[42D/, ''        # example how to handle pager
16 |     #skip rogue ^M
17 |     cfg = cfg.gsub /\r/, ''
18 |     cfg.each_line.to_a[1..-2].join
19 |   end
20 |  
21 |   cmd :secret do |cfg|
22 |     cfg.gsub! /^( snmp-agent community).*/, '\\1 <configuration removed>'
23 |     cfg.gsub! /^( password hash).*/, '\\1 <configuration removed>'
24 |     cfg
25 |   end
26 | 
27 |   cfg :telnet do
28 |     username /^Username:$/
29 |     password /^Password:$/
30 |   end
31 | 
32 |   cfg :telnet, :ssh do
33 |     # enable command-line mode on SMB comware switches (HP V1910, V1920)
34 |     # autodetection is hard, because the 'summary' command is paged, and
35 |     # the pager cannot be disabled before _cmdline-mode on.
36 |     if vars :comware_cmdline
37 |       post_login do
38 |         send "_cmdline-mode on\n"
39 |         send "y\n"
40 |         send vars(:comware_cmdline) + "\n"
41 |       end
42 |     end
43 | 
44 |     post_login 'screen-length disable'
45 |     post_login 'undo terminal monitor'
46 |     pre_logout 'quit'
47 |   end
48 | 
49 |   cmd 'display version' do |cfg|
50 |     cfg = cfg.each_line.select {|l| not l.match /uptime/i }.join
51 |     comment cfg
52 |   end
53 | 
54 |   cmd 'display device' do |cfg|
55 |     comment cfg
56 |   end
57 | 
58 |   cmd 'display current-configuration' do |cfg|
59 |     cfg
60 |   end
61 | end
62 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/zhoneolt.rb:
--------------------------------------------------------------------------------
 1 | class ZhoneOLT < Oxidized::Model
 2 |   # Zhone OLT/MetroE/DSL devices (ONT uses a completely different CLI)
 3 | 
 4 |   # the prompt can be anything on zhone, but it defaults to 'zXX>' and we
 5 |   # always use hostname>
 6 |   prompt /^(\r*[\w.@():-]+[>]\s?)$/
 7 |   comment '# '
 8 | 
 9 |   cmd :secret do |cfg|
10 |     cfg.gsub! /^(set configsyncpasswd = ) \S+/, '\\1 <removed>'
11 |     cfg.gsub! /^(set user-pass = ) \S+/, '\\1 <removed>'
12 |     cfg.gsub! /^(set auth-key = ) \S+/, '\\1 <removed>'
13 |     cfg.gsub! /^(set priv-key = ) \S+/, '\\1 <removed>'
14 |     cfg.gsub! /^(set ftp-password = ) \S+/, '\\1 <removed>'
15 |     cfg.gsub! /^(set community-name = ) \S+/, '\\1 <removed>'
16 |     cfg.gsub! /^(set communityname = ) \S+/, '\\1 <removed>'
17 |     cfg
18 |   end
19 | 
20 |   cmd :all do |cfg|
21 |     cfg.each_line.to_a[1..-2].map{|line|line.delete("\r").rstrip}.join("\n") + "\n"
22 |   end
23 | 
24 |   cmd 'swversion' do |cfg|
25 |     comment cfg
26 |   end
27 | 
28 |   cmd 'slots' do |cfg|
29 |     comment cfg
30 |   end
31 | 
32 |   cmd 'eeshow card' do |cfg|
33 |     comment cfg
34 |   end
35 | 
36 |   cmd 'ethrpshow' do |cfg|
37 |     cfg = cfg.each_line.select { |line| line.match /Vendor (Name|OUI|Part|Revision)|Serial Number|Manufacturing Date/ }.join
38 |     comment cfg
39 |   end
40 | 
41 |   cmd 'dump console' do |cfg|
42 |     cfg = cfg.each_line.select { |line| not line.match /To Abort the operation enter Ctrl-C/ }.join
43 |   end
44 | 
45 |   # zhone technically supports ssh, but it locks up a ton.  Especially when
46 |   # showing large amounts of output, like "dump console"
47 |   cfg :telnet do
48 |     username /\r*login:/
49 |     password /\r*password:/
50 |     pre_logout 'logout'
51 |   end
52 | end
53 | 


--------------------------------------------------------------------------------
/spec/nodes_spec.rb:
--------------------------------------------------------------------------------
 1 | require 'spec_helper'
 2 | 
 3 | describe Oxidized::Nodes do
 4 |   before(:each) do
 5 |     Resolv.any_instance.stubs(:getaddress)
 6 |     Oxidized.asetus = Asetus.new
 7 |     Oxidized.setup_logger
 8 | 
 9 |     opts = {
10 |       input: 'ssh',
11 |       output: 'git',
12 |       model: 'junos',
13 |       username: 'alma',
14 |       password: 'armud',
15 |       prompt: 'test_prompt'
16 |     }
17 | 
18 |     Oxidized::Node.any_instance.stubs(:resolve_repo)
19 |     Oxidized::Node.any_instance.stubs(:resolve_output)
20 |     @nodes_org = %w(ltt-pe1.hel kes2-rr1.tku tor-peer1.oul
21 |                     hal-p2.tre sav-gr1-sw1.kuo psl-sec-pe1.hel).map { |e| Oxidized::Node.new(opts.merge(name: e)) }
22 |     @node = @nodes_org.delete_at(0)
23 |     @nodes = Oxidized::Nodes.new(nodes: @nodes_org.dup)
24 |   end
25 | 
26 |   describe '#put' do
27 |     it 'adds node to top of queue' do
28 |       @nodes.put @node
29 |       @nodes.must_equal [@node] + @nodes_org
30 |     end
31 |   end
32 | 
33 |   describe '#get' do
34 |     it 'returns node from top of queue' do
35 |       @nodes.get.must_equal @nodes_org.first
36 |     end
37 |     it 'moves node from top to bottom' do
38 |       @nodes.get
39 |       @nodes.last.must_equal @nodes_org.first
40 |     end
41 |     it 'does not change node count' do
42 |       before = @nodes.size
43 |       @nodes.get
44 |       before.must_equal @nodes.size
45 |     end
46 |   end
47 | 
48 |   describe '#next' do
49 |     it 'moves node to top of queue' do
50 |       node = @nodes[3]
51 |       @nodes.next node.name
52 |       @nodes.first.must_equal node
53 |     end
54 |     it 'does not change node count' do
55 |       before = @nodes.size
56 |       @nodes.next @nodes[3].name
57 |       before.must_equal @nodes.size
58 |     end
59 |   end
60 | end
61 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/hpebladesystem.rb:
--------------------------------------------------------------------------------
 1 | class HPEBladeSystem < Oxidized::Model
 2 |   # HPE Onboard Administrator
 3 | 
 4 |   prompt /.*> /
 5 |   comment '# '
 6 | 
 7 |   expect /^\s*--More--\s+.*$/ do |data, re|
 8 |      send ' '
 9 |      data.sub re, ''
10 |   end
11 | 
12 |   cmd :all do |cfg|
13 |     cfg = cfg.delete("\r").each_line.to_a[0..-1].map{|line|line.rstrip}.join("\n") + "\n"
14 |     cfg.each_line.to_a[0..-2].join
15 |   end
16 | 
17 |   cmd :secret do |cfg|
18 |     cfg.gsub! /^(SET SNMP COMMUNITY (READ|WRITE)).*/, '\\1 <configuration removed>'
19 |     cfg
20 |   end
21 | 
22 |   cmd 'show oa info' do |cfg|
23 |     comment cfg
24 |   end
25 |   
26 |   cmd 'show oa network' do |cfg|
27 |     comment cfg
28 |   end
29 | 
30 |   cmd 'show oa certificate' do |cfg|
31 |     comment cfg
32 |   end
33 |   
34 |   cmd 'show sshfingerprint' do |cfg|
35 |     comment cfg
36 |   end
37 |   
38 |   cmd 'show fru' do |cfg|
39 |     comment cfg
40 |   end
41 |   
42 |   cmd 'show network' do |cfg|
43 |     comment cfg
44 |   end
45 | 
46 |   cmd 'show vlan' do |cfg|
47 |     comment cfg
48 |   end
49 | 
50 |   cmd 'show rack name' do |cfg|
51 |     comment cfg
52 |   end
53 | 
54 |   cmd 'show server list' do |cfg|
55 |     comment cfg
56 |   end
57 |   
58 |   cmd 'show server names' do |cfg|
59 |     comment cfg
60 |   end
61 |   
62 |   cmd 'show server port map all' do |cfg|
63 |     comment cfg
64 |   end
65 |   
66 |   cmd 'show server info all' do |cfg|
67 |     comment cfg
68 |   end
69 | 
70 |   cmd 'show config' do |cfg|
71 |     cfg.gsub! /^#(Generated on:) .*$/, '\\1 <removed>'
72 |     cfg.gsub /^\s+/, ''
73 |   end
74 |   
75 |   cfg :telnet do
76 |     username /\slogin:/
77 |     password /^Password: /
78 |   end
79 |  
80 |    cfg :telnet, :ssh do
81 |      pre_logout "exit"
82 |    end
83 | end
84 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/fortios.rb:
--------------------------------------------------------------------------------
 1 | class FortiOS < Oxidized::Model
 2 | 
 3 |   comment  '# '
 4 | 
 5 |   prompt /^([-\w\.\~]+(\s[\(\w\-\.\)]+)?\~?\s?[#>$]\s?)$/
 6 | 
 7 |   expect /^--More--\s$/ do |data, re|
 8 |     send ' '
 9 |     data.sub re, ''
10 |   end
11 | 
12 |   cmd :all do |cfg, cmdstring|
13 |     new_cfg = comment "COMMAND: #{cmdstring}\n"
14 |     new_cfg << cfg.each_line.to_a[1..-2].map { |line| line.gsub(/(conf_file_ver=)(.*)/, '\1<stripped>\3') }.join
15 |   end
16 | 
17 |   cmd :secret do |cfg|
18 |     cfg.gsub! /(set (?:passwd|password|psksecret)).*/, '\\1 <configuration removed>'
19 |     cfg.gsub! /(set private-key).*-+END ENCRYPTED PRIVATE KEY-*"$/m , '\\1 <configuration removed>'
20 |     cfg
21 |   end
22 | 
23 |   cmd 'get system status' do |cfg|
24 |     @vdom_enabled = cfg.include? 'Virtual domain configuration: enable'
25 |     cfg.gsub!(/(System time: )(.*)/, '\1<stripped>\3')
26 |     comment cfg
27 |   end
28 | 
29 |   post do
30 |     cfg = []
31 |     cfg << cmd('config global') if @vdom_enabled
32 | 
33 |     cfg << cmd('get hardware status') do |cfg|
34 |        comment cfg
35 |     end
36 | 
37 |     #default behaviour: include autoupdate output (backwards compatibility)
38 |     #do not include if variable "show_autoupdate" is set to false
39 |     if  defined?(vars(:fortios_autoupdate)).nil? || vars(:fortios_autoupdate)
40 |        cfg << cmd('diagnose autoupdate version') do |cfg|
41 |           comment cfg.each_line.reject { |line| line.match /Last Update|Result/ }.join
42 |        end
43 |     end
44 | 
45 | cfg << cmd('end') if @vdom_enabled
46 | 
47 |     cfg << cmd('show')
48 |     cfg.join "\n"
49 |   end
50 | 
51 |   cfg :telnet do
52 |     username /login:/
53 |     password /^Password:/
54 |   end
55 | 
56 |   cfg :telnet, :ssh do
57 |     pre_logout "exit\n"
58 |   end
59 | 
60 | end
61 | 
62 | 


--------------------------------------------------------------------------------
/extra/oxidized.init.d:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | # chkconfig: - 99 01
 3 | # description: Oxidized - Network Device Configuration Backup Tool
 4 | # processname: /opt/ruby-2.1/bin/oxidized
 5 | 
 6 | # Source function library
 7 | . /etc/rc.d/init.d/functions
 8 | 
 9 | name="oxidized"
10 | desc="Oxidized"
11 | cmd=oxidized
12 | args="--daemonize"
13 | lockfile=/var/lock/subsys/$name
14 | pidfile=/etc/oxidized/pid
15 | 
16 | export OXIDIZED_HOME=/etc/oxidized
17 | 
18 | # Source sysconfig configuration
19 | [ -r /etc/sysconfig/$name ] && . /etc/sysconfig/$name
20 | 
21 | start() {
22 |     echo -n $"Starting $desc: "
23 |     daemon ${cmd} ${args}
24 |     retval=$?
25 |     if [ $retval = 0 ]
26 |     then
27 |         echo_success
28 |         touch $lockfile
29 |     else
30 |         echo_failure
31 |     fi
32 |     echo
33 |     return $retval
34 | }
35 | 
36 | stop() {
37 |     echo -n $"Stopping $desc: "
38 |     killproc -p $pidfile
39 |     retval=$?
40 |     [ $retval -eq 0 ] && rm -f $lockfile
41 |     rm -f $pidfile
42 |     echo
43 |     return $retval
44 | }
45 | 
46 | restart() {
47 |     stop
48 |     start
49 | }
50 | 
51 | reload() {
52 |   echo -n $"Reloading config..."
53 |   curl -s http://localhost:8888/reload?format=json -O /dev/null
54 |   echo
55 | }
56 | 
57 | rh_status() {
58 |     status -p $pidfile $cmd
59 | }
60 | 
61 | rh_status_q() {
62 |     rh_status >/dev/null 2>&1
63 | }
64 | 
65 | case "$1" in
66 |     start)
67 |         rh_status_q && exit 0
68 |         $1
69 |         ;;
70 |     stop)
71 |         rh_status_q || exit 0
72 |         $1
73 |         ;;
74 |     restart)
75 |         $1
76 |         ;;
77 |     reload)
78 |         rh_status_q || exit 0
79 |         $1
80 |         ;;
81 |     status)
82 |         rh_status
83 |         ;;
84 |     *)
85 |         echo $"Usage: $0 {start|stop|restart|reload|status}"
86 |         exit 2
87 | esac
88 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/tmos.rb:
--------------------------------------------------------------------------------
 1 | class TMOS < Oxidized::Model
 2 | 
 3 |   comment  '# '
 4 | 
 5 |   cmd :secret do |cfg|
 6 |     cfg.gsub!(/^([\s\t]*)secret \S+/, '\1secret <secret removed>')
 7 |     cfg.gsub!(/^([\s\t]*\S*)password \S+/, '\1password <secret removed>')
 8 |     cfg.gsub!(/^([\s\t]*\S*)passphrase \S+/, '\1passphrase <secret removed>')
 9 |     cfg.gsub!(/community \S+/, 'community <secret removed>')
10 |     cfg.gsub!(/community-name \S+/, 'community-name <secret removed>')
11 |     cfg.gsub!(/^([\s\t]*\S*)encrypted \S+$/, '\1encrypted <secret removed>')
12 |     cfg
13 |   end
14 | 
15 |   cmd('tmsh -q show sys version') { |cfg| comment cfg }
16 | 
17 |   cmd('tmsh -q show sys software') { |cfg| comment cfg }
18 | 
19 |   cmd 'tmsh -q show sys hardware field-fmt' do |cfg|
20 |     cfg.gsub!(/fan-speed (\S+)/, '')
21 |     cfg.gsub!(/temperature (\S+)/, '')
22 |     comment cfg
23 |   end
24 | 
25 |   cmd('cat /config/bigip.license') { |cfg| comment cfg }
26 | 
27 |   cmd 'tmsh -q list' do |cfg|
28 |     cfg.gsub!(/state (up|down|checking|irule-down)/, '')
29 |     cfg.gsub!(/errors (\d+)/, '')
30 |     cfg
31 |   end
32 | 
33 |   cmd('tmsh -q list net route all') { |cfg| comment cfg }
34 | 
35 |   cmd('/bin/ls --full-time --color=never /config/ssl/ssl.crt') { |cfg| comment cfg }
36 | 
37 |   cmd('/bin/ls --full-time --color=never /config/ssl/ssl.key') { |cfg| comment cfg }
38 | 
39 |   cmd 'tmsh -q show running-config sys db all-properties' do |cfg|
40 |     cfg.gsub!(/sys db configsync.localconfigtime {[^}]+}/m, '')
41 |     cfg.gsub!(/sys db gtm.configtime {[^}]+}/m, '')
42 |     cfg.gsub!(/sys db ltm.configtime {[^}]+}/m, '')
43 |     comment cfg
44 |   end
45 | 
46 |   cmd('cat /config/partitions/*/bigip.conf') { |cfg| comment cfg }
47 | 
48 |   cfg :ssh do
49 |     exec true  # don't run shell, run each command in exec channel
50 |   end
51 | 
52 | end
53 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/procurve.rb:
--------------------------------------------------------------------------------
 1 | class Procurve < Oxidized::Model
 2 | 
 3 |   # some models start lines with \r 
 4 |   # previous command is repeated followed by "\eE", which sometimes ends up on last line
 5 |   prompt /^\r?([\w -]+\eE)?([\w.-]+# )$/
 6 | 
 7 |   comment  '! '
 8 | 
 9 |   # replace next line control sequence with a new line
10 |   expect /\eE/ do |data, re|
11 |     data.gsub re, "\n"
12 |   end
13 | 
14 |   # replace all used vt100 control sequences
15 |   expect /\e\[\??\d+(;\d+)*[A-Za-z]/ do |data, re|
16 |     data.gsub re, ''
17 |   end
18 | 
19 |   expect /Press any key to continue(\e\[\??\d+(;\d+)*[A-Za-z])*$/ do
20 |     send ' '
21 |     ""
22 |   end
23 | 
24 |   cmd :all do |cfg|
25 |     cfg = cfg.each_line.to_a[1..-3].join
26 |     cfg = cfg.gsub /^\r/, ''
27 |   end
28 | 
29 |   cmd :secret do |cfg|
30 |     cfg.gsub! /^(snmp-server community).*/, '\\1 <configuration removed>'
31 |     cfg.gsub! /^(snmp-server host).*/, '\\1 <configuration removed>'
32 |     cfg.gsub! /^(radius-server host).*/, '\\1 <configuration removed>'
33 |     cfg
34 |   end
35 | 
36 |   cmd 'show version' do |cfg|
37 |     comment cfg
38 |   end
39 | 
40 |   # not supported on all models
41 |   cmd 'show system-information' do |cfg|
42 |     cfg = cfg.split("\n")[0..-8].join("\n")
43 |     comment cfg
44 |   end
45 | 
46 |   # not supported on all models
47 |   cmd 'show system information' do |cfg|
48 |     cfg = cfg.each_line.select { |line| not line.match /(.*CPU.*)|(.*Up Time.*)|(.*Total.*)|(.*Free.*)|(.*Lowest.*)|(.*Missed.*)/ }
49 |     cfg = cfg.join
50 |     comment cfg
51 |   end
52 | 
53 |   cmd 'show running-config'
54 | 
55 |   cfg :telnet do
56 |     username /Username:/
57 |     password /Password:/
58 |   end
59 | 
60 |   cfg :telnet, :ssh do
61 |     post_login 'no page'
62 |     pre_logout "logout\ny\nn"
63 |   end
64 | 
65 |   cfg :ssh do
66 |     pty_options({ chars_wide: 1000 })
67 |   end
68 | 
69 | end
70 | 


--------------------------------------------------------------------------------
/lib/oxidized/jobs.rb:
--------------------------------------------------------------------------------
 1 | module Oxidized
 2 |   class Jobs < Array
 3 |     AVERAGE_DURATION  = 5   # initially presume nodes take 5s to complete
 4 |     MAX_INTER_JOB_GAP = 300 # add job if more than X from last job started
 5 |     attr_accessor :interval, :max, :want
 6 | 
 7 |     def initialize max, interval, nodes
 8 |       @max       = max
 9 |       # Set interval to 1 if interval is 0 (=disabled) so we don't break 
10 |       # the 'ceil' function
11 |       @interval  = interval == 0 ? 1 : interval
12 |       @nodes     = nodes
13 |       @last      = Time.now.utc
14 |       @durations = Array.new @nodes.size, AVERAGE_DURATION
15 |       duration AVERAGE_DURATION
16 |       super()
17 |     end
18 | 
19 |     def push arg
20 |       @last = Time.now.utc
21 |       super
22 |     end
23 | 
24 |     def duration last
25 |       if @durations.size > @nodes.size
26 |         @durations.slice! @nodes.size...@durations.size
27 |       elsif @durations.size < @nodes.size
28 |         @durations.fill AVERAGE_DURATION, @durations.size...@nodes.size
29 |       end
30 |       @durations.push(last).shift
31 |       @duration = @durations.inject(:+).to_f / @nodes.size #rolling average
32 |       new_count
33 |     end
34 | 
35 |     def new_count
36 |       @want = ((@nodes.size * @duration) / @interval).ceil
37 |       @want = 1 if @want < 1
38 |       @want = @nodes.size if @want > @nodes.size
39 |       @want = @max if @want > @max
40 |     end
41 | 
42 |     def work
43 |       # if   a) we want less or same amount of threads as we now running
44 |       # and  b) we want less threads running than the total amount of nodes
45 |       # and  c) there is more than MAX_INTER_JOB_GAP since last one was started
46 |       # then we want one more thread (rationale is to fix hanging thread causing HOLB)
47 |       if @want <= size and @want < @nodes.size
48 |         @want +=1 if (Time.now.utc - @last) > MAX_INTER_JOB_GAP
49 |       end
50 |     end
51 | 
52 |   end
53 | end
54 | 


--------------------------------------------------------------------------------
/lib/oxidized/source/sql.rb:
--------------------------------------------------------------------------------
 1 | module Oxidized
 2 | class SQL < Source
 3 |   begin
 4 |     require 'sequel'
 5 |   rescue LoadError
 6 |     raise OxidizedError, 'sequel not found: sudo gem install sequel'
 7 |   end
 8 | 
 9 |   def setup
10 |     if @cfg.empty?
11 |       Oxidized.asetus.user.source.sql.adapter   = 'sqlite'
12 |       Oxidized.asetus.user.source.sql.database  = File.join(Config::Root, 'sqlite.db')
13 |       Oxidized.asetus.user.source.sql.table     = 'devices'
14 |       Oxidized.asetus.user.source.sql.map.name  = 'name'
15 |       Oxidized.asetus.user.source.sql.map.model = 'rancid'
16 |       Oxidized.asetus.save :user
17 |       raise NoConfig, 'no source sql config, edit ~/.config/oxidized/config'
18 |     end
19 |   end
20 | 
21 |   def load
22 |     nodes = []
23 |     db = connect
24 |     query = db[@cfg.table.to_sym]
25 |     query = query.with_sql(@cfg.query) if @cfg.query?
26 |     query.each do |node|
27 |       # map node parameters
28 |       keys = {}
29 |       @cfg.map.each { |key, sql_column| keys[key.to_sym] = node_var_interpolate node[sql_column.to_sym] }
30 |       keys[:model] = map_model keys[:model] if keys.key? :model
31 | 
32 |       # map node specific vars
33 |       vars = {}
34 |       @cfg.vars_map.each do |key, sql_column|
35 |         vars[key.to_sym] = node_var_interpolate node[sql_column.to_sym]
36 |       end
37 |       keys[:vars] = vars unless vars.empty?
38 | 
39 |       nodes << keys
40 |     end
41 |     db.disconnect
42 |     nodes
43 |   end
44 | 
45 |   private
46 | 
47 |   def initialize
48 |     super
49 |     @cfg = Oxidized.config.source.sql
50 |   end
51 | 
52 |   def connect
53 |     Sequel.connect(:adapter  => @cfg.adapter,
54 |                    :host     => @cfg.host?,
55 |                    :user     => @cfg.user?,
56 |                    :password => @cfg.password?,
57 |                    :database => @cfg.database)
58 |   rescue Sequel::AdapterNotFound => error
59 |     raise OxidizedError, "SQL adapter gem not installed: " + error.message
60 |   end
61 | 
62 | end
63 | end
64 | 


--------------------------------------------------------------------------------
/lib/oxidized/output/http.rb:
--------------------------------------------------------------------------------
 1 | module Oxidized
 2 |   class Http < Output
 3 |     attr_reader :commitref
 4 |     def initialize
 5 |       @cfg = Oxidized.config.output.http
 6 |     end
 7 | 
 8 |     def setup
 9 |       if @cfg.empty?
10 |         CFGS.user.output.http.user  = 'Oxidized'
11 |         CFGS.user.output.http.pasword = 'secret'
12 |         CFGS.user.output.http.url  =  'http://localhost/web-api/oxidized'
13 |         CFGS.save :user
14 |         raise NoConfig, 'no output http config, edit ~/.config/oxidized/config'
15 |       end
16 |     end
17 |     require "net/http"
18 |     require "uri"
19 |     require "json"
20 |     def store node, outputs, opt={}
21 |       @commitref = nil
22 |       json = JSON.pretty_generate(
23 |           {
24 |               'msg' => opt[:msg],
25 |               'user' => opt[:user],
26 |               'email' => opt[:email],
27 |               'group' => opt[:group],
28 |               'node' => node,
29 |               'config' => outputs.to_cfg,
30 |               # actually we need to also iterate outputs, for other types like in gitlab. But most people don't use 'type' functionality.
31 |           }
32 |       )
33 |       uri = URI.parse @cfg.url
34 |       http = Net::HTTP.new uri.host, uri.port
35 |       #http.use_ssl = true if uri.scheme = 'https'
36 |       req = Net::HTTP::Post.new(uri.request_uri, initheader = { 'Content-Type' => 'application/json'})
37 |       req.basic_auth @cfg.user, @cfg.password
38 |       req.body = json
39 |       response = http.request req
40 | 
41 |       case response.code.to_i
42 |         when 200 || 201
43 |           Oxidized.logger.info "Configuration http backup complete for #{node}"
44 |           p [:success]
45 |         when (400..499)
46 |           Oxidized.logger.info "Configuration http backup for #{node} failed status: #{response.body}"
47 |           p [:bad_request]
48 |         when (500..599)
49 |           p [:server_problems]
50 |           Oxidized.logger.info "Configuration http backup for #{node} failed status: #{response.body}"
51 |       end
52 | 
53 |     end
54 | 
55 |   end
56 | end
57 | 
58 | 
59 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/powerconnect.rb:
--------------------------------------------------------------------------------
 1 | class PowerConnect < Oxidized::Model
 2 | 
 3 |   prompt /^([\w\s.@-]+[#>]\s?)$/ # allow spaces in hostname..dell does not limit it.. #
 4 | 
 5 |   comment  '! '
 6 | 
 7 |   expect /^\s*--More--\s+.*$/ do |data, re|
 8 |      send ' '
 9 |      data.sub re, ''
10 |   end
11 | 
12 |   cmd :all do |cfg|
13 |     cfg.each_line.to_a[1..-3].join
14 |   end
15 | 
16 |   cmd 'show version' do |cfg|
17 |     if (@stackable.nil?)
18 |       @stackable = true if cfg.match /(U|u)nit\s/
19 |     end
20 |     cfg = cfg.split("\n").select { |line| not line[/Up\sTime/] }
21 |     comment cfg.join("\n") + "\n"
22 |   end
23 | 
24 |   cmd 'show system' do |cfg|
25 |     @model = $1 if cfg.match /Power[C|c]onnect (\d{4})[P|F]?/
26 |     clean cfg
27 |   end
28 | 
29 |   cmd 'show running-config' do |cfg|
30 |     cfg.sub(/^(sflow \S+ destination owner \S+ timeout )\d+$/, '! \1<timeout>')
31 |   end
32 | 
33 |   cfg :telnet, :ssh do
34 |     username /^User( Name)?:/
35 |     password /^\r?Password:/
36 |   end
37 | 
38 |   cfg :telnet, :ssh do
39 |     if vars :enable
40 |       post_login do
41 |         send "enable\n"
42 |         cmd vars(:enable)
43 |       end
44 |     end
45 | 
46 |     post_login "terminal datadump"
47 |     post_login "terminal length 0"
48 |     pre_logout "logout"
49 |     pre_logout "exit"
50 |     
51 |   end
52 | 
53 |   def clean cfg
54 |     out = []
55 |     skip_blocks = 0
56 |     cfg.each_line do |line|
57 |       # If this is a stackable switch we should skip this block of information
58 |       if (line.match /Up\sTime|Temperature|Power Suppl(ies|y)|Fans/i and @stackable == true)
59 |         skip_blocks = 1
60 |         # Some switches have another empty line. This is identified by this line having a colon
61 |         skip_blocks = 2 if line.match /:/
62 |       end
63 |       # If we have lines to skip do this until we reach and empty line
64 |       if skip_blocks > 0
65 |         skip_blocks -= 1 if /\S/ !~ line
66 |         next
67 |       end
68 |       out << line.strip
69 |     end
70 |     out = comment out.join "\n"
71 |     out << "\n"
72 |   end
73 | 
74 | end
75 | 


--------------------------------------------------------------------------------
/lib/oxidized/source/http.rb:
--------------------------------------------------------------------------------
 1 | module Oxidized
 2 | class HTTP < Source
 3 |   def initialize
 4 |     @cfg = Oxidized.config.source.http
 5 |     super
 6 |   end
 7 | 
 8 |   def setup
 9 |     if @cfg.url.empty?
10 |       raise NoConfig, 'no source http url config, edit ~/.config/oxidized/config'
11 |     end
12 |   end
13 | 
14 |   require "net/http"
15 |   require "uri"
16 |   require "json"
17 | 
18 |   def load
19 |     nodes = []
20 |     uri = URI.parse(@cfg.url)
21 |     http = Net::HTTP.new(uri.host, uri.port)
22 |     http.use_ssl = true if uri.scheme == 'https'
23 |     http.verify_mode = OpenSSL::SSL::VERIFY_NONE unless @cfg.secure
24 | 
25 |     # map headers
26 |     headers = {}
27 |     @cfg.headers.each do |header, value|
28 |       headers[header] = value
29 |     end
30 | 
31 |     request = Net::HTTP::Get.new(uri.request_uri, headers)
32 |     if (@cfg.user? && @cfg.pass?)
33 |         request.basic_auth(@cfg.user,@cfg.pass)
34 |     end
35 | 
36 |     response = http.request(request)
37 |     data = JSON.parse(response.body)
38 |     data.each do |node|
39 |       next if node.empty?
40 |       # map node parameters
41 |       keys = {}
42 |       @cfg.map.each do |key, want_position|
43 |         want_positions = want_position.split('.')
44 |         keys[key.to_sym] = node_var_interpolate node.dig(*want_positions)
45 |       end
46 |       keys[:model] = map_model keys[:model] if keys.key? :model
47 | 
48 |       # map node specific vars
49 |       vars = {}
50 |       @cfg.vars_map.each do |key, want_position|
51 |         want_positions = want_position.split('.')
52 |         vars[key.to_sym] = node_var_interpolate node.dig(*want_positions)
53 |       end
54 |       keys[:vars] = vars unless vars.empty?
55 | 
56 |       nodes << keys
57 |     end
58 |     nodes
59 |   end
60 | 
61 | end
62 | end
63 | 
64 | if RUBY_VERSION < '2.3'
65 |   class Hash
66 |     def dig(key, *rest)
67 |       value = self[key]
68 |       if value.nil? || rest.empty?
69 |         value
70 |       elsif value.respond_to?(:dig)
71 |         value.dig(*rest)
72 |       else # foo.bar.baz (bar exist but is not hash)
73 |         return nil
74 |       end
75 |     end
76 |   end
77 | end
78 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/cumulus.rb:
--------------------------------------------------------------------------------
 1 | class Cumulus < Oxidized::Model
 2 |   
 3 |   prompt /^((\w*)@(.*)):/
 4 |   comment  '# '
 5 |   
 6 |   
 7 |   #add a comment in the final conf
 8 |   def add_comment comment
 9 |     "\n###### #{comment} ######\n" 
10 |   end
11 | 
12 |   cmd :all do |cfg|
13 |     cfg.each_line.to_a[1..-2].join
14 |   end
15 |   
16 |   #show the persistent configuration
17 |   pre do
18 |     cfg = add_comment 'THE HOSTNAME'
19 |     cfg += cmd 'cat /etc/hostname'
20 |     
21 |     cfg += add_comment 'THE HOSTS'
22 |     cfg += cmd 'cat /etc/hosts'
23 |     
24 |     cfg += add_comment 'THE INTERFACES'
25 |     cfg += cmd 'grep -r "" /etc/network/interface* | cut -d "/" -f 4-'
26 |     
27 |     cfg += add_comment 'RESOLV.CONF'
28 |     cfg += cmd 'cat /etc/resolv.conf'
29 |     
30 |     cfg += add_comment 'NTP.CONF'
31 |     cfg += cmd 'cat /etc/ntp.conf'
32 |     
33 |     cfg += add_comment 'IP Routes'
34 |     cfg += cmd 'netstat -rn'
35 | 
36 |     cfg += add_comment 'QUAGGA DAEMONS'
37 |     cfg += cmd 'cat /etc/quagga/daemons'
38 |     
39 |     cfg += add_comment 'QUAGGA ZEBRA'
40 |     cfg += cmd 'cat /etc/quagga/zebra.conf'
41 |     
42 |     cfg += add_comment 'QUAGGA BGP'
43 |     cfg += cmd 'cat /etc/quagga/bgpd.conf'
44 |     
45 |     cfg += add_comment 'QUAGGA OSPF'
46 |     cfg += cmd 'cat /etc/quagga/ospfd.conf'
47 |     
48 |     cfg += add_comment 'QUAGGA OSPF6'
49 |     cfg += cmd 'cat /etc/quagga/ospf6d.conf'
50 |     
51 |     cfg += add_comment 'MOTD'
52 |     cfg += cmd 'cat /etc/motd'
53 |     
54 |     cfg += add_comment 'PASSWD'
55 |     cfg += cmd 'cat /etc/passwd'
56 |     
57 |     cfg += add_comment ' SWITCHD'
58 |     cfg += cmd 'cat /etc/cumulus/switchd.conf'
59 |     
60 |     cfg += add_comment 'ACL'
61 |     cfg += cmd 'iptables -L -n'
62 |     
63 |     cfg += add_comment 'VERSION'
64 |     cfg += cmd 'cat /etc/cumulus/etc.replace/os-release'
65 | 
66 |     cfg += add_comment 'License'
67 |     cfg += cmd 'cl-license'
68 |     
69 |   end
70 |   
71 | 
72 |   cfg :telnet do
73 |     username /^Username:/
74 |     password /^Password:/
75 |   end
76 | 
77 |   cfg :telnet, :ssh do
78 |     pre_logout 'exit'
79 |   end
80 |  
81 | 
82 | end
83 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/asa.rb:
--------------------------------------------------------------------------------
 1 | class ASA < Oxidized::Model
 2 | 
 3 |   # Cisco ASA model #
 4 |   # Only SSH supported for the sake of security
 5 | 
 6 |   prompt /^\r*([\w.@()-\/]+[#>]\s?)$/
 7 |   comment  '! '
 8 | 
 9 |   cmd :all do |cfg|
10 |     cfg.each_line.to_a[1..-2].join
11 |   end
12 | 
13 |   cmd :secret do |cfg|
14 |     cfg.gsub! /enable password (\S+) (.*)/, 'enable password <secret hidden> \2'
15 |     cfg.gsub! /username (\S+) password (\S+) (.*)/, 'username \1 password <secret hidden> \3'
16 |     cfg.gsub! /ikev2 pre-shared-key (\S+)/, 'ikev2 pre-shared-key <secret hidden>'
17 |     cfg.gsub! /ikev2 (remote|local)-authentication pre-shared-key (\S+)/, 'ikev2 \1-authentication pre-shared-key <secret hidden>'
18 |     cfg.gsub! /^(aaa-server TACACS\+? \(\S+\) host.*\n\skey) \S+$/mi, '\1 <secret hidden>'
19 |     cfg
20 |   end
21 | 
22 |   cmd 'show version' do |cfg|
23 |     # avoid commits due to uptime / ixo-router01 up 2 mins 28 secs / ixo-router01 up 1 days 2 hours
24 |     cfg = cfg.each_line.select { |line| not line.match /(\s+up\s+\d+\s+)|(.*days.*)/ }
25 |     cfg = cfg.join
26 |     comment cfg
27 |   end
28 | 
29 |   cmd 'show inventory' do |cfg|
30 |     comment cfg
31 |   end
32 | 
33 |   cmd 'more system:running-config' do |cfg|
34 |     cfg = cfg.each_line.to_a[3..-1].join
35 |     cfg.gsub! /^: [^\n]*\n/, ''
36 |     # backup any xml referenced in the configuration.
37 |     anyconnect_profiles = cfg.scan(Regexp.new('(\sdisk0:/.+\.xml)')).flatten
38 |     anyconnect_profiles.each do |profile|
39 |   	  cfg << (comment profile + "\n" )
40 |    	  cmd ("more" + profile) do |xml|
41 | 	      cfg << (comment xml)
42 | 	    end
43 |     end
44 |     # if DAP is enabled, also backup dap.xml
45 |     if cfg.rindex(/dynamic-access-policy-record\s(?!DfltAccessPolicy)/)
46 |    	  cfg << (comment "disk0:/dap.xml\n")
47 |       cmd "more disk0:/dap.xml" do |xml|
48 |         cfg << (comment xml)
49 |       end
50 |     end
51 |     cfg
52 |   end
53 | 
54 |   cfg :ssh do
55 |     if vars :enable
56 |       post_login do
57 |         send "enable\n"
58 |         cmd vars(:enable)
59 |       end
60 |     end
61 |     post_login 'terminal pager 0'
62 |     pre_logout 'exit'
63 |   end
64 | 
65 | end
66 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/ipos.rb:
--------------------------------------------------------------------------------
 1 | class IPOS < Oxidized::Model
 2 | 
 3 |   # Ericsson SSR (IPOS)
 4 |   # Redback SE (SEOS)
 5 | 
 6 |   prompt /^([\[\]\w.@-]+[#>]\s?)$/
 7 |   comment '! '
 8 | 
 9 |   cmd 'show chassis' do |cfg|
10 |     comment cfg.each_line.to_a[0..-2].join
11 |   end
12 | 
13 |   cmd 'show hardware' do |cfg|
14 |     comment cfg.each_line.to_a[0..-2].join
15 |   end
16 | 
17 |   cmd 'show release' do |cfg|
18 |     comment cfg.each_line.to_a[0..-2].join
19 |   end
20 | 
21 |   cmd 'show configuration' do |cfg|
22 |     # SEOS regularly adds some odd line breaks in random places
23 |     # when showing the config, triggering changes.
24 |     cfg.gsub! "\r\n", "\n"
25 | 
26 |     cfg = cfg.each_line.to_a
27 | 
28 |     # Keeps the issued command commented but removes the uncommented "Building configuration..."
29 |     # and "Current configuration:" lines as well as the last prompt at the end.
30 |     cfg = cfg[4..-2].unshift comment cfg[0]
31 | 
32 |     # Later IPOS releases add this line in addition to the usual "last changed" line.
33 |     # It's touched regularly (as often as multiple times per minute) by the OS without actual visible config changes.
34 |     cfg = cfg.reject { |line| line.match "Configuration last changed by system user" }
35 | 
36 |     # Earlier IPOS releases lack the "changed by system user" line and instead overwrite
37 |     # the single "last changed by user" line. Because the line has a timestamp it will
38 |     # trigger constant changes if not removed. By doing so there will only be a single
39 |     # extra change trigged after an actual config change by a user but still have the
40 |     # real user.
41 |     cfg = cfg.reject { |line| line.match "Configuration last changed by user '%LICM%' at" }
42 |     cfg = cfg.reject { |line| line.match "Configuration last changed by user '<NO USER>' at" }
43 |     cfg = cfg.reject { |line| line.match "Configuration last changed by user '' at" }
44 | 
45 |     cfg.join
46 |   end
47 | 
48 |   cfg :telnet do
49 |     username /^login:/
50 |     password /^\r*password:/
51 |   end
52 | 
53 |   cfg :telnet, :ssh do
54 |     post_login 'terminal length 0'
55 |     pre_logout do
56 |       send "exit\n"
57 |       send "n\n"
58 |     end
59 |   end
60 | 
61 | end
62 | 


--------------------------------------------------------------------------------
/extra/oxidized.init:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | #
 3 | # Written by Stefan Schlesinger / sts@ono.at / http://sts.ono.at
 4 | #
 5 | ### BEGIN INIT INFO
 6 | # Provides:          oxidized
 7 | # Required-Start:    $remote_fs $syslog
 8 | # Required-Stop:     $remote_fs $syslog
 9 | # Default-Start:     2 3 4 5
10 | # Default-Stop:      0 1 6
11 | # Short-Description: Start Oxidized at boot time
12 | # Description:       Oxidized - Network Device Configuration Backup Tool
13 | ### END INIT INFO
14 | 
15 | set -e
16 | 
17 | PATH=/sbin:/bin:/usr/sbin:/usr/bin
18 | DAEMON=/home/sts/oxidized/bin/oxidized
19 | NAME="oxidized"
20 | DESC="Oxidized - Network Device Configuration Backup Tool"
21 | ARGS=""
22 | USER="sts"
23 | 
24 | test -x $DAEMON || exit 0
25 | 
26 | . /lib/lsb/init-functions
27 | 
28 | if [ -r /etc/default/$NAME ]; then
29 | 	. /etc/default/$NAME
30 | fi
31 | 
32 | CONFIG="${CONFIG:-/etc/oxidized/config}"
33 | 
34 | PIDFILE=/var/run/$NAME.pid
35 | 
36 | do_start()
37 | {
38 |         start-stop-daemon --start --quiet --background --pidfile $PIDFILE --make-pidfile  \
39 |         --oknodo --chuid $USER --exec $DAEMON -- -c $CONFIG $ARGS
40 | }
41 | 
42 | do_stop()
43 | {
44 |         start-stop-daemon --oknodo --stop --quiet -v --pidfile $PIDFILE \
45 |         --chuid $USER --retry KILL/10 -- -c $CONFIG $ARGS
46 | }
47 | 
48 | case "$1" in
49 |   start)
50 |         if [ "$ENABLED" = "no" ]; then
51 |                 log_failure_msg "Not starting $DESC: disabled via /etc/default/$NAME"
52 |                 exit 0
53 |         fi
54 | 
55 |         log_daemon_msg "Starting $DESC..." "$NAME"
56 |         if do_start ; then
57 |                 log_end_msg 0
58 |         else
59 |                 log_end_msg 1
60 |         fi
61 |         ;;
62 |   stop)
63 |         log_daemon_msg "Stopping $DESC..." "$NAME"
64 |         if do_stop ; then
65 |                 log_end_msg 0
66 |         else
67 |                 log_end_msg 1
68 |         fi
69 |         ;;
70 | 
71 |   restart|force-reload)
72 |         $0 stop
73 |         sleep 1
74 |         $0 start
75 |         ;;
76 |   status)
77 | 	status_of_proc -p $PIDFILE $DAEMON $NAME
78 | 	;;
79 |   *)
80 | 	N=/etc/init.d/$NAME
81 | 	echo "Usage: $N {start|stop|restart|force-reload|status}" >&2
82 | 	exit 1
83 | 	;;
84 | esac
85 | 
86 | exit 0
87 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/trango.rb:
--------------------------------------------------------------------------------
 1 | class Trango < Oxidized::Model
 2 |   # take a Trangolink sysinfo output and turn it into a configuration file
 3 |   
 4 |   prompt /^#>\s?/
 5 |   comment  '# '
 6 | 
 7 |   cmd 'sysinfo' do |cfg|
 8 |     out = []
 9 |     comments = []
10 |     cfg.each_line do |line|
11 |       if line.match /\[Opmode\] (off|on) \[Default Opmode\] (off|on)/
12 |         out << "opmode " + Regexp.last_match[1]
13 |         out << "defaultopmode " + Regexp.last_match[2]
14 |       end
15 |       if line.match /\[Tx Power\] ([\-\d]+) dBm/
16 |         out << "power " + Regexp.last_match[1]
17 |       end
18 |       if line.match /\[Active Channel\] (\d+) (v|h)/
19 |         out << "freq " + Regexp.last_match[1] + ' ' + Regexp.last_match[2]
20 |       end
21 |       if line.match /\[Peer ID\] ([A-F0-9]+)/
22 |         out << "peerid " + Regexp.last_match[1]
23 |       end
24 |       if line.match /\[Unit Type\] (\S+)/
25 |         out << "utype " + Regexp.last_match[1]
26 |       end
27 |       if line.match /\[(Hardware Version|Firmware Version|Model|S\/N)\] (\S+)/
28 |         comments << '# ' + Regexp.last_match[1] + ': ' + Regexp.last_match[2]
29 |       end
30 |       if line.match /\[Remarks\] (\S+)/
31 |         out << "remarks " + Regexp.last_match[1]
32 |       end
33 |       if line.match /\[RSSI LED\] (on|off)/
34 |         out << "rssiled " + Regexp.last_match[1]
35 |       end
36 |       if line.match /\[Speed\] (\d+) Mbps/
37 |         speed = Regexp.last_match[1]
38 |       end
39 |       if line.match /\[Tx MIR\] (\d+) Kbps/
40 |         out << "mir ".concat(Regexp.last_match[1])
41 |       end
42 |       if line.match /\[Auto Rate Shift\] (on|off)/
43 |         out << "autorateshift ".concat(Regexp.last_match[1])
44 |         if Regexp.last_match[1].eql? 'off'
45 |           out << "speed $speed"
46 |         end
47 |       end
48 |       if line.match /\[IP\] (\S+) \[Subnet Mask\] (\S+) \[Gateway\] (\S+)/
49 |         out << "ipconfig " + Regexp.last_match[1] + ' ' +
50 |                               Regexp.last_match[2] + ' ' +
51 |                               Regexp.last_match[3]
52 |       end
53 |     end 
54 |     comments.push(*out).join "\n"
55 |   end 
56 | 
57 |   cfg :telnet do
58 |     password /Password:/
59 |     pre_logout 'exit'
60 |   end
61 |  
62 | end
63 | 


--------------------------------------------------------------------------------
/lib/oxidized/manager.rb:
--------------------------------------------------------------------------------
 1 | module Oxidized
 2 |   require 'oxidized/model/model'
 3 |   require 'oxidized/input/input'
 4 |   require 'oxidized/output/output'
 5 |   require 'oxidized/source/source'
 6 |   class Manager
 7 |     class << self
 8 |       def load dir, file
 9 |         begin
10 |           require File.join dir, file+'.rb'
11 |           klass = nil
12 |           [Oxidized, Object].each do |mod|
13 |             klass = mod.constants.find { |const| const.to_s.downcase == file.downcase }
14 |             klass = mod.constants.find { |const| const.to_s.downcase == 'oxidized'+ file.downcase } unless klass
15 |             klass = mod.const_get klass if klass
16 |             break if klass
17 |           end
18 |           i = klass.new
19 |           i.setup if i.respond_to? :setup
20 |           { file => klass }
21 |         rescue LoadError
22 |           {}
23 |         end
24 |       end
25 |     end
26 |     attr_reader :input, :output, :model, :source, :hook
27 |     def initialize
28 |       @input  = {}
29 |       @output = {}
30 |       @model  = {}
31 |       @source = {}
32 |       @hook = {}
33 |     end
34 |     def add_input method
35 |       method = Manager.load Config::InputDir, method
36 |       return false if method.empty?
37 |       @input.merge! method
38 |     end
39 |     def add_output method
40 |       method = Manager.load Config::OutputDir, method
41 |       return false if method.empty?
42 |       @output.merge! method
43 |     end
44 |     def add_model _model
45 |       name = _model
46 |       _model = Manager.load File.join(Config::Root, 'model'), name
47 |       _model = Manager.load Config::ModelDir, name if _model.empty?
48 |       return false if _model.empty?
49 |       @model.merge! _model
50 |     end
51 |     def add_source _source
52 |       return nil if @source.key? _source
53 |       _source = Manager.load Config::SourceDir, _source
54 |       return false if _source.empty?
55 |       @source.merge! _source
56 |     end
57 |     def add_hook _hook
58 |       return nil if @hook.key? _hook
59 |       name = _hook
60 |       _hook = Manager.load File.join(Config::Root, 'hook'), name
61 |       _hook = Manager.load Config::HookDir, name if _hook.empty?
62 |       return false if _hook.empty?
63 |       @hook.merge! _hook
64 |     end
65 |   end
66 | end
67 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/ios.rb:
--------------------------------------------------------------------------------
 1 | class IOS < Oxidized::Model
 2 | 
 3 |   prompt /^([\w.@()-]+[#>]\s?)$/
 4 |   comment  '! '
 5 | 
 6 |   # example how to handle pager
 7 |   #expect /^\s--More--\s+.*$/ do |data, re|
 8 |   #  send ' '
 9 |   #  data.sub re, ''
10 |   #end
11 | 
12 |   # non-preferred way to handle additional PW prompt
13 |   #expect /^[\w.]+>$/ do |data|
14 |   #  send "enable\n"
15 |   #  send vars(:enable) + "\n"
16 |   #  data
17 |   #end
18 | 
19 |   cmd :all do |cfg|
20 |     #cfg.gsub! /\cH+\s{8}/, ''         # example how to handle pager
21 |     #cfg.gsub! /\cH+/, ''              # example how to handle pager
22 |     cfg.each_line.to_a[1..-2].join
23 |   end
24 | 
25 |   cmd :secret do |cfg|
26 |     cfg.gsub! /^(snmp-server community).*/, '\\1 <configuration removed>'
27 |     cfg.gsub! /username (\S+) privilege (\d+) (\S+).*/, '<secret hidden>'
28 |     cfg.gsub! /^username \S+ password \d \S+/, '<secret hidden>'
29 |     cfg.gsub! /^username \S+ secret \d \S+/, '<secret hidden>'
30 |     cfg.gsub! /^enable (password|secret) \d \S+/, '<secret hidden>'
31 |     cfg.gsub! /^(\s+(?:password|secret)) (?:\d )?\S+/, '\\1 <secret hidden>'
32 |     cfg.gsub! /wpa-psk ascii \d \S+/, '<secret hidden>'
33 |     cfg.gsub! /^tacacs-server key \d \S+/, '<secret hidden>'
34 |     cfg
35 |   end
36 | 
37 |   cmd 'show version' do |cfg|
38 |     comment cfg.lines.first
39 |   end
40 | 
41 |   cmd 'show inventory' do |cfg|
42 |     comment cfg
43 |   end
44 | 
45 |   cmd 'show running-config' do |cfg|
46 |     cfg = cfg.each_line.to_a[3..-1]
47 |     cfg = cfg.reject { |line| line.match /^ntp clock-period / }.join
48 |     cfg.gsub! /^Current configuration : [^\n]*\n/, ''
49 |     cfg.gsub! /^\ tunnel\ mpls\ traffic-eng\ bandwidth[^\n]*\n*(
50 |                   (?:\ [^\n]*\n*)*
51 |                   tunnel\ mpls\ traffic-eng\ auto-bw)/mx, '\1'
52 |     cfg
53 |   end
54 | 
55 |   cfg :telnet do
56 |     username /^Username:/
57 |     password /^Password:/
58 |   end
59 | 
60 |   cfg :telnet, :ssh do
61 |     # preferred way to handle additional passwords
62 |     if vars :enable
63 |       post_login do
64 |         send "enable\n"
65 |         cmd vars(:enable)
66 |       end
67 |     end
68 |     post_login 'terminal length 0'
69 |     post_login 'terminal width 0'
70 |     pre_logout 'exit'
71 |   end
72 | 
73 | end
74 | 


--------------------------------------------------------------------------------
/lib/oxidized/hook/exec.rb:
--------------------------------------------------------------------------------
 1 | class Exec < Oxidized::Hook
 2 |   include Process
 3 | 
 4 |   def initialize
 5 |     super
 6 |     @timeout = 60
 7 |     @async = false
 8 |   end
 9 | 
10 |   def validate_cfg!
11 |     # Syntax check
12 |     if cfg.has_key? "timeout"
13 |       @timeout = cfg.timeout
14 |       raise "invalid timeout value" unless @timeout.is_a?(Integer) &&
15 |                                            @timeout > 0
16 |     end
17 | 
18 |     if cfg.has_key? "async"
19 |       @async = !!cfg.async
20 |     end
21 | 
22 |     if cfg.has_key? "cmd"
23 |       @cmd = cfg.cmd
24 |       raise "invalid cmd value" unless @cmd.is_a?(String) || @cmd.is_a?(Array)
25 |     end
26 | 
27 |   rescue RuntimeError => e
28 |     raise ArgumentError,
29 |       "#{self.class.name}: configuration invalid: #{e.message}"
30 |   end
31 | 
32 |   def run_hook ctx
33 |     env = make_env ctx
34 |     log "Execute: #{@cmd.inspect}", :debug
35 |     th = Thread.new do
36 |       begin
37 |         run_cmd! env
38 |       rescue => e
39 |         raise e unless @async
40 |       end
41 |     end
42 |     th.join unless @async
43 |   end
44 | 
45 |   def run_cmd! env
46 |     pid, status = nil, nil
47 |     Timeout.timeout(@timeout) do
48 |       pid = spawn env, @cmd , :unsetenv_others => true
49 |       pid, status = wait2 pid
50 |       unless status.exitstatus.zero?
51 |         msg = "#{@cmd.inspect} failed with exit value #{status.exitstatus}"
52 |         log msg, :error
53 |         raise msg
54 |       end
55 |     end
56 |   rescue TimeoutError
57 |     kill "TERM", pid
58 |     msg = "#{@cmd} timed out"
59 |     log msg, :error
60 |     raise TimeoutError, msg
61 |   end
62 | 
63 |   def make_env ctx
64 |     env = {
65 |       "OX_EVENT" => ctx.event.to_s
66 |     }
67 |     if ctx.node
68 |       env.merge!(
69 |         "OX_NODE_NAME" => ctx.node.name.to_s,
70 |         "OX_NODE_FROM" => ctx.node.from.to_s,
71 |         "OX_NODE_MSG" => ctx.node.msg.to_s,
72 |         "OX_NODE_GROUP" => ctx.node.group.to_s,
73 |         "OX_EVENT" => ctx.event.to_s,
74 |         "OX_REPO_COMMITREF" => ctx.commitref.to_s,
75 |         "OX_REPO_NAME" => ctx.node.repo.to_s,
76 |       )
77 |     end
78 |     if ctx.job
79 |       env.merge!(
80 |         "OX_JOB_STATUS" => ctx.job.status.to_s,
81 |         "OX_JOB_TIME" => ctx.job.time.to_s,
82 |       )
83 |     end
84 |     env
85 |   end
86 | end
87 | 


--------------------------------------------------------------------------------
/lib/oxidized/hook.rb:
--------------------------------------------------------------------------------
 1 | module Oxidized
 2 | class HookManager
 3 |   class << self
 4 |     def from_config cfg
 5 |       mgr = new
 6 |       cfg.hooks.each do |name,h_cfg|
 7 |         h_cfg.events.each do |event|
 8 |           mgr.register event.to_sym, name, h_cfg.type, h_cfg
 9 |         end
10 |       end
11 |       mgr
12 |     end
13 |   end
14 | 
15 |   # HookContext is passed to each hook. It can contain anything related to the
16 |   # event in question. At least it contains the event name
17 |   class HookContext < OpenStruct; end
18 | 
19 |   # RegisteredHook is a container for a Hook instance
20 |   class RegisteredHook < Struct.new(:name, :hook); end
21 | 
22 |   Events = [
23 |     :node_success,
24 |     :node_fail,
25 |     :post_store,
26 |   ]
27 |   attr_reader :registered_hooks
28 | 
29 |   def initialize
30 |     @registered_hooks = Hash.new {|h,k| h[k] = []}
31 |   end
32 | 
33 |   def register event, name, hook_type, cfg
34 |     unless Events.include? event
35 |       raise ArgumentError,
36 |         "unknown event #{event}, available: #{Events.join ','}"
37 |     end
38 | 
39 |     Oxidized.mgr.add_hook hook_type
40 |     begin
41 |       hook = Oxidized.mgr.hook.fetch(hook_type).new
42 |     rescue KeyError
43 |       raise KeyError, "cannot find hook #{hook_type.inspect}"
44 |     end
45 | 
46 |     hook.cfg = cfg
47 | 
48 |     @registered_hooks[event] << RegisteredHook.new(name, hook)
49 |     Oxidized.logger.debug "Hook #{name.inspect} registered #{hook.class} for event #{event.inspect}"
50 |   end
51 | 
52 |   def handle event, ctx_params={}
53 |     ctx = HookContext.new ctx_params
54 |     ctx.event = event
55 | 
56 |     @registered_hooks[event].each do |r_hook|
57 |       begin
58 |         r_hook.hook.run_hook ctx
59 |       rescue => e
60 |         Oxidized.logger.error "Hook #{r_hook.name} (#{r_hook.hook}) failed " +
61 |                   "(#{e.inspect}) for event #{event.inspect}"
62 |       end
63 |     end
64 |   end
65 | end
66 | 
67 | # Hook abstract base class
68 | class Hook
69 |   attr_reader :cfg
70 | 
71 |   def initialize
72 |   end
73 | 
74 |   def cfg=(cfg)
75 |     @cfg = cfg
76 |     validate_cfg! if self.respond_to? :validate_cfg!
77 |   end
78 | 
79 |   def run_hook ctx
80 |     raise NotImplementedError
81 |   end
82 | 
83 |   def log(msg, level=:info)
84 |     Oxidized.logger.send(level, "#{self.class.name}: #{msg}")
85 |   end
86 | 
87 | end
88 | end
89 | 


--------------------------------------------------------------------------------
/lib/oxidized/hook/githubrepo.rb:
--------------------------------------------------------------------------------
 1 | class GithubRepo < Oxidized::Hook
 2 |   def validate_cfg!
 3 |     raise KeyError, 'hook.remote_repo is required' unless cfg.has_key?('remote_repo')
 4 |   end
 5 | 
 6 |   def run_hook(ctx)
 7 |     repo = Rugged::Repository.new(ctx.node.repo)
 8 |     log "Pushing local repository(#{repo.path})..."
 9 |     remote = repo.remotes['origin'] || repo.remotes.create('origin', remote_repo(ctx.node))
10 |     log "to remote: #{remote.url}"
11 | 
12 |     fetch_and_merge_remote(repo)
13 | 
14 |     remote.push([repo.head.name], credentials: credentials)
15 |   end
16 | 
17 |   def fetch_and_merge_remote(repo)
18 |     result = repo.fetch('origin', [repo.head.name], credentials: credentials)
19 |     log result.inspect, :debug
20 | 
21 |     unless result[:total_deltas] > 0
22 |       log "nothing recieved after fetch", :debug
23 |       return
24 |     end
25 | 
26 |     their_branch = repo.branches["origin/master"]
27 | 
28 |     log "merging fetched branch #{their_branch.name}", :debug
29 | 
30 |     merge_index = repo.merge_commits(repo.head.target_id, their_branch.target_id)
31 | 
32 |     if merge_index.conflicts?
33 |       log("Conflicts detected, skipping Rugged::Commit.create", :warn)
34 |       return
35 |     end
36 | 
37 |     Rugged::Commit.create(repo, {
38 |       parents: [repo.head.target, their_branch.target],
39 |       tree: merge_index.write_tree(repo),
40 |       message: "Merge remote-tracking branch '#{their_branch.name}'",
41 |       update_ref: "HEAD"
42 |     })
43 |   end
44 | 
45 |   private
46 | 
47 |   def credentials
48 |     @credentials ||= if cfg.has_key?('username') && cfg.has_key?('password')
49 |       log "Using https auth", :debug
50 |       Rugged::Credentials::UserPassword.new(username: cfg.username, password: cfg.password)
51 |     else
52 |       if cfg.has_key?('publickey') && cfg.has_key?('privatekey')
53 |         log "Using ssh auth with key", :debug
54 |         Rugged::Credentials::SshKey.new(username: 'git', publickey: File.expand_path(cfg.publickey), privatekey: File.expand_path(cfg.privatekey))
55 |       else
56 |         log "Using ssh auth with agentforwarding", :debug
57 |         Rugged::Credentials::SshKeyFromAgent.new(username: 'git')
58 |       end
59 |     end
60 |   end
61 | 
62 |   def remote_repo(node)
63 |     if node.group.nil? || cfg.remote_repo.is_a?(String)
64 |       cfg.remote_repo
65 |     else
66 |       cfg.remote_repo[node.group]
67 |     end
68 |   end
69 | end
70 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/planet.rb:
--------------------------------------------------------------------------------
 1 | class Planet < Oxidized::Model
 2 | 
 3 |   prompt /^\r?([\w.@()-]+[#>]\s?)$/
 4 |   comment  '! '
 5 | 
 6 |   # example how to handle pager
 7 |   #expect /^\s--More--\s+.*$/ do |data, re|
 8 |   # send ' '
 9 |   # data.sub re, ''
10 |   #end
11 | 
12 |   # non-preferred way to handle additional PW prompt
13 |   #expect /^[\w.]+>$/ do |data|
14 |   #  send "enable\n"
15 |   #  send vars(:enable) + "\n"
16 |   #  data
17 |   #end
18 | 
19 |   cmd :all do |cfg|
20 |     #cfg.gsub! /\cH+\s{8}/, ''         # example how to handle pager
21 |     #cfg.gsub! /\cH+/, ''              # example how to handle pager
22 |     cfg.each_line.to_a[1..-2].join
23 |   end
24 | 
25 |   cmd :secret do |cfg|
26 |     cfg.gsub! /^(snmp-server community).*/, '\\1 <configuration removed>'
27 |     cfg.gsub! /username (\S+) privilege (\d+) (\S+).*/, '<secret hidden>'
28 |     cfg.gsub! /^username \S+ password \d \S+/, '<secret hidden>'
29 |     cfg.gsub! /^enable password \d \S+/, '<secret hidden>'
30 |     cfg.gsub! /wpa-psk ascii \d \S+/, '<secret hidden>'
31 |     cfg.gsub! /^tacacs-server key \d \S+/, '<secret hidden>'
32 |     cfg
33 |   end
34 | 
35 |   cmd 'show version' do |cfg|
36 |     cfg.gsub! "\n\r", "\n"
37 |     @planetgs = true if cfg.match /^System Name\w*:\w*GS-.*$/
38 |     @planetsgs = true if cfg.match /SGS-(.*) Device, Compiled on .*$/
39 | 
40 |     cfg = cfg.each_line.to_a[0...-2]
41 | 
42 |    # Strip system time and system uptime from planet gs switches
43 |     cfg = cfg.reject { |line| line.match /System Time\s*:.*/ }
44 |     cfg = cfg.reject { |line| line.match /System Uptime\s*:.*/ }
45 | 
46 |     comment cfg.join
47 |   end
48 | 
49 | 
50 |   cmd 'show running-config' do |cfg|
51 |     cfg.gsub! "\n\r", "\n"
52 |     cfg = cfg.each_line.to_a
53 | 
54 |     cfg = cfg.reject { |line| line.match "Building configuration..." }
55 |   
56 |     if @planetsgs
57 |       cfg << cmd('show transceiver detail | include transceiver detail information|found|Type|length|Nominal|wavelength|Base information') do |cfg|
58 |         comment cfg
59 |       end
60 |     end
61 | 
62 |     cfg.join
63 |   end
64 |   
65 | 
66 |   cfg :telnet do
67 |     username /^Username:/
68 |     password /^Password:/
69 |   end
70 | 
71 |   cfg :telnet, :ssh do
72 |     post_login 'terminal length 0'
73 |     # preferred way to handle additional passwords
74 |     if vars :enable
75 |       post_login do
76 |         send "enable\n"
77 |         cmd vars(:enable)
78 |       end
79 |     end
80 |     pre_logout 'exit'
81 |   end
82 | 
83 | end
84 | 


--------------------------------------------------------------------------------
/extra/oxidized-report-git-commits:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | # 
 3 | # A script to maintain a local working copy of an oxidized configuration
 4 | # repository and mail out diffs for configuration changes
 5 | # 
 6 | # Copyright 2016 Nick Hilliard <nick@foobar.org>, All Rights Reserved
 7 | # 
 8 | # Licensed under the Apache License, Version 2.0 (the "License");
 9 | # you may not use this file except in compliance with the License.
10 | # You may obtain a copy of the License at
11 | # 
12 | #   http://www.apache.org/licenses/LICENSE-2.0
13 | # 
14 | # Unless required by applicable law or agreed to in writing, software
15 | # distributed under the License is distributed on an "AS IS" BASIS,
16 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 | # See the License for the specific language governing permissions and
18 | # limitations under the License.
19 | #
20 | # usage: add the following hook to the oxidized config file:
21 | # 
22 | # hooks:
23 | #  email_output:
24 | #    type: exec
25 | #    events: [post_store, node_fail]
26 | #    cmd: '/home/oxidized/extra/oxidized-report-git-commits ~/gitdir/ | mail -s "Oxidized updates for ${OX_NODE_NAME}" update-recipient@example.com'
27 | #    async: true
28 | #    timeout: 120
29 | # 
30 | #
31 | # The script takes a single argument, namely a git working directory name,
32 | # e.g.  "~/gitdir/".  This is only used as a staging directory and should
33 | # not be set to be the same as the git repo directory.
34 | #
35 | 
36 | PATH=${PATH}:/usr/local/bin:/usr/local/sbin
37 | export PATH
38 | 
39 | gitdir=$1
40 | 
41 | if [ X${OX_REPO_COMMITREF} = "X" ]; then
42 | 	echo \$OX_REPO_COMMITREF not set
43 | 	exit 64
44 | fi
45 | 
46 | if [ X${OX_REPO_NAME} = "X" ]; then
47 | 	echo \$OX_REPO_NAME not set
48 | 	exit 64
49 | fi
50 | 	
51 | if [ ! -d ${gitdir}/.git ]; then
52 | 	git clone -q ${OX_REPO_NAME} ${gitdir}
53 | 
54 | 	ret=$?
55 | 	if [ X"${ret}" != X0 ] && [ X"${ret}" != X1 ]; then
56 | 		echo git clone failed: aborting.
57 | 		exit 128
58 | 	fi
59 | fi
60 | 
61 | cd ${gitdir}
62 | 
63 | git pull -q > /dev/null 2>&1 
64 | ret=$?
65 | if [ X"${ret}" != X0 ] && [ X"${ret}" != X1 ]; then
66 | 	echo git pull failed: aborting.
67 | 	exit 128
68 | fi
69 | 
70 | # Git is probably working at this stage, so safe to emit more info
71 | 
72 | echo "Node name: ${OX_NODE_NAME}"
73 | echo "Group Name: ${OX_NODE_GROUP}"
74 | echo "Job Time: ${OX_JOB_TIME}"
75 | echo "Git Commit ID: ${OX_REPO_COMMITREF}"
76 | echo "Git Repo: ${OX_REPO_NAME}"
77 | echo "Local working dir: ${gitdir}"
78 | echo ""
79 | 
80 | git diff --no-color ${OX_REPO_COMMITREF}~1..${OX_REPO_COMMITREF}
81 | 


--------------------------------------------------------------------------------
/lib/oxidized/cli.rb:
--------------------------------------------------------------------------------
 1 | module Oxidized
 2 |   class CLI
 3 |     require 'slop'
 4 |     require 'oxidized'
 5 | 
 6 |     def run
 7 |       check_pid
 8 |       Process.daemon if @opts[:daemonize]
 9 |       write_pid
10 |       begin
11 |         Oxidized.logger.info "Oxidized starting, running as pid #{$$}"
12 |         Oxidized.new
13 |       rescue => error
14 |         crash error
15 |         raise
16 |       end
17 |     end
18 | 
19 |     private
20 | 
21 |     def initialize
22 |       _args, @opts = parse_opts
23 | 
24 |       Config.load(@opts)
25 |       Oxidized.setup_logger
26 | 
27 |       @pidfile = File.expand_path(Oxidized.config.pid)
28 |     end
29 | 
30 |     def crash error
31 |       Oxidized.logger.fatal "Oxidized crashed, crashfile written in #{Config::Crash}"
32 |       open Config::Crash, 'w' do |file|
33 |         file.puts '-' * 50
34 |         file.puts Time.now.utc
35 |         file.puts error.message + ' [' + error.class.to_s + ']'
36 |         file.puts '-' * 50
37 |         file.puts error.backtrace
38 |         file.puts '-' * 50
39 |       end
40 |     end
41 | 
42 |     def parse_opts
43 |       opts = Slop.new(:help=>true) do
44 |         on 'd', 'debug', 'turn on debugging'
45 |         on 'daemonize',  'Daemonize/fork the process'
46 |         on 'v', 'version', 'show version' do
47 |           puts Oxidized::VERSION
48 |           Kernel.exit
49 |         end
50 |       end
51 |       [opts.parse!, opts]
52 |     end
53 | 
54 |     def pidfile
55 |       @pidfile
56 |     end
57 | 
58 |     def pidfile?
59 |       !!pidfile
60 |     end
61 | 
62 |     def write_pid
63 |       if pidfile?
64 |         begin
65 |           File.open(pidfile, ::File::CREAT | ::File::EXCL | ::File::WRONLY){|f| f.write("#{Process.pid}") }
66 |           at_exit { File.delete(pidfile) if File.exists?(pidfile) }
67 |         rescue Errno::EEXIST
68 |           check_pid
69 |           retry
70 |         end
71 |       end
72 |     end
73 | 
74 |     def check_pid
75 |       if pidfile?
76 |         case pid_status(pidfile)
77 |         when :running, :not_owned
78 |           puts "A server is already running. Check #{pidfile}"
79 |           exit(1)
80 |         when :dead
81 |           File.delete(pidfile)
82 |         end
83 |       end
84 |     end
85 | 
86 |     def pid_status(pidfile)
87 |       return :exited unless File.exists?(pidfile)
88 |       pid = ::File.read(pidfile).to_i
89 |       return :dead if pid == 0
90 |       Process.kill(0, pid)
91 |       :running
92 |     rescue Errno::ESRCH
93 |       :dead
94 |     rescue Errno::EPERM
95 |       :not_owned
96 |     end
97 |   end
98 | end
99 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/ironware.rb:
--------------------------------------------------------------------------------
 1 | class IronWare < Oxidized::Model
 2 | 
 3 |   prompt /^.*(telnet|ssh)\@.+[>#]\s?$/i
 4 |   comment  '! '
 5 | 
 6 |   #to handle pager without enable
 7 |   #expect /^((.*)--More--(.*))$/ do |data, re|
 8 |   #  send ' '
 9 |   #  data.sub re, ''
10 |   #end
11 | 
12 | 
13 |   #to remove backspace (if handle pager without enable)
14 |   #expect /^((.*)[\b](.*))$/ do |data, re|
15 |   #  data.sub re, ''
16 |   #end
17 | 
18 |   cmd :all do |cfg|
19 |     # sometimes ironware inserts arbitrary whitespace after commands are
20 |     # issued on the CLI, from run to run.  this normalises the output.
21 |     cfg.each_line.to_a[1..-2].drop_while { |e| e.match /^\s+$/ }.join
22 |   end
23 | 
24 |   cmd 'show version' do |cfg|
25 |     cfg.gsub! /(^((.*)[Ss]ystem uptime(.*))$)/, '' #remove unwanted line system uptime
26 |     cfg.gsub! /(^((.*)[Tt]he system started at(.*))$)/, ''
27 |     cfg.gsub! /[Uu]p\s?[Tt]ime is .*/,''
28 | 
29 |     comment cfg
30 |   end
31 | 
32 |   cmd 'show chassis' do |cfg|
33 |     cfg.encode!("UTF-8", :invalid => :replace, :undef => :replace) #sometimes ironware returns broken encoding
34 |     cfg.gsub! /(^((.*)Current temp(.*))$)/, '' #remove unwanted lines current temperature
35 |     cfg.gsub! /Speed = [A-Z-]{2,6} \(\d{2,3}\%\)/, '' #remove unwanted lines Speed Fans
36 |     cfg.gsub! /current speed is [A-Z]{2,6} \(\d{2,3}\%\)/, ''
37 |     cfg.gsub! /([\[]*)1([\]]*)<->([\[]*)2([\]]*)(<->([\[]*)3([\]]*))*/, ''
38 |     cfg.gsub! /\d{2}\.\d deg-C/, 'XX.X deg-C'
39 |     if cfg.include? "TEMPERATURE"
40 |       sc = StringScanner.new cfg
41 |       out = ''
42 |       temps = ''
43 |       out << sc.scan_until(/.*TEMPERATURE/)
44 |       temps << sc.scan_until(/.*Fans/)
45 |       out << sc.rest
46 |       cfg = out
47 |     end
48 | 
49 |     comment cfg
50 |   end
51 | 
52 |   cmd 'show flash' do |cfg|
53 |     comment cfg
54 |   end
55 | 
56 |   cmd 'show module' do |cfg|
57 |     cfg.gsub! /^((Invalid input)|(Type \?)).*$/, '' # some ironware devices are fixed config
58 |     comment cfg
59 |   end
60 | 
61 |   cmd 'show running-config' do |cfg|
62 |     arr = cfg.each_line.to_a
63 |     arr[2..-1].join unless arr.length < 2
64 |   end
65 | 
66 |   cfg :telnet do
67 |     # match expected prompts on both older and newer
68 |     # versions of IronWare
69 |     username /^(Please Enter Login Name|Username):/
70 |     password /^(Please Enter )Password:/
71 |   end
72 | 
73 |   #handle pager with enable
74 |   cfg :telnet, :ssh do
75 |     if vars :enable
76 |       post_login do
77 |         send "enable\n"
78 |         cmd vars(:enable)
79 |       end
80 |     end
81 |     post_login ''
82 |     post_login 'skip-page-display'
83 |     post_login 'terminal length 0'
84 |     pre_logout "logout\nexit\nexit\n"
85 |   end
86 | 
87 | end
88 | 


--------------------------------------------------------------------------------
/lib/oxidized/config.rb:
--------------------------------------------------------------------------------
 1 | module Oxidized
 2 |   require 'asetus'
 3 |   class NoConfig < OxidizedError; end
 4 |   class InvalidConfig < OxidizedError; end
 5 |   class Config
 6 |     Root      = ENV['OXIDIZED_HOME'] || File.join(ENV['HOME'], '.config', 'oxidized')
 7 |     Crash     = File.join Root, 'crash'
 8 |     Log       = File.join Root, 'logs'
 9 |     InputDir  = File.join Directory, %w(lib oxidized input)
10 |     OutputDir = File.join Directory, %w(lib oxidized output)
11 |     ModelDir  = File.join Directory, %w(lib oxidized model)
12 |     SourceDir = File.join Directory, %w(lib oxidized source)
13 |     HookDir   = File.join Directory, %w(lib oxidized hook)
14 |     Sleep     = 1
15 | 
16 |     def self.load(cmd_opts={})
17 |       asetus = Asetus.new(name: 'oxidized', load: false, key_to_s: true)
18 |       Oxidized.asetus = asetus
19 | 
20 |       asetus.default.username      = 'username'
21 |       asetus.default.password      = 'password'
22 |       asetus.default.model         = 'junos'
23 |       asetus.default.interval      = 3600
24 |       asetus.default.use_syslog    = false
25 |       asetus.default.debug         = false
26 |       asetus.default.threads       = 30
27 |       asetus.default.timeout       = 20
28 |       asetus.default.retries       = 3
29 |       asetus.default.prompt        = /^([\w.@-]+[#>]\s?)$/
30 |       asetus.default.rest          = '127.0.0.1:8888' # or false to disable
31 |       asetus.default.next_adds_job = false            # if true, /next adds job, so device is fetched immmeiately
32 |       asetus.default.vars          = {}               # could be 'enable'=>'enablePW'
33 |       asetus.default.groups        = {}               # group level configuration
34 |       asetus.default.pid           = File.join(Oxidized::Config::Root, 'pid')
35 | 
36 |       asetus.default.input.default    = 'ssh, telnet'
37 |       asetus.default.input.debug      = false # or String for session log file
38 |       asetus.default.input.ssh.secure = false # complain about changed certs
39 | 
40 |       asetus.default.output.default = 'file'  # file, git
41 |       asetus.default.source.default = 'csv'   # csv, sql
42 | 
43 |       asetus.default.model_map = {
44 |         'cisco'   => 'ios',
45 |         'juniper' => 'junos',
46 |       }
47 | 
48 |       begin
49 |         asetus.load # load system+user configs, merge to Config.cfg
50 |       rescue => error
51 |         raise InvalidConfig, "Error loading config: #{error.message}"
52 |       end
53 | 
54 |       raise NoConfig, 'edit ~/.config/oxidized/config' if asetus.create
55 | 
56 |       # override if comand line flag given
57 |       asetus.cfg.debug = cmd_opts[:debug] if cmd_opts[:debug]
58 | 
59 |       asetus
60 |     end
61 |   end
62 | 
63 |   class << self
64 |     attr_accessor :mgr, :Hooks
65 |   end
66 | end
67 | 


--------------------------------------------------------------------------------
/spec/node_spec.rb:
--------------------------------------------------------------------------------
 1 | require 'spec_helper'
 2 | 
 3 | describe Oxidized::Node do
 4 |   before(:each) do
 5 |     Oxidized.asetus = Asetus.new
 6 |     Oxidized.setup_logger
 7 | 
 8 |     Oxidized::Node.any_instance.stubs(:resolve_repo)
 9 |     Oxidized::Node.any_instance.stubs(:resolve_output)
10 |     @node = Oxidized::Node.new(name: 'example.com',
11 |                                input: 'ssh',
12 |                                output: 'git',
13 |                                model: 'junos',
14 |                                username: 'alma',
15 |                                password: 'armud',
16 |                                prompt: 'test_prompt')
17 | 
18 |   end
19 | 
20 |   describe '#new' do
21 |     it 'should resolve input' do
22 |       @node.input[0].to_s.split('::')[1].must_equal 'SSH'
23 |     end
24 |     it 'should resolve model' do
25 |       @node.model.class.must_equal JunOS
26 |     end
27 |     it 'should resolve username' do
28 |       @node.auth[:username].must_equal 'alma'
29 |     end
30 |     it 'should resolve password' do
31 |       @node.auth[:password].must_equal 'armud'
32 |     end
33 |     it 'should require prompt' do
34 |       @node.prompt.must_equal 'test_prompt'
35 |     end
36 |   end
37 | 
38 |   describe '#run' do
39 |     it 'should fetch the configuration' do
40 |       stub_oxidized_ssh
41 | 
42 |       status, _ = @node.run
43 |       status.must_equal :success
44 |     end
45 |   end
46 | 
47 |   describe '#repo' do
48 |     before do
49 |       Oxidized.config.output.default = 'git'
50 |       Oxidized::Node.any_instance.unstub(:resolve_repo)
51 |     end
52 | 
53 |     let(:group) { nil }
54 |     let(:node) do
55 |       Oxidized::Node.new({
56 |         ip: '127.0.0.1', group: group, model: 'junos'
57 |       })
58 |     end
59 | 
60 |     it 'when there are no groups' do
61 |       Oxidized.config.output.git.repo = '/tmp/repository.git'
62 |       node.repo.must_equal '/tmp/repository.git'
63 |     end
64 | 
65 |     describe 'when there are groups' do
66 |       let(:group) { 'ggrroouupp' }
67 | 
68 |       before do
69 |         Oxidized.config.output.git.single_repo = single_repo
70 |       end
71 | 
72 |       describe 'with only one repository' do
73 |         let(:single_repo) { true }
74 | 
75 |         before do
76 |           Oxidized.config.output.git.repo = '/tmp/repository.git'
77 |         end
78 | 
79 |         it 'should use the correct remote' do
80 |           node.repo.must_equal '/tmp/repository.git'
81 |         end
82 |       end
83 | 
84 |       describe 'with more than one repository' do
85 |         let(:single_repo) { nil }
86 | 
87 |         before do
88 |           Oxidized.config.output.git.repo.ggrroouupp = '/tmp/ggrroouupp.git'
89 |         end
90 | 
91 |         it 'should use the correct remote' do
92 |           node.repo.must_equal '/tmp/ggrroouupp.git'
93 |         end
94 |       end
95 |     end
96 |   end
97 | end
98 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/timos.rb:
--------------------------------------------------------------------------------
  1 | class TiMOS < Oxidized::Model
  2 | 
  3 |   #
  4 |   # Nokia SR OS (TiMOS) (formerly TiMetra, Alcatel, Alcatel-Lucent).
  5 |   # Used in 7705 SAR, 7210 SAS, 7450 ESS, 7750 SR, 7950 XRS, and NSP.
  6 |   #
  7 | 
  8 |   comment  '# '
  9 | 
 10 |   prompt /^([-\w\.:>\*]+\s?[#>]\s?)$/
 11 | 
 12 |   cmd :all do |cfg, cmdstring|
 13 |     new_cfg = comment "COMMAND: #{cmdstring}\n"
 14 |     new_cfg << cfg.each_line.to_a[1..-2].join
 15 |   end
 16 | 
 17 |   #
 18 |   # Show the boot options file.
 19 |   #
 20 |   cmd 'show bof' do |cfg|
 21 |     cfg.gsub! /# Finished .*/, ''
 22 |     cfg.gsub! /# Generated .*/, ''
 23 |     comment cfg
 24 |   end
 25 | 
 26 |   #
 27 |   # Show the system information.
 28 |   #
 29 |   cmd 'show system information' do |cfg|
 30 |     #
 31 |     # Strip uptime.
 32 |     #
 33 |     cfg.sub! /^System Up Time.*\n/, ''
 34 |     cfg.gsub! /# Finished .*/, ''
 35 |     cfg.gsub! /# Generated .*/, ''
 36 |     comment cfg
 37 |   end
 38 | 
 39 |   #
 40 |   # Show the card state.
 41 |   #
 42 |   cmd 'show card state' do |cfg|
 43 |     cfg.gsub! /# Finished .*/, ''
 44 |     cfg.gsub! /# Generated .*/, ''
 45 |     comment cfg
 46 |   end
 47 | 
 48 |   #
 49 |   # Show the boot log.
 50 |   #
 51 |   cmd 'file type bootlog.txt' do |cfg|
 52 |     #
 53 |     # Strip carriage returns and backspaces.
 54 |     #
 55 |     cfg.gsub! /\r/, ''
 56 |     cfg.gsub! /[\b][\b][\b]/, "\n"
 57 |     cfg.gsub! /# Finished .*/, ''
 58 |     cfg.gsub! /# Generated .*/, ''
 59 |     comment cfg
 60 |   end
 61 | 
 62 |   #
 63 |   # Show the running debug configuration.
 64 |   #
 65 |   cmd 'show debug' do |cfg|
 66 |     cfg.gsub! /# Finished .*/, ''
 67 |     cfg.gsub! /# Generated .*/, ''
 68 |     comment cfg
 69 |   end
 70 | 
 71 |   #
 72 |   # Show the saved debug configuration (admin debug-save).
 73 |   #
 74 |   cmd 'file type config.dbg' do |cfg|
 75 |     #
 76 |     # Strip carriage returns.
 77 |     #
 78 |     cfg.gsub! /\r/, ''
 79 |     cfg.gsub! /# Finished .*/, ''
 80 |     cfg.gsub! /# Generated .*/, ''
 81 |     comment cfg
 82 |   end
 83 | 
 84 |   #
 85 |   # Show the running persistent indices.
 86 |   #
 87 |   cmd 'admin display-config index' do |cfg|
 88 |     #
 89 |     # Strip carriage returns.
 90 |     #
 91 |     cfg.gsub! /\r/, ''
 92 |     cfg.gsub! /# Finished .*/, ''
 93 |     cfg.gsub! /# Generated .*/, ''
 94 |     comment cfg
 95 |   end
 96 | 
 97 |   #
 98 |   # Show the running configuration.
 99 |   #
100 |   cmd 'admin display-config' do |cfg|
101 |     #
102 |     # Strip carriage returns.
103 |     #
104 |     cfg.gsub! /\r/, ''
105 |     cfg.gsub! /# Finished .*/, ''
106 |     cfg.gsub! /# Generated .*/, ''
107 |   end
108 | 
109 |   cfg :telnet do
110 |     username /^Login: /
111 |     password /^Password: /
112 |   end
113 | 
114 |   cfg :telnet, :ssh do
115 |     post_login 'environment no more'
116 |     pre_logout 'logout'
117 |   end
118 | end
119 | 


--------------------------------------------------------------------------------
/lib/oxidized/worker.rb:
--------------------------------------------------------------------------------
 1 | module Oxidized
 2 |   require 'oxidized/job'
 3 |   require 'oxidized/jobs'
 4 |   class Worker
 5 |     def initialize nodes
 6 |       @nodes      = nodes
 7 |       @jobs       = Jobs.new(Oxidized.config.threads, Oxidized.config.interval, @nodes)
 8 |       @nodes.jobs = @jobs
 9 |       Thread.abort_on_exception = true
10 |     end
11 | 
12 |     def work
13 |       ended = []
14 |       @jobs.delete_if { |job| ended << job if not job.alive? }
15 |       ended.each      { |job| process job }
16 |       @jobs.work
17 |       while @jobs.size < @jobs.want
18 |         Oxidized.logger.debug "lib/oxidized/worker.rb: Jobs #{@jobs.size}, Want: #{@jobs.want}"
19 |         # ask for next node in queue non destructive way
20 |         nextnode = @nodes.first
21 |         unless nextnode.last.nil?
22 |           # Set unobtainable value for 'last' if interval checking is disabled
23 |           last = Oxidized.config.interval == 0 ? Time.now.utc + 10 : nextnode.last.end
24 |           break if last + Oxidized.config.interval > Time.now.utc
25 |         end
26 |         # shift nodes and get the next node
27 |         node = @nodes.get
28 |         node.running? ? next : node.running = true
29 |         @jobs.push Job.new node
30 |         Oxidized.logger.debug "lib/oxidized/worker.rb: Added #{node.name} to the job queue"
31 |       end
32 |       Oxidized.logger.debug("lib/oxidized/worker.rb: #{@jobs.size} jobs running in parallel") unless @jobs.empty?
33 |     end
34 | 
35 |     def process job
36 |       node = job.node
37 |       node.last = job
38 |       node.stats.add job
39 |       @jobs.duration job.time
40 |       node.running = false
41 |       if job.status == :success
42 |         Oxidized.Hooks.handle :node_success, :node => node,
43 |                                              :job => job
44 |         msg = "update #{node.name}"
45 |         msg += " from #{node.from}" if node.from
46 |         msg += " with message '#{node.msg}'" if node.msg
47 |         output = node.output.new
48 |         if output.store node.name, job.config,
49 |                               :msg => msg, :user => node.user, :group => node.group
50 |           Oxidized.logger.info "Configuration updated for #{node.group}/#{node.name}"
51 |           Oxidized.Hooks.handle :post_store, :node => node,
52 |                                              :job => job,
53 |                                              :commitref => output.commitref
54 |         end
55 |         node.reset
56 |       else
57 |         msg = "#{node.name} status #{job.status}"
58 |         if node.retry < Oxidized.config.retries
59 |           node.retry += 1
60 |           msg += ", retry attempt #{node.retry}"
61 |           @nodes.next node.name
62 |         else
63 |           msg += ", retries exhausted, giving up"
64 |           node.retry = 0
65 |           Oxidized.Hooks.handle :node_fail, :node => node,
66 |                                             :job => job
67 |         end
68 |         Oxidized.logger.warn msg
69 |       end
70 |     rescue NodeNotFound
71 |       Oxidized.logger.warn "#{node.name} not found, removed while collecting?"
72 |     end
73 | 
74 |   end
75 | end
76 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/acos.rb:
--------------------------------------------------------------------------------
  1 | class ACOS < Oxidized::Model
  2 |   # A10 ACOS model for AX and Thunder series
  3 | 
  4 |   comment  '! '
  5 | 
  6 |   ##ACOS prompt changes depending on the state of the device
  7 |   prompt /^([-\w.\/:?\[\]\(\)]+[#>]\s?)$/
  8 | 
  9 |   cmd :secret do |cfg|
 10 |     cfg.gsub!(/community read encrypted (\S+)/, 'community read encrypted <hidden>') # snmp
 11 |     cfg.gsub!(/secret encrypted (\S+)/, 'secret encrypted <hidden>') # tacacs-server
 12 |     cfg.gsub!(/password encrypted (\S+)/, 'password encrypted <hidden>') # user
 13 |     cfg
 14 |   end
 15 | 
 16 |   cmd 'show version' do |cfg|
 17 |     cfg.gsub! /\s(Last configuration saved at).*/, ' \\1 <removed>'
 18 |     cfg.gsub! /\s(Memory).*/, ' \\1 <removed>'
 19 |     cfg.gsub! /\s(Current time is).*/, ' \\1 <removed>'
 20 |     cfg.gsub! /\s(The system has been up).*/, ' \\1 <removed>'
 21 |     comment cfg
 22 |   end
 23 | 
 24 |   cmd 'show bootimage' do |cfg|
 25 |     comment cfg
 26 |   end
 27 | 
 28 |   cmd 'show license' do |cfg|
 29 |     comment cfg
 30 |   end
 31 | 
 32 |   cmd 'show partition-config all' do |cfg|
 33 |      cfg.gsub! /(Current configuration).*/, '\\1 <removed>'
 34 |      cfg.gsub! /(Configuration last updated at).*/, '\\1 <removed>'
 35 |      cfg.gsub! /(Configuration last saved at).*/, '\\1 <removed>'
 36 |      cfg.gsub! /(Configuration last synchronized at).*/, '\\1 <removed>'
 37 |      cfg
 38 |   end  
 39 | 
 40 |   cmd 'show running-config all-partitions' do |cfg|
 41 |      cfg.gsub! /(Current configuration).*/, '\\1 <removed>'
 42 |      cfg.gsub! /(Configuration last updated at).*/, '\\1 <removed>'
 43 |      cfg.gsub! /(Configuration last saved at).*/, '\\1 <removed>'
 44 |      cfg.gsub! /(Configuration last synchronized at).*/, '\\1 <removed>'
 45 |      cfg
 46 |   end
 47 | 
 48 |   cmd 'show aflex all-partitions' do |cfg|
 49 |     comment cfg
 50 |   end
 51 | 
 52 |   cmd 'show aflex all-partitions' do |cfg|
 53 |     @partitions_aflex = cfg.lines.each_with_object({}) do |l,h|
 54 |       h[$1] = [] if l.match /partition: (.+)/
 55 |       # only consider scripts that have passed syntax check
 56 |       h[h.keys.last] << $1 if l.match /^([\w-]+) +Check/
 57 |     end
 58 |     ''
 59 |   end
 60 | 
 61 |   cmd :all do |cfg, cmdstring|
 62 |     new_cfg = comment "COMMAND: #{cmdstring}\n"
 63 |     new_cfg << cfg.each_line.to_a[1..-2].join
 64 |   end
 65 | 
 66 |   pre do
 67 |     unless @partitions_aflex.empty?
 68 |       out = []
 69 |       @partitions_aflex.each do |partition,arules|
 70 |         out << "! partition: #{partition}"
 71 |         arules.each do |name|
 72 |           cmd("show aflex #{name} partition #{partition}") do |cfg|
 73 |             content = cfg.split(/Content:/).last.strip
 74 |             out << "aflex create #{name}"
 75 |             out << content
 76 |             out << ".\n"
 77 |           end
 78 |         end
 79 |       end
 80 |       out.join "\n"
 81 |     end
 82 |   end
 83 | 
 84 |   cfg :telnet do
 85 |     username  /login:/
 86 |     password  /^Password:/
 87 |   end
 88 |   
 89 |   cfg :telnet, :ssh do
 90 |     # preferred way to handle additional passwords
 91 |     post_login do
 92 |       pw = vars(:enable)
 93 |       pw ||= ""
 94 |       send "enable\r\n"
 95 |       cmd pw
 96 |     end
 97 |     post_login 'terminal length 0'
 98 |     post_login 'terminal width 0'
 99 |     pre_logout "exit\nexit\nY\r\n"
100 |   end
101 | 
102 | end
103 | 


--------------------------------------------------------------------------------
/extra/syslog.rb:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env ruby
  2 | 
  3 | # IOS:
  4 | # logging discriminator CFG mnemonics includes CONFIG_I
  5 | # logging host SERVER discriminator CFG
  6 | 
  7 | # JunOS:
  8 | # set system syslog host SERVER interactive-commands notice
  9 | # set system syslog host SERVER match "^mgd\[[0-9]+\]: UI_COMMIT: .*"
 10 | 
 11 | # Ports < 1024 need extra privileges, use a port higher than this by setting the port option in your oxidized config file.
 12 | # To use the default port for syslog (514) you shouldn't pass an argument, but you will need to allow this with:
 13 | # sudo setcap 'cap_net_bind_service=+ep' /usr/bin/ruby
 14 | 
 15 | # Config options are:
 16 | # syslogd
 17 | #  port (Default = 514)
 18 | #  file (Default = messages)
 19 | #  resolve (Default = true)
 20 | 
 21 | # To stop the resolution of IP's to PTR you can set resolve to false
 22 | 
 23 | # exit if fork   ## TODO: proper daemonize
 24 | 
 25 | require 'socket'
 26 | require 'resolv'
 27 | require_relative 'rest_client'
 28 | 
 29 | module Oxidized
 30 |   
 31 |   require 'asetus'
 32 |   class Config
 33 |     Root      = File.join ENV['HOME'], '.config', 'oxidized'
 34 |   end
 35 | 
 36 |   CFGS = Asetus.new :name=>'oxidized', :load=>false, :key_to_s=>true
 37 |   CFGS.default.syslogd.port        = 514
 38 |   CFGS.default.syslogd.file        = 'messages'
 39 |   CFGS.default.syslogd.resolve     = true
 40 | 
 41 |   begin
 42 |     CFGS.load
 43 |   rescue => error
 44 |     raise InvalidConfig, "Error loading config: #{error.message}"
 45 |   ensure
 46 |     CFG = CFGS.cfg  # convenienence, instead of Config.cfg.password, CFG.password
 47 |   end
 48 | 
 49 |   class SyslogMonitor
 50 |     NAME_MAP = {
 51 |       /(.*)\.ip\.tdc\.net/ => '\1',
 52 |       /(.*)\.ip\.fi/       => '\1',
 53 |     }
 54 |     MSG = {
 55 |       :ios   => /%SYS-(SW[0-9]+-)?5-CONFIG_I:/,
 56 |       :junos => 'UI_COMMIT:',
 57 |       :eos   => /%SYS-5-CONFIG_I:/,
 58 |       :nxos  => /%VSHD-5-VSHD_SYSLOG_CONFIG_I:/,
 59 |     }
 60 | 
 61 |     class << self
 62 |       def udp port=Oxidized::CFG.syslogd.port, listen=0
 63 |         io = UDPSocket.new
 64 |         io.bind listen, port
 65 |         new io, :udp
 66 |       end
 67 |       def file syslog_file=Oxidized::CFG.syslogd.file
 68 |         io = open syslog_file, 'r'
 69 |         io.seek 0, IO::SEEK_END
 70 |         new io, :file
 71 |       end
 72 |     end
 73 | 
 74 |     private
 75 | 
 76 |     def initialize io, mode=:udp
 77 |       @mode = mode
 78 |       run io
 79 |     end
 80 | 
 81 |     def rest opt
 82 |       Oxidized::RestClient.next opt
 83 |     end
 84 | 
 85 |     def ios ip, log, i
 86 |       # TODO: we need to fetch 'ip/name' in mode == :file here
 87 |       user = log[i+5]
 88 |       from = log[-1][1..-2]
 89 |       rest( :user => user, :from => from, :model => 'ios', :ip => ip,
 90 |             :name => getname(ip) )
 91 |     end
 92 | 
 93 |     def jnpr ip, log, i
 94 |       # TODO: we need to fetch 'ip/name' in mode == :file here
 95 |       user = log[i+2][1..-2]
 96 |       msg  = log[(i+6)..-1].join(' ')[10..-2]
 97 |       msg  = nil if msg == 'none'
 98 |       rest( :user => user, :msg => msg, :model => 'jnpr', :ip => ip,
 99 |             :name => getname(ip) )
100 |     end
101 | 
102 |     def handle_log log, ip
103 |       log = log.to_s.split ' '
104 |       if i = log.find_index { |e| e.match( MSG[:ios] ) }
105 |         ios ip, log,  i
106 |       elsif i = log.index(MSG[:junos])
107 |         jnpr ip, log, i
108 |       end
109 |     end
110 | 
111 |     def run io
112 |       while true
113 |         log = select [io]
114 |         log, ip = log.first.first, nil
115 |         if @mode == :udp
116 |           log, ip = log.recvfrom_nonblock 2000
117 |           ip = ip.last
118 |         else
119 |           begin
120 |             log = log.read_nonblock 2000
121 |           rescue EOFError
122 |             sleep 1
123 |             retry
124 |           end
125 |         end
126 |         handle_log log, ip
127 |       end
128 |     end
129 | 
130 |     def getname ip
131 |       if Oxidized::CFG.syslogd.resolve == false
132 |         ip
133 |       else
134 |         name = (Resolv.getname ip.to_s rescue ip)
135 |         NAME_MAP.each { |re, sub| name.sub! re, sub }
136 |         name
137 |       end
138 |     end
139 |   end
140 | end
141 | 
142 | Oxidized::SyslogMonitor.udp
143 | #Oxidized::SyslogMonitor.file '/var/log/poop'
144 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/aosw.rb:
--------------------------------------------------------------------------------
  1 | class AOSW < Oxidized::Model
  2 | 
  3 |   # AOSW Aruba Wireless, IAP, Instant Controller and Mobility Access Switches
  4 |   # Used in Alcatel OAW-4750 WLAN controller
  5 |   # Also Dell controllers
  6 |   
  7 |   # HPE Aruba Switches should use a different model as the software is based on the HP Procurve line.
  8 |   
  9 |   # Support for IAP & Instant Controller tested with 115, 205, 215 & 325 running 6.4.4.8-4.2.4.5_57965
 10 |   # Support for Mobility Access Switches tested with S2500-48P & S2500-24P running 7.4.1.4_54199 and S2500-24P running 7.4.1.7_57823
 11 |   # All IAPs connected to a Instant Controller will have the same config output. Only the controller needs to be monitored. 
 12 | 
 13 |   comment  '# '
 14 |   prompt /^\(?.+\)?\s?[#>]/
 15 | 
 16 |   cmd :all do |cfg|
 17 |     cfg.each_line.to_a[1..-2].join
 18 |   end
 19 | 
 20 |   cmd :secret do |cfg|
 21 |     cfg.gsub!(/secret (\S+)$/, 'secret <secret removed>')
 22 |     cfg.gsub!(/enable secret (\S+)$/, 'enable secret <secret removed>')
 23 |     cfg.gsub!(/PRE-SHARE (\S+)$/, 'PRE-SHARE <secret removed>')
 24 |     cfg.gsub!(/ipsec (\S+)$/, 'ipsec <secret removed>')
 25 |     cfg.gsub!(/community (\S+)$/, 'community <secret removed>')
 26 |     cfg.gsub!(/ sha (\S+)/, ' sha <secret removed>')
 27 |     cfg.gsub!(/ des (\S+)/, ' des <secret removed>')
 28 |     cfg.gsub!(/mobility-manager (\S+) user (\S+) (\S+)/, 'mobility-manager \1 user \2 <secret removed>')
 29 |     cfg.gsub!(/mgmt-user (\S+) (root|guest\-provisioning|network\-operations|read\-only|location\-api\-mgmt) (\S+)$/, 'mgmt-user \1 \2 <secret removed>') #MAS & Wireless Controler 
 30 |     cfg.gsub!(/mgmt-user (\S+) (\S+)( (read\-only|guest\-mgmt))?$/, 'mgmt-user \1 <secret removed> \3') #IAP 
 31 | #MAS format: mgmt-user <username> <accesslevel> <password hash>
 32 | #IAP format (root user): mgmt-user <username> <password hash>
 33 | #IAP format: mgmt-user <username> <password hash> <access level>
 34 |     cfg.gsub!(/key (\S+)$/, 'key <secret removed>')
 35 |     cfg.gsub!(/wpa-passphrase (\S+)$/, 'wpa-passphrase <secret removed>')
 36 |     cfg.gsub!(/bkup-passwords (\S+)$/, 'bkup-passwords <secret removed>')
 37 |     cfg.gsub!(/user (\S+) (\S+) (\S+)$/, 'user \1 <secret removed> \3')
 38 |     cfg.gsub!(/virtual-controller-key (\S+)$/, 'virtual-controller-key <secret removed>')
 39 |     cfg
 40 |   end
 41 | 
 42 |   cmd 'show version' do |cfg|
 43 |     cfg = cfg.each_line.select { |line| not line.match /(Switch|AP) uptime/i }
 44 |     rstrip_cfg comment cfg.join
 45 |   end
 46 | 
 47 |   cmd 'show inventory' do |cfg|
 48 |     cfg = "" if cfg.match /(Invalid input detected at '\^' marker|Parse error)/ #Don't show for unsupported devices (IAP and MAS)
 49 |     rstrip_cfg clean cfg
 50 |   end
 51 | 
 52 |   cmd 'show slots' do |cfg|
 53 |     cfg = "" if cfg.match /(Invalid input detected at '\^' marker|Parse error)/ #Don't show for unsupported devices (IAP and MAS)
 54 |     rstrip_cfg comment cfg
 55 |   end
 56 | 
 57 |   cmd 'show license' do |cfg|
 58 |     cfg = "" if cfg.match /(Invalid input detected at '\^' marker|Parse error)/ #Don't show for unsupported devices (IAP and MAS)
 59 |     rstrip_cfg comment cfg
 60 |   end
 61 | 
 62 |   cmd 'show running-config' do |cfg|
 63 |     out = []
 64 |     cfg.each_line do |line|
 65 |       next if line.match /^controller config \d+$/
 66 |       next if line.match /^Building Configuration/
 67 |       out << line.strip
 68 |     end
 69 |     out = out.join "\n"
 70 |     out << "\n"
 71 |   end
 72 | 
 73 |   cfg :telnet do
 74 |     username /^User:\s*/
 75 |     password /^Password:\s*/
 76 |   end
 77 | 
 78 |   cfg :telnet, :ssh do
 79 |     if vars :enable
 80 |       post_login do
 81 |         send "enable\n"
 82 |         cmd vars(:enable)
 83 |       end
 84 |     end
 85 |     post_login 'no paging'
 86 |     post_login 'encrypt disable'
 87 |     if vars :enable
 88 |       pre_logout 'exit'
 89 |     end
 90 |     pre_logout 'exit'
 91 |   end
 92 | 
 93 |   def rstrip_cfg cfg
 94 |     out = []
 95 |     cfg.each_line do |line|
 96 |       out << line.rstrip
 97 |     end
 98 |     out = out.join "\n"
 99 |     out << "\n"
100 |   end
101 | 
102 |   def clean cfg
103 |     out = []
104 |     cfg.each_line do |line|
105 |       # drop the temperature, fan speed and voltage, which change each run
106 |       next if line.match /Output \d Config/i
107 |       next if line.match /(Tachometers|Temperatures|Voltages)/
108 |       next if line.match /((Card|CPU) Temperature|Chassis Fan|VMON1[0-9])/
109 |       next if line.match /[0-9]+\s+(RPMS?|m?V|C)/i
110 |       out << line.strip
111 |     end
112 |     out = comment out.join "\n"
113 |     out << "\n"
114 |   end
115 | 
116 | end
117 | 


--------------------------------------------------------------------------------
/lib/oxidized/input/ssh.rb:
--------------------------------------------------------------------------------
  1 | module Oxidized
  2 |   require 'net/ssh'
  3 |   require 'net/ssh/proxy/command'
  4 |   require 'timeout'
  5 |   require 'oxidized/input/cli'
  6 |   class SSH < Input
  7 |     RescueFail = {
  8 |       :debug => [
  9 |         Net::SSH::Disconnect,
 10 |       ],
 11 |       :warn => [
 12 |         RuntimeError,
 13 |         Net::SSH::AuthenticationFailed,
 14 |       ],
 15 |     }
 16 |     include Input::CLI
 17 |     class NoShell < OxidizedError; end
 18 | 
 19 |     def connect node
 20 |       @node        = node
 21 |       @output      = ''
 22 |       @pty_options = { term: "vt100" }
 23 |       @node.model.cfg['ssh'].each { |cb| instance_exec(&cb) }
 24 |       secure = Oxidized.config.input.ssh.secure
 25 |       @log = File.open(Oxidized::Config::Log + "/#{@node.ip}-ssh", 'w') if Oxidized.config.input.debug?
 26 |       port = vars(:ssh_port) || 22
 27 |       if proxy_host = vars(:ssh_proxy)
 28 |         proxy =  Net::SSH::Proxy::Command.new("ssh #{proxy_host} -W %h:%p")
 29 |       end
 30 |       ssh_opts = {
 31 |         :port => port.to_i,
 32 |         :password => @node.auth[:password], :timeout => Oxidized.config.timeout,
 33 |         :paranoid => secure,
 34 |         :auth_methods => %w(none publickey password keyboard-interactive),
 35 |         :number_of_password_prompts => 0,
 36 |         :proxy => proxy,
 37 |       }
 38 |       ssh_opts[:keys] = vars(:ssh_keys).is_a?(Array) ? vars(:ssh_keys) : [vars(:ssh_keys)] if vars(:ssh_keys)
 39 |       ssh_opts[:kex]  = vars(:ssh_kex).split(/,\s*/) if vars(:ssh_kex)
 40 |       ssh_opts[:encryption] = vars(:ssh_encryption).split(/,\s*/) if vars(:ssh_encryption)
 41 | 
 42 |       Oxidized.logger.debug "lib/oxidized/input/ssh.rb: Connecting to #{@node.name}"
 43 |       @ssh = Net::SSH.start(@node.ip, @node.auth[:username], ssh_opts)
 44 |       unless @exec
 45 |         shell_open @ssh
 46 |         begin
 47 |           login
 48 |         rescue Timeout::Error
 49 |           raise PromptUndetect, [ @output, 'not matching configured prompt', @node.prompt ].join(' ')
 50 |         end
 51 |       end
 52 |       connected?
 53 |     end
 54 | 
 55 |     def connected?
 56 |       @ssh and not @ssh.closed?
 57 |     end
 58 | 
 59 |     def cmd cmd, expect=node.prompt
 60 |       Oxidized.logger.debug "lib/oxidized/input/ssh.rb #{cmd} @ #{node.name} with expect: #{expect.inspect}"
 61 |       if @exec
 62 |         @ssh.exec! cmd
 63 |       else
 64 |         cmd_shell(cmd, expect).gsub(/\r\n/, "\n")
 65 |       end
 66 |     end
 67 | 
 68 |     def send data
 69 |       @ses.send_data data
 70 |     end
 71 | 
 72 |     def output
 73 |       @output
 74 |     end
 75 | 
 76 |     def pty_options hash
 77 |       @pty_options = @pty_options.merge hash
 78 |     end
 79 | 
 80 |     private
 81 | 
 82 |     def disconnect
 83 |       disconnect_cli
 84 |       # if disconnect does not disconnect us, give up after timeout
 85 |       Timeout::timeout(Oxidized.config.timeout) { @ssh.loop }
 86 |     rescue Errno::ECONNRESET, Net::SSH::Disconnect, IOError
 87 |     ensure
 88 |       @log.close if Oxidized.config.input.debug?
 89 |       (@ssh.close rescue true) unless @ssh.closed?
 90 |     end
 91 | 
 92 |     def shell_open ssh
 93 |       @ses = ssh.open_channel do |ch|
 94 |         ch.on_data do |_ch, data|
 95 |           if Oxidized.config.input.debug?
 96 |             @log.print data
 97 |             @log.fsync
 98 |           end
 99 |           @output << data
100 |           @output = @node.model.expects @output
101 |         end
102 |         ch.request_pty (@pty_options) do |_ch, success_pty|
103 |           raise NoShell, "Can't get PTY" unless success_pty
104 |           ch.send_channel_request 'shell' do |_ch, success_shell|
105 |             raise NoShell, "Can't get shell" unless success_shell
106 |           end
107 |         end
108 |       end
109 |     end
110 | 
111 |     # some models have SSH auth or terminal auth based on version of code
112 |     # if SSH is configured for terminal auth, we'll still try to detect prompt
113 |     def login
114 |       if @username
115 |         match = expect username, @node.prompt
116 |         if match == username
117 |           cmd @node.auth[:username], password
118 |           cmd @node.auth[:password]
119 |         end
120 |       else
121 |         expect @node.prompt
122 |       end
123 |     end
124 | 
125 |     def exec state=nil
126 |       state == nil ? @exec : (@exec=state) unless vars :ssh_no_exec
127 |     end
128 | 
129 |     def cmd_shell(cmd, expect_re)
130 |       @output = ''
131 |       @ses.send_data cmd + "\n"
132 |       @ses.process
133 |       expect expect_re if expect_re
134 |       @output
135 |     end
136 | 
137 |     def expect *regexps
138 |       regexps = [regexps].flatten
139 |       Oxidized.logger.debug "lib/oxidized/input/ssh.rb: expecting #{regexps.inspect} at #{node.name}"
140 |       Timeout::timeout(Oxidized.config.timeout) do
141 |         @ssh.loop(0.1) do
142 |           sleep 0.1
143 |           match = regexps.find { |regexp| @output.match regexp }
144 |           return match if match
145 |           true
146 |         end
147 |       end
148 |     end
149 | 
150 |   end
151 | end
152 | 


--------------------------------------------------------------------------------
/lib/oxidized/model/model.rb:
--------------------------------------------------------------------------------
  1 | require 'strscan'
  2 | require_relative 'outputs'
  3 | 
  4 | module Oxidized
  5 |   class Model
  6 |     include Oxidized::Config::Vars
  7 | 
  8 |     class << self
  9 |       def inherited klass
 10 |         klass.instance_variable_set '@cmd',   Hash.new { |h,k| h[k] = [] }
 11 |         klass.instance_variable_set '@cfg',   Hash.new { |h,k| h[k] = [] }
 12 |         klass.instance_variable_set '@procs', Hash.new { |h,k| h[k] = [] }
 13 |         klass.instance_variable_set '@expect', []
 14 |         klass.instance_variable_set '@comment', nil
 15 |         klass.instance_variable_set '@prompt', nil
 16 |       end
 17 |       def comment _comment='# '
 18 |         return @comment if @comment
 19 |         @comment = block_given? ? yield : _comment
 20 |       end
 21 |       def prompt _prompt=nil
 22 |         @prompt or @prompt = _prompt
 23 |       end
 24 |       def cfg *methods, &block
 25 |         [methods].flatten.each do |method|
 26 |           @cfg[method.to_s] << block
 27 |         end
 28 |       end
 29 |       def cfgs
 30 |         @cfg
 31 |       end
 32 |       def cmd _cmd=nil, &block
 33 |         if _cmd.class == Symbol
 34 |           @cmd[_cmd] << block
 35 |         else
 36 |           @cmd[:cmd] << [_cmd, block]
 37 |         end
 38 |         Oxidized.logger.debug "lib/oxidized/model/model.rb Added #{_cmd} to the commands list"
 39 |       end
 40 |       def cmds
 41 |         @cmd
 42 |       end
 43 |       def expect re, &block
 44 |         @expect << [re, block]
 45 |       end
 46 |       def expects
 47 |         @expect
 48 |       end
 49 | 
 50 |       # calls the block at the end of the model, prepending the output of the
 51 |       # block to the output string
 52 |       #
 53 |       # @author Saku Ytti <saku@ytti.fi>
 54 |       # @since 0.0.39
 55 |       # @yield expects block which should return [String]
 56 |       # @return [void]
 57 |       def pre &block
 58 |         @procs[:pre] << block
 59 |       end
 60 | 
 61 |       # calls the block at the end of the model, adding the output of the block
 62 |       # to the output string
 63 |       #
 64 |       # @author Saku Ytti <saku@ytti.fi>
 65 |       # @since 0.0.39
 66 |       # @yield expects block which should return [String]
 67 |       # @return [void]
 68 |       def post &block
 69 |         @procs[:post] << block
 70 |       end
 71 | 
 72 |       # @author Saku Ytti <saku@ytti.fi>
 73 |       # @since 0.0.39
 74 |       # @return [Hash] hash proc procs :pre+:post to be prepended/postfixed to output
 75 |       def procs
 76 |         @procs
 77 |       end
 78 |     end
 79 | 
 80 |     attr_accessor :input, :node
 81 | 
 82 |     def cmd string, &block
 83 |       Oxidized.logger.debug "lib/oxidized/model/model.rb Executing #{string}"
 84 |       out = @input.cmd(string)
 85 |       return false unless out
 86 |       self.class.cmds[:all].each do |all_block|
 87 |         out = instance_exec Oxidized::String.new(out), string, &all_block
 88 |       end
 89 |       if vars :remove_secret
 90 |         self.class.cmds[:secret].each do |all_block|
 91 |           out = instance_exec Oxidized::String.new(out), string, &all_block
 92 |         end
 93 |       end
 94 |       out = instance_exec Oxidized::String.new(out), &block if block
 95 |       process_cmd_output out, string
 96 |     end
 97 | 
 98 |     def output
 99 |       @input.output
100 |     end
101 | 
102 |     def send data
103 |       @input.send data
104 |     end
105 | 
106 |     def expect re, &block
107 |       self.class.expect re, &block
108 |     end
109 | 
110 |     def cfg
111 |       self.class.cfgs
112 |     end
113 | 
114 |     def prompt
115 |       self.class.prompt
116 |     end
117 | 
118 |     def expects data
119 |       self.class.expects.each do |re, cb|
120 |         if data.match re
121 |           if cb.arity == 2
122 |             data = instance_exec [data, re], &cb
123 |           else
124 |             data = instance_exec data, &cb
125 |           end
126 |         end
127 |       end
128 |       data
129 |     end
130 | 
131 |     def get
132 |       Oxidized.logger.debug 'lib/oxidized/model/model.rb Collecting commands\' outputs'
133 |       outputs = Outputs.new
134 |       procs = self.class.procs
135 |       self.class.cmds[:cmd].each do |command, block|
136 |         out = cmd command, &block
137 |         return false unless out
138 |         outputs << out
139 |       end
140 |       procs[:pre].each do |pre_proc|
141 |         outputs.unshift process_cmd_output(instance_eval(&pre_proc), '')
142 |       end
143 |       procs[:post].each do |post_proc|
144 |         outputs << process_cmd_output(instance_eval(&post_proc), '')
145 |       end
146 |       outputs
147 |     end
148 | 
149 |     def comment _comment
150 |       data = ''
151 |       _comment.each_line do |line|
152 |         data << self.class.comment << line
153 |       end
154 |       data
155 |     end
156 | 
157 |     def screenscrape
158 |       @input.class.to_s.match(/Telnet/) || vars(:ssh_no_exec)
159 |     end
160 | 
161 |     private
162 | 
163 |     def process_cmd_output output, name
164 |       output = Oxidized::String.new output if ::String === output
165 |       output = Oxidized::String.new '' unless Oxidized::String === output
166 |       output.set_cmd(name)
167 |       output
168 |     end
169 | 
170 |   end
171 | end
172 | 


--------------------------------------------------------------------------------
/lib/oxidized/input/telnet.rb:
--------------------------------------------------------------------------------
  1 | module Oxidized
  2 |   require 'net/telnet'
  3 |   require 'oxidized/input/cli'
  4 |   class Telnet < Input
  5 |     RescueFail = {}
  6 |     include Input::CLI
  7 |     attr_reader :telnet
  8 | 
  9 |     def connect node
 10 |       @node    = node
 11 |       @timeout = Oxidized.config.timeout
 12 |       @node.model.cfg['telnet'].each { |cb| instance_exec(&cb) }
 13 |       port = vars(:telnet_port) || 23
 14 | 
 15 |       opt = { 'Host'    => @node.ip,
 16 |               'Port'    => port.to_i,
 17 |               'Timeout' => @timeout,
 18 |               'Model'   => @node.model }
 19 |       opt['Output_log'] = Oxidized::Config::Log + "/#{@node.ip}-telnet" if Oxidized.config.input.debug?
 20 | 
 21 |       @telnet  = Net::Telnet.new opt
 22 |       if @node.auth[:username] and @node.auth[:username].length > 0
 23 |         expect username
 24 |         @telnet.puts @node.auth[:username]
 25 |       end
 26 |       expect password
 27 |       @telnet.puts @node.auth[:password]
 28 |       begin
 29 |         expect @node.prompt
 30 |       rescue Timeout::Error
 31 |         raise PromptUndetect, [ 'unable to detect prompt:', @node.prompt ].join(' ')
 32 |       end
 33 |     end
 34 | 
 35 |     def connected?
 36 |       @telnet and not @telnet.sock.closed?
 37 |     end
 38 | 
 39 |     def cmd cmd, expect=@node.prompt
 40 |       Oxidized.logger.debug "Telnet: #{cmd} @#{@node.name}"
 41 |       args = { 'String' => cmd }
 42 |       args.merge!({ 'Match' => expect, 'Timeout' => @timeout }) if expect
 43 |       @telnet.cmd args
 44 |     end
 45 | 
 46 |     def send data
 47 |       @telnet.write data
 48 |     end
 49 | 
 50 |     def output
 51 |       @telnet.output
 52 |     end
 53 | 
 54 |     private
 55 | 
 56 |     def expect re
 57 |       @telnet.waitfor 'Match' => re, 'Timeout' => @timeout
 58 |     end
 59 | 
 60 |     def disconnect
 61 |       begin
 62 |         disconnect_cli
 63 |         @telnet.close
 64 |       rescue Errno::ECONNRESET
 65 |       end
 66 |     end
 67 | 
 68 |   end
 69 | end
 70 | 
 71 | 
 72 | class Net::Telnet
 73 |   ## FIXME: we just need 'line = model.expects line' to handle pager
 74 |   ## how to do this, without redefining the whole damn thing
 75 |   ## FIXME: we also need output (not sure I'm going to support this)
 76 |   attr_reader :output
 77 |   def waitfor(options) # :yield: recvdata
 78 |     time_out = @options["Timeout"]
 79 |     waittime = @options["Waittime"]
 80 |     fail_eof = @options["FailEOF"]
 81 |     model    = @options["Model"]
 82 | 
 83 |     if options.kind_of?(Hash)
 84 |       prompt   = if options.has_key?("Match")
 85 |                    options["Match"]
 86 |                  elsif options.has_key?("Prompt")
 87 |                    options["Prompt"]
 88 |                  elsif options.has_key?("String")
 89 |                    Regexp.new( Regexp.quote(options["String"]) )
 90 |                  end
 91 |       time_out = options["Timeout"]  if options.has_key?("Timeout")
 92 |       waittime = options["Waittime"] if options.has_key?("Waittime")
 93 |       fail_eof = options["FailEOF"]  if options.has_key?("FailEOF")
 94 |     else
 95 |       prompt = options
 96 |     end
 97 | 
 98 |     if time_out == false
 99 |       time_out = nil
100 |     end
101 | 
102 |     line = ''
103 |     buf = ''
104 |     rest = ''
105 |     until(prompt === line and not IO::select([@sock], nil, nil, waittime))
106 |       unless IO::select([@sock], nil, nil, time_out)
107 |         raise TimeoutError, "timed out while waiting for more data"
108 |       end
109 |       begin
110 |         c = @sock.readpartial(1024 * 1024)
111 |         @output = c
112 |         @dumplog.log_dump('<', c) if @options.has_key?("Dump_log")
113 |         if @options["Telnetmode"]
114 |           c = rest + c
115 |           if Integer(c.rindex(/#{IAC}#{SE}/no) || 0) <
116 |              Integer(c.rindex(/#{IAC}#{SB}/no) || 0)
117 |             buf = preprocess(c[0 ... c.rindex(/#{IAC}#{SB}/no)])
118 |             rest = c[c.rindex(/#{IAC}#{SB}/no) .. -1]
119 |           elsif pt = c.rindex(/#{IAC}[^#{IAC}#{AO}#{AYT}#{DM}#{IP}#{NOP}]?\z/no) ||
120 |                      c.rindex(/\r\z/no)
121 |             buf = preprocess(c[0 ... pt])
122 |             rest = c[pt .. -1]
123 |           else
124 |             buf = preprocess(c)
125 |             rest = ''
126 |           end
127 |        else
128 |          # Not Telnetmode.
129 |          #
130 |          # We cannot use preprocess() on this data, because that
131 |          # method makes some Telnetmode-specific assumptions.
132 |          buf = rest + c
133 |          rest = ''
134 |          unless @options["Binmode"]
135 |            if pt = buf.rindex(/\r\z/no)
136 |              buf = buf[0 ... pt]
137 |              rest = buf[pt .. -1]
138 |            end
139 |            buf.gsub!(/#{EOL}/no, "\n")
140 |          end
141 |         end
142 |         @log.print(buf) if @options.has_key?("Output_log")
143 |         line += buf
144 |         line = model.expects line
145 |         line = yield line if block_given?
146 |         yield buf if block_given?
147 |       rescue EOFError # End of file reached
148 |         raise if fail_eof
149 |         if line == ''
150 |           line = nil
151 |           yield nil if block_given?
152 |         end
153 |         break
154 |       end
155 |     end
156 |     line
157 |   end
158 | end
159 | 


--------------------------------------------------------------------------------
/lib/oxidized/nodes.rb:
--------------------------------------------------------------------------------
  1 | module Oxidized
  2 |   require 'ipaddr'
  3 |   require 'oxidized/node'
  4 |   class Oxidized::NotSupported < OxidizedError; end
  5 |   class Oxidized::NodeNotFound < OxidizedError; end
  6 |   class Nodes < Array
  7 |     attr_accessor :source, :jobs
  8 |     alias :put :unshift
  9 |     def load node_want=nil
 10 |       with_lock do
 11 |         new = []
 12 |         @source = Oxidized.config.source.default
 13 |         Oxidized.mgr.add_source @source
 14 |         Oxidized.logger.info "lib/oxidized/nodes.rb: Loading nodes"
 15 |         Oxidized.mgr.source[@source].new.load.each do |node|
 16 |           # we want to load specific node(s), not all of them
 17 |           next unless node_want? node_want, node
 18 |           begin
 19 |             _node = Node.new node
 20 |             new.push _node
 21 |           rescue ModelNotFound => err
 22 |             Oxidized.logger.error "node %s raised %s with message '%s'" % [node, err.class, err.message]
 23 |           rescue Resolv::ResolvError => err
 24 |             Oxidized.logger.error "node %s is not resolvable, raised %s with message '%s'" % [node, err.class, err.message]
 25 |           end
 26 |         end
 27 |         size == 0 ? replace(new) : update_nodes(new)
 28 |         Oxidized.logger.info "lib/oxidized/nodes.rb: Loaded #{size} nodes"
 29 |       end
 30 |     end
 31 | 
 32 |     def node_want? node_want, node
 33 |       return true unless node_want
 34 |       node_want_ip = (IPAddr.new(node_want) rescue false)
 35 |       name_is_ip   = (IPAddr.new(node[:name]) rescue false)
 36 |       if name_is_ip and node_want_ip == node[:name]
 37 |         true
 38 |       elsif node[:ip] and node_want_ip == node[:ip]
 39 |         true
 40 |       elsif node_want.match node[:name]
 41 |         true unless name_is_ip
 42 |       end
 43 |     end
 44 | 
 45 | 
 46 |     def list
 47 |       with_lock do
 48 |         map { |e| e.serialize }
 49 |       end
 50 |     end
 51 | 
 52 |     def show node
 53 |       with_lock do
 54 |         i = find_node_index node
 55 |         self[i].serialize
 56 |       end
 57 |     end
 58 | 
 59 |     def fetch node_name, group
 60 |       yield_node_output(node_name) do |node, output|
 61 |         output.fetch node, group
 62 |       end
 63 |     end
 64 | 
 65 |     # @param node [String] name of the node moved into the head of array
 66 |     def next node, opt={}
 67 |       if waiting.find_node_index(node)
 68 |         with_lock do
 69 |           n = del node
 70 |           n.user = opt['user']
 71 |           n.msg  = opt['msg']
 72 |           n.from = opt['from']
 73 |           # set last job to nil so that the node is picked for immediate update
 74 |           n.last = nil
 75 |           put n
 76 |           jobs.want += 1 if Oxidized.config.next_adds_job?
 77 |         end
 78 |       end
 79 |     end
 80 |     alias :top :next
 81 | 
 82 |     # @return [String] node from the head of the array
 83 |     def get
 84 |       with_lock do
 85 |         (self << shift).last
 86 |       end
 87 |     end
 88 | 
 89 |     # @param node node whose index number in Nodes to find
 90 |     # @return [Fixnum] index number of node in Nodes
 91 |     def find_node_index node
 92 |       find_index node or raise Oxidized::NodeNotFound, "unable to find '#{node}'"
 93 |     end
 94 | 
 95 |     def version node_name, group
 96 |       yield_node_output(node_name) do |node, output|
 97 |         output.version node, group
 98 |       end
 99 |     end
100 | 
101 |     def get_version node_name, group, oid
102 |       yield_node_output(node_name) do |node, output|
103 |         output.get_version node, group, oid
104 |       end
105 |     end
106 | 
107 |     def get_diff node_name, group, oid1, oid2
108 |       yield_node_output(node_name) do |node, output|
109 |         output.get_diff node, group, oid1, oid2
110 |       end
111 |     end
112 | 
113 |     private
114 | 
115 |     def initialize opts={}
116 |       super()
117 |       node = opts.delete :node
118 |       @mutex= Mutex.new  # we compete for the nodes with webapi thread
119 |       if nodes = opts.delete(:nodes)
120 |         replace nodes
121 |       else
122 |         load node
123 |       end
124 |     end
125 | 
126 |     def with_lock &block
127 |       @mutex.synchronize(&block)
128 |     end
129 | 
130 |     def find_index node
131 |       index { |e| e.name == node or e.ip == node}
132 |     end
133 | 
134 |     # @param node node which is removed from nodes list
135 |     # @return [Node] deleted node
136 |     def del node
137 |       delete_at find_node_index(node)
138 |     end
139 | 
140 |     # @return [Nodes] list of nodes running now
141 |     def running
142 |       Nodes.new :nodes => select { |node| node.running? }
143 |     end
144 | 
145 |     # @return [Nodes] list of nodes waiting (not running)
146 |     def waiting
147 |       Nodes.new :nodes => select { |node| not node.running? }
148 |     end
149 | 
150 |     # walks list of new nodes, if old node contains same name, adds last and
151 |     # stats information from old to new.
152 |     #
153 |     # @todo can we trust name to be unique identifier, what about when groups are used?
154 |     # @param [Array] nodes Array of nodes used to replace+update old
155 |     def update_nodes nodes
156 |       old = self.dup
157 |       replace(nodes)
158 |       each do |node|
159 |         begin
160 |           if i = old.find_node_index(node.name)
161 |             node.stats = old[i].stats
162 |             node.last  = old[i].last
163 |           end
164 |         rescue  Oxidized::NodeNotFound
165 |         end
166 |       end
167 |       sort_by! { |x| x.last.nil? ? Time.new(0) : x.last.end }
168 |     end
169 | 
170 |     def yield_node_output(node_name)
171 |       with_lock do
172 |         node = find { |n| n.name == node_name }
173 |         output = node.output.new
174 |         raise Oxidized::NotSupported unless output.respond_to? :fetch
175 |         yield node, output
176 |       end
177 |     end
178 |   end
179 | end
180 | 


--------------------------------------------------------------------------------
/lib/oxidized/output/git.rb:
--------------------------------------------------------------------------------
  1 | module Oxidized
  2 | class Git < Output
  3 |   class GitError < OxidizedError; end
  4 |   begin
  5 |     require 'rugged'
  6 |   rescue LoadError
  7 |     raise OxidizedError, 'rugged not found: sudo gem install rugged'
  8 |   end
  9 | 
 10 |   attr_reader :commitref
 11 | 
 12 |   def initialize
 13 |     @cfg = Oxidized.config.output.git
 14 |   end
 15 | 
 16 |   def setup
 17 |     if @cfg.empty?
 18 |       Oxidized.asetus.user.output.git.user  = 'Oxidized'
 19 |       Oxidized.asetus.user.output.git.email = 'o@example.com'
 20 |       Oxidized.asetus.user.output.git.repo  =  File.join(Config::Root, 'oxidized.git')
 21 |       Oxidized.asetus.save :user
 22 |       raise NoConfig, 'no output git config, edit ~/.config/oxidized/config'
 23 |     end
 24 | 
 25 |     if @cfg.repo.respond_to?(:each)
 26 |       @cfg.repo.each do |group, repo|
 27 |         @cfg.repo["#{group}="] = File.expand_path repo
 28 |       end
 29 |     else
 30 |       @cfg.repo = File.expand_path @cfg.repo
 31 |     end
 32 |   end
 33 | 
 34 |   def store file, outputs, opt={}
 35 |     @msg   = opt[:msg]
 36 |     @user  = (opt[:user]  or @cfg.user)
 37 |     @email = (opt[:email] or @cfg.email)
 38 |     @opt   = opt
 39 |     @commitref = nil
 40 |     repo   = @cfg.repo
 41 | 
 42 |     outputs.types.each do |type|
 43 |       type_cfg = ''
 44 |       type_repo = File.join(File.dirname(repo), type + '.git')
 45 |       outputs.type(type).each do |output|
 46 |         (type_cfg << output; next) if not output.name
 47 |         type_file = file + '--' + output.name
 48 |         if @cfg.type_as_directory?
 49 |           type_file = type + '/' + type_file
 50 |           type_repo = repo
 51 |         end
 52 |         update type_repo, type_file, output
 53 |       end
 54 |       update type_repo, file, type_cfg
 55 |     end
 56 | 
 57 |     update repo, file, outputs.to_cfg
 58 |   end
 59 | 
 60 | 
 61 |   def fetch node, group
 62 |     begin
 63 |       repo, path = yield_repo_and_path(node, group)
 64 |       repo = Rugged::Repository.new repo
 65 |       index = repo.index
 66 |       index.read_tree repo.head.target.tree unless repo.empty?
 67 |       repo.read(index.get(path)[:oid]).data
 68 |     rescue
 69 |       'node not found'
 70 |     end
 71 |   end
 72 | 
 73 |     # give a hash of all oid revision for the given node, and the date of the commit
 74 |     def version node, group
 75 |       begin
 76 |         repo, path = yield_repo_and_path(node, group)
 77 | 
 78 |         repo = Rugged::Repository.new repo
 79 |         walker = Rugged::Walker.new(repo)
 80 |         walker.sorting(Rugged::SORT_DATE)
 81 |         walker.push(repo.head.target)
 82 |         i = -1
 83 |         tab  = []
 84 |         walker.each do |commit|
 85 |           if commit.diff(paths: [path]).size > 0
 86 |             hash = {}
 87 |             hash[:date] = commit.time.to_s
 88 |             hash[:oid] = commit.oid
 89 |             hash[:author] = commit.author
 90 |             hash[:message] = commit.message
 91 |             tab[i += 1] = hash
 92 |           end
 93 |         end
 94 |         walker.reset
 95 |         tab
 96 |       rescue
 97 |         'node not found'
 98 |       end
 99 |     end
100 | 
101 |     #give the blob of a specific revision
102 |     def get_version node, group, oid
103 |       begin
104 |         repo, path = yield_repo_and_path(node, group)
105 |         repo = Rugged::Repository.new repo
106 |         repo.blob_at(oid,path).content
107 |       rescue
108 |         'version not found'
109 |       end
110 |     end
111 | 
112 |     #give a hash with the patch of a diff between 2 revision and the stats (added and deleted lines)
113 |     def get_diff node, group, oid1, oid2
114 |       begin
115 |         diff_commits = nil
116 |         repo, _ = yield_repo_and_path(node, group)
117 |         repo = Rugged::Repository.new repo
118 |         commit = repo.lookup(oid1)
119 | 
120 |         if oid2
121 |           commit_old = repo.lookup(oid2)
122 |           diff = repo.diff(commit_old, commit)
123 |           diff.each do |patch|
124 |             if /#{node.name}\s+/.match(patch.to_s.lines.first)
125 |               diff_commits = {:patch => patch.to_s, :stat => patch.stat}
126 |               break
127 |             end
128 |           end
129 |         else
130 |           stat = commit.parents[0].diff(commit).stat
131 |           stat = [stat[1],stat[2]]
132 |           patch = commit.parents[0].diff(commit).patch
133 |           diff_commits = {:patch => patch, :stat => stat}
134 |         end
135 | 
136 |         diff_commits
137 |       rescue
138 |         'no diffs'
139 |       end
140 |     end
141 | 
142 |   private
143 | 
144 |   def yield_repo_and_path(node, group)
145 |     repo, path = node.repo, node.name
146 | 
147 |     if group and @cfg.single_repo?
148 |       path = "#{group}/#{node.name}"
149 |     end
150 | 
151 |     [repo, path]
152 |   end
153 | 
154 |   def update repo, file, data
155 |     return if data.empty?
156 | 
157 |     if @opt[:group]
158 |       if @cfg.single_repo?
159 |         file = File.join @opt[:group], file
160 |       else
161 |         repo = if repo.is_a?(::String)
162 |                  File.join File.dirname(repo), @opt[:group] + '.git'
163 |                else
164 |                  repo[@opt[:group]]
165 |                end
166 |       end
167 |     end
168 | 
169 |     begin
170 |       repo = Rugged::Repository.new repo
171 |       update_repo repo, file, data, @msg, @user, @email
172 |     rescue Rugged::OSError, Rugged::RepositoryError => open_error
173 |       begin
174 |         Rugged::Repository.init_at repo, :bare
175 |       rescue => create_error
176 |         raise GitError, "first '#{open_error.message}' was raised while opening git repo, then '#{create_error.message}' was while trying to create git repo"
177 |       end
178 |       retry
179 |     end
180 |   end
181 | 
182 |   def update_repo repo, file, data, msg, user, email
183 |     oid = repo.write data, :blob
184 |     index = repo.index
185 |     index.read_tree repo.head.target.tree unless repo.empty?
186 | 
187 |     tree_old = index.write_tree repo
188 |     index.add :path=>file, :oid=>oid, :mode=>0100644
189 |     tree_new = index.write_tree repo
190 | 
191 |     if tree_old != tree_new
192 |       repo.config['user.name']  = user
193 |       repo.config['user.email'] = email
194 |       @commitref = Rugged::Commit.create(repo,
195 |         :tree       => index.write_tree(repo),
196 |         :message    => msg,
197 |         :parents    => repo.empty? ? [] : [repo.head.target].compact,
198 |         :update_ref => 'HEAD',
199 |       )
200 | 
201 |       index.write
202 |       true
203 |     end
204 |   end
205 | end
206 | end
207 | 


--------------------------------------------------------------------------------
/spec/githubrepo_spec.rb:
--------------------------------------------------------------------------------
  1 | require 'spec_helper'
  2 | require 'rugged'
  3 | require 'oxidized/hook/githubrepo'
  4 | 
  5 | describe GithubRepo do
  6 |   let(:credentials) { mock() }
  7 |   let(:remote) { mock() }
  8 |   let(:remotes) { mock() }
  9 |   let(:repo_head) { mock() }
 10 |   let(:repo) { mock() }
 11 |   let(:gr) { GithubRepo.new }
 12 | 
 13 |   before do
 14 |     Oxidized.asetus = Asetus.new
 15 |     Oxidized.config.log = '/dev/null'
 16 |     Oxidized.setup_logger
 17 |     Oxidized.config.output.default = 'git'
 18 |   end
 19 | 
 20 |   describe '#validate_cfg!' do
 21 |     before do
 22 |       gr.expects(:respond_to?).with(:validate_cfg!).returns(false) # `cfg=` call
 23 |     end
 24 | 
 25 |     it 'raise a error when `remote_repo` is not configured' do
 26 |       Oxidized.config.hooks.github_repo_hook = { type: 'githubrepo' }
 27 |       gr.cfg = Oxidized.config.hooks.github_repo_hook
 28 |       proc { gr.validate_cfg! }.must_raise(KeyError)
 29 |     end
 30 |   end
 31 | 
 32 |   describe "#fetch_and_merge_remote" do
 33 |     before(:each) do
 34 |       Oxidized.config.hooks.github_repo_hook.remote_repo = 'git@github.com:username/foo.git'
 35 |       Rugged::Credentials::SshKeyFromAgent.expects(:new).with(username: 'git').returns(credentials)
 36 |       repo_head.expects(:name).returns('refs/heads/master')
 37 |       gr.cfg = Oxidized.config.hooks.github_repo_hook
 38 |     end
 39 | 
 40 |     it "should not try to merge when there is no update in remote branch" do
 41 |       repo.expects(:fetch).with('origin', ['refs/heads/master'], credentials: credentials).returns(Hash.new(0))
 42 |       repo.expects(:branches).never
 43 |       repo.expects(:head).returns(repo_head)
 44 |       gr.fetch_and_merge_remote(repo).must_equal nil
 45 |     end
 46 |     describe "when there is update considering conflicts" do
 47 |       let(:merge_index) { mock() }
 48 |       let(:their_branch) { mock() }
 49 | 
 50 |       before(:each) do
 51 |         repo.expects(:fetch).with('origin', ['refs/heads/master'], credentials: credentials).returns({total_deltas: 1})
 52 |         their_branch.expects(:target_id).returns(1)
 53 |         repo_head.expects(:target_id).returns(2)
 54 |         repo.expects(:merge_commits).with(2, 1).returns(merge_index)
 55 |         repo.expects(:branches).returns({"origin/master" => their_branch})
 56 |       end
 57 | 
 58 |       it "should not try merging when there's conflict" do
 59 |         repo.expects(:head).twice.returns(repo_head)
 60 |         their_branch.expects(:name).returns("origin/master")
 61 |         merge_index.expects(:conflicts?).returns(true)
 62 |         Rugged::Commit.expects(:create).never
 63 |         gr.fetch_and_merge_remote(repo).must_equal nil
 64 |       end
 65 | 
 66 |       it "should merge when there is no conflict" do
 67 |         repo.expects(:head).times(3).returns(repo_head)
 68 |         their_branch.expects(:target).returns("their_target")
 69 |         their_branch.expects(:name).twice.returns("origin/master")
 70 |         repo_head.expects(:target).returns("our_target")
 71 |         merge_index.expects(:write_tree).with(repo).returns("tree")
 72 |         merge_index.expects(:conflicts?).returns(false)
 73 |         Rugged::Commit.expects(:create).with(repo, {
 74 |           parents: ["our_target", "their_target"],
 75 |           tree: "tree",
 76 |           message: "Merge remote-tracking branch 'origin/master'",
 77 |           update_ref: "HEAD"
 78 |         }).returns(1)
 79 |         gr.fetch_and_merge_remote(repo).must_equal 1
 80 |       end
 81 |     end
 82 |   end
 83 | 
 84 |   describe "#run_hook" do
 85 |     let(:group) { nil }
 86 |     let(:ctx) { OpenStruct.new(node: node) }
 87 |     let(:node) do
 88 |       Oxidized::Node.new(ip: '127.0.0.1', group: group, model: 'junos', output: 'git')
 89 |     end
 90 | 
 91 |     before do
 92 |       repo_head.expects(:name).twice.returns('refs/heads/master')
 93 |       repo.expects(:head).twice.returns(repo_head)
 94 |       repo.expects(:path).returns('/foo.git')
 95 |       repo.expects(:fetch).with('origin', ['refs/heads/master'], credentials: credentials).returns(Hash.new(0))
 96 |     end
 97 | 
 98 |     describe 'when there is only one repository and no groups' do
 99 |       before do
100 |         Oxidized.config.output.git.repo = '/foo.git'
101 |         remote.expects(:url).returns('https://github.com/username/foo.git')
102 |         remote.expects(:push).with(['refs/heads/master'], credentials: credentials).returns(true)
103 |         repo.expects(:remotes).returns({'origin' => remote})
104 |         Rugged::Repository.expects(:new).with('/foo.git').returns(repo)
105 |       end
106 | 
107 |       it "will push to the remote repository using https" do
108 |         Oxidized.config.hooks.github_repo_hook.remote_repo = 'https://github.com/username/foo.git'
109 |         Oxidized.config.hooks.github_repo_hook.username = 'username'
110 |         Oxidized.config.hooks.github_repo_hook.password = 'password'
111 |         Rugged::Credentials::UserPassword.expects(:new).with(username: 'username', password: 'password').returns(credentials)
112 |         gr.cfg = Oxidized.config.hooks.github_repo_hook
113 |         gr.run_hook(ctx).must_equal true
114 |       end
115 | 
116 |       it "will push to the remote repository using ssh" do
117 |         Oxidized.config.hooks.github_repo_hook.remote_repo = 'git@github.com:username/foo.git'
118 |         Rugged::Credentials::SshKeyFromAgent.expects(:new).with(username: 'git').returns(credentials)
119 |         gr.cfg = Oxidized.config.hooks.github_repo_hook
120 |         gr.run_hook(ctx).must_equal true
121 |       end
122 |     end
123 | 
124 |     describe "when there are groups" do
125 |       let(:group) { 'ggrroouupp' }
126 | 
127 |       before do
128 |         Rugged::Credentials::SshKeyFromAgent.expects(:new).with(username: 'git').returns(credentials)
129 |         Rugged::Repository.expects(:new).with(repository).returns(repo)
130 | 
131 |         repo.expects(:remotes).twice.returns(remotes)
132 |         remotes.expects(:[]).with('origin').returns(nil)
133 |         remotes.expects(:create).with('origin', create_remote).returns(remote)
134 |         remote.expects(:url).returns('url')
135 |         remote.expects(:push).with(['refs/heads/master'], credentials: credentials).returns(true)
136 |       end
137 | 
138 |       describe 'and there are several repositories' do
139 |         let(:create_remote) { 'ggrroouupp#remote_repo' }
140 |         let(:repository) { '/ggrroouupp.git' }
141 | 
142 |         before do
143 |           Oxidized.config.output.git.repo.ggrroouupp = repository
144 |           Oxidized.config.hooks.github_repo_hook.remote_repo.ggrroouupp = 'ggrroouupp#remote_repo'
145 |         end
146 | 
147 |         it 'will push to the node group repository' do
148 |           gr.cfg = Oxidized.config.hooks.github_repo_hook
149 |           gr.run_hook(ctx).must_equal true
150 |         end
151 |       end
152 | 
153 |       describe 'and has a single repository' do
154 |         let(:create_remote) { 'github_repo_hook#remote_repo' }
155 |         let(:repository) { '/foo.git' }
156 | 
157 |         before do
158 |           Oxidized.config.output.git.repo = repository
159 |           Oxidized.config.hooks.github_repo_hook.remote_repo = 'github_repo_hook#remote_repo'
160 |           Oxidized.config.output.git.single_repo = true
161 |         end
162 | 
163 |         it 'will push to the correct repository' do
164 |           gr.cfg = Oxidized.config.hooks.github_repo_hook
165 |           gr.run_hook(ctx).must_equal true
166 |         end
167 |       end
168 |     end
169 |   end
170 | end
171 | 


--------------------------------------------------------------------------------
/lib/oxidized/node.rb:
--------------------------------------------------------------------------------
  1 | module Oxidized
  2 |   require 'resolv'
  3 |   require 'ostruct'
  4 |   require_relative 'node/stats'
  5 |   class MethodNotFound < OxidizedError; end
  6 |   class ModelNotFound  < OxidizedError; end
  7 |   class Node
  8 |     attr_reader :name, :ip, :model, :input, :output, :group, :auth, :prompt, :vars, :last, :repo
  9 |     attr_accessor :running, :user, :msg, :from, :stats, :retry
 10 |     alias :running? :running
 11 |     def initialize opt
 12 |       Oxidized.logger.debug 'resolving DNS for %s...' % opt[:name]
 13 |       # remove the prefix if an IP Address is provided with one as IPAddr converts it to a network address.
 14 |       ip_addr, _ = opt[:ip].to_s.split("/")
 15 |       Oxidized.logger.debug 'IPADDR %s' % ip_addr.to_s
 16 |       @name           = opt[:name]
 17 |       @ip             = IPAddr.new(ip_addr).to_s rescue nil
 18 |       @ip           ||= Resolv.new.getaddress @name
 19 |       @group          = opt[:group]
 20 |       @input          = resolve_input opt
 21 |       @output         = resolve_output opt
 22 |       @model          = resolve_model opt
 23 |       @auth           = resolve_auth opt
 24 |       @prompt         = resolve_prompt opt
 25 |       @vars           = opt[:vars]
 26 |       @stats          = Stats.new
 27 |       @retry          = 0
 28 |       @repo           = resolve_repo opt
 29 | 
 30 |       # model instance needs to access node instance
 31 |       @model.node = self
 32 |     end
 33 | 
 34 |     def run
 35 |       status, config = :fail, nil
 36 |       @input.each do |input|
 37 |         # don't try input if model is missing config block, we may need strong config to class_name map
 38 |         cfg_name = input.to_s.split('::').last.downcase
 39 |         next unless @model.cfg[cfg_name] and not @model.cfg[cfg_name].empty?
 40 |         @model.input = input = input.new
 41 |         if config=run_input(input)
 42 |           Oxidized.logger.debug "lib/oxidized/node.rb: #{input.class.name} ran for #{name} successfully"
 43 |           status = :success
 44 |           break
 45 |         else
 46 |           Oxidized.logger.debug "lib/oxidized/node.rb: #{input.class.name} failed for #{name}"
 47 |           status = :no_connection
 48 |         end
 49 |       end
 50 |       @model.input = nil
 51 |       [status, config]
 52 |     end
 53 | 
 54 |     def run_input input
 55 |       rescue_fail = {}
 56 |       [input.class::RescueFail, input.class.superclass::RescueFail].each do |hash|
 57 |         hash.each do |level,errors|
 58 |           errors.each do |err|
 59 |             rescue_fail[err] = level
 60 |           end
 61 |         end
 62 |       end
 63 |       begin
 64 |         input.connect(self) and input.get
 65 |       rescue *rescue_fail.keys => err
 66 |         resc  = ''
 67 |         if not level = rescue_fail[err.class]
 68 |           resc  = err.class.ancestors.find{|e|rescue_fail.keys.include? e}
 69 |           level = rescue_fail[resc]
 70 |           resc  = " (rescued #{resc})"
 71 |         end
 72 |         Oxidized.logger.send(level, '%s raised %s%s with msg "%s"' % [self.ip, err.class, resc, err.message])
 73 |         return false
 74 |       rescue => err
 75 |         file = Oxidized::Config::Crash + '.' + self.ip.to_s
 76 |         open file, 'w' do |fh|
 77 |           fh.puts Time.now.utc
 78 |           fh.puts err.message + ' [' + err.class.to_s + ']'
 79 |           fh.puts '-' * 50
 80 |           fh.puts err.backtrace
 81 |         end
 82 |         Oxidized.logger.error '%s raised %s with msg "%s", %s saved' % [self.ip, err.class, err.message, file]
 83 |         return false
 84 |       end
 85 |     end
 86 | 
 87 |     def serialize
 88 |       h = {
 89 |         :name      => @name,
 90 |         :full_name => @name,
 91 |         :ip        => @ip,
 92 |         :group     => @group,
 93 |         :model     => @model.class.to_s,
 94 |         :last      => nil,
 95 |         :vars      => @vars,
 96 |       }
 97 |       h[:full_name] = [@group, @name].join('/') if @group
 98 |       if @last
 99 |         h[:last] = {
100 |           :start  => @last.start,
101 |           :end    => @last.end,
102 |           :status => @last.status,
103 |           :time   => @last.time,
104 |         }
105 |       end
106 |       h
107 |     end
108 | 
109 |     def last= job
110 |       if job
111 |         ostruct = OpenStruct.new
112 |         ostruct.start  = job.start
113 |         ostruct.end    = job.end
114 |         ostruct.status = job.status
115 |         ostruct.time   = job.time
116 |         @last = ostruct
117 |       else
118 |         @last = nil
119 |       end
120 |     end
121 | 
122 |     def reset
123 |       @user = @msg = @from = nil
124 |       @retry = 0
125 |     end
126 | 
127 |     private
128 | 
129 |     def resolve_prompt opt
130 |       opt[:prompt] || @model.prompt || Oxidized.config.prompt
131 |     end
132 | 
133 |     def resolve_auth opt
134 |       # Resolve configured username/password
135 |       {
136 |         username:       resolve_key(:username, opt),
137 |         password:       resolve_key(:password, opt),
138 |       }
139 |     end
140 | 
141 |     def resolve_input opt
142 |       inputs = resolve_key :input, opt, Oxidized.config.input.default
143 |       inputs.split(/\s*,\s*/).map do |input|
144 |         if not Oxidized.mgr.input[input]
145 |           Oxidized.mgr.add_input input or raise MethodNotFound, "#{input} not found for node #{ip}"
146 |         end
147 |         Oxidized.mgr.input[input]
148 |       end
149 |     end
150 | 
151 |     def resolve_output opt
152 |       output = resolve_key :output, opt, Oxidized.config.output.default
153 |       if not Oxidized.mgr.output[output]
154 |         Oxidized.mgr.add_output output or raise MethodNotFound, "#{output} not found for node #{ip}"
155 |       end
156 |       Oxidized.mgr.output[output]
157 |     end
158 | 
159 |     def resolve_model opt
160 |       model = resolve_key :model, opt
161 |       if not Oxidized.mgr.model[model]
162 |         Oxidized.logger.debug "lib/oxidized/node.rb: Loading model #{model.inspect}"
163 |         Oxidized.mgr.add_model model or raise ModelNotFound, "#{model} not found for node #{ip}"
164 |       end
165 |       Oxidized.mgr.model[model].new
166 |     end
167 | 
168 |     def resolve_repo opt
169 |       return unless is_git? opt
170 | 
171 |       remote_repo = Oxidized.config.output.git.repo
172 | 
173 |       if remote_repo.is_a?(::String)
174 |         if Oxidized.config.output.git.single_repo? || @group.nil?
175 |           remote_repo
176 |         else
177 |           File.join(File.dirname(remote_repo), @group + '.git')
178 |         end
179 |       else
180 |         remote_repo[@group]
181 |       end
182 |     end
183 | 
184 |     def resolve_key key, opt, global=nil
185 |       # resolve key, first get global, then get group then get node config
186 |       key_sym = key.to_sym
187 |       key_str = key.to_s
188 |       value   = global
189 |       Oxidized.logger.debug "node.rb: resolving node key '#{key}', with passed global value of '#{value}' and node value '#{opt[key_sym]}'"
190 | 
191 |       #global
192 |       if not value and Oxidized.config.has_key?(key_str)
193 |         value = Oxidized.config[key_str]
194 |         Oxidized.logger.debug "node.rb: setting node key '#{key}' to value '#{value}' from global"
195 |       end
196 | 
197 |       #group
198 |       if Oxidized.config.groups.has_key?(@group)
199 |         if Oxidized.config.groups[@group].has_key?(key_str)
200 |           value = Oxidized.config.groups[@group][key_str]
201 |           Oxidized.logger.debug "node.rb: setting node key '#{key}' to value '#{value}' from group"
202 |         end
203 |       end
204 | 
205 |       #node
206 |       value = opt[key_sym] || value
207 |       Oxidized.logger.debug "node.rb: returning node key '#{key}' with value '#{value}'"
208 |       value
209 |     end
210 | 
211 |     def is_git? opt
212 |       (opt[:output] || Oxidized.config.output.default) == 'git'
213 |     end
214 | 
215 |   end
216 | end
217 | 


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
  1 | # 0.19.0
  2 | - FEATURE: allow setting ssh_keys (not relying on openssh config) (@denvera)
  3 | - FEATURE: fujitsupy model (@stokbaek)
  4 | - FEATURE: fiberdriver model (@emjemj)
  5 | - FEATURE: hpbladesystems model (@flokli)
  6 | - FEATURE: planetsgs model (@flokli)
  7 | - FEATURE: trango model (@rfdrake)
  8 | - FEATURE: casa model (@rfdrake)
  9 | - FEATURE: dlink model (@rfdrake)
 10 | - FEATURE: hatteras model (@rfdrake)
 11 | - FEATURE: ability to ignore SSL certs in http (@laf)
 12 | - FEATURE: awsns hooks, publish messages to AWS SNS topics (@natm)
 13 | - BUGFIX: pfsense, dnos, powerconnect, ciscosmb, eos, aosw
 14 | 
 15 | # 0.18.0
 16 | - FEATURE: APC model (by @davromaniak )
 17 | - BUGFIX: ironware, aosw
 18 | - BUGFIX: interpolate nil, false, true for node vars too
 19 | 
 20 | # 0 17.0
 21 | - FEATURE: "nil", "false" and "true" in source (e.g. router.db) are interpeted as nil, false, true. Empty is now always considered empty string, instead of in some cases nil and some cases empty string.
 22 | - FEATURE: support tftp as input model (@MajesticFalcon)
 23 | - FEATURE: add alvarion model (@MajesticFalcon)
 24 | - FEATURE: detect if ssh wants password terminal/CLI prompt or not
 25 | - FEATURE: node (group, model, username, password) resolution refactoring, supports wider range of use-cases
 26 | - BUGFIX: fetch for file output (@danilopopeye)
 27 | - BUGFIX: net-ssh version specification
 28 | - BUGFIX: routeros, catos, pfsense
 29 | 
 30 | # 0.16.3
 31 | - FEATURE: pfsense support (by @stokbaek)
 32 | - BUGFIX: cumulus prompt not working with default switch configs (by @nertwork)
 33 | - BUGFIX: disconnect ssh when prompt wasn't found (by @andir)
 34 | - BUGFIX: saos, asa, acos, timos updates, cumulus
 35 | 
 36 | # 0.16.2
 37 | - BUGFIX: when not using git (by @danilopopeye)
 38 | - BUGFIX: screenos update
 39 | 
 40 | # 0.16.1
 41 | - BUGFIX: unnecessary puts statement removed from git.rb
 42 | 
 43 | # 0.16.0
 44 | - FEATURE: support Gaia OS devices (by @totosh)
 45 | - BUGFIX: #fetch, #version fixes in nodes.rb (by @danilopopeye)
 46 | - BUGFIX: procurve
 47 | 
 48 | # 0.15.0
 49 | - FEATURE: disable periodic collection, only on demand (by Adam Winberg)
 50 | - FEATURE: allow disabling ssh exec mode always (mainly for oxidized-script) (by @nickhilliard)
 51 | - FEATURE: support mellanox devices (by @ham5ter)
 52 | - FEATURE: support firewireos devices (by @alexandre-io)
 53 | - FEATURE: support quanta devices (by @f0o)
 54 | - FEATURE: support tellabs coriant8800, coriant8600 (by @udhos)
 55 | - FEATURE: support brocade6910 (by @cardboardpig)
 56 | - BUGFIX: debugging, tests (by @ElvinEfendi)
 57 | - BUGFIX: nos, panos, acos, procurve, eos, edgeswitch, aosw, fortios updates
 58 | 
 59 | # 0.14.3
 60 | - BUGFIX: fix git when using multiple groups without single_repo
 61 | 
 62 | # 0.14.2
 63 | - BUGFIX: git expand path for all groups
 64 | - BUGFIX: git get_version, teletubbies do it again
 65 | - BUGFIX: comware, acos, procurve models
 66 | 
 67 | # 0.14.1
 68 | - BUGFIX: git get_version when groups and single_repo are used
 69 | 
 70 | # 0.14.0
 71 | - FEATURE: support supermicro swithes (by @funzoneq)
 72 | - FEATURE: support catos switches
 73 | - BUGFIX: git+groups+singlerepo (by @PANZERBARON)
 74 | - BUGFIX: asa, tmos, ironware, ios-xr
 75 | - BUGFIX: mandate net-ssh 3.0.x, don't accept 3.1 (numerous issues)
 76 | 
 77 | # 0.13.1
 78 | - BUGFIX: file permissions (Sigh...)
 79 | 
 80 | # 0.13.0
 81 | - FEATURE: http post for configs (by @jgroom33)
 82 | - FEATURE: support ericsson redbacks (by @roedie)
 83 | - FEATURE: support motorola wireless controllers (by @roadie)
 84 | - FEATURE: support citrix netscaler (by @roadie)
 85 | - FEATURE: support datacom devices (by @danilopopeye)
 86 | - FEATURE: support netonix devices
 87 | - FEATURE: support specifying ssh cipher and kex (by @roadie)
 88 | - FEATURE: rename proxy to ssh_proxy (by @roadie)
 89 | - FEATURE: support ssh keys on ssh_proxy (by @awix)
 90 | - BUGFIX: various (by @danilopopeye)
 91 | - BUGFIX: Node#repo with groups (by @danilopopeye)
 92 | - BUGFIX: githubrepohoook (by @danilopopeye)
 93 | - BUGFIX: fortios, airos, junos, xos, edgeswitch, nos, tmos, procurve, ipos models
 94 | 
 95 | # 0.12.2
 96 | - BUGFIX: more MRV model fixes (by @natm)
 97 | 
 98 | # 0.12.1
 99 | - BUGFIX: set term to vty100
100 | - BUGFIX: MRV model fixes (by @natm)
101 | 
102 | # 0.12.0
103 | - FEATURE: enhance AOSW (by @mikebryant)
104 | - FEATURE: F5 TMOS support (by @mikebryant)
105 | - FEATURE: Opengear support (by @mikebryant)
106 | - FEATURE: EdgeSwitch support (by @doogieconsulting)
107 | - BUGFIX: rename input debug log files
108 | - BUGFIX: powerconnect model fixes (by @Madpilot0)
109 | - BUGFIX: fortigate model fixes (by @ElvinEfendi)
110 | - BUGFIX: various (by @mikebryant)
111 | - BUGFIX: write SSH debug to file without buffering
112 | - BUGFIX: fix IOS XR prompt handling
113 | 
114 | # 0.11.0
115 | - FEATURE: ssh proxycommand (by @ElvinEfendi)
116 | - FEATURE: basic auth in HTTP source (by @laf)
117 | - BUGFIX: do not inject string to output before model gets it
118 | - BUGFIX: store pidfile in oxidized root
119 | 
120 | # 0.10.0
121 | - FEATURE: Various refactoring (by @ElvinEfendi)
122 | - FEATURE: Ciena SOAS support (by @jgroom33)
123 | - FEATURE: support group variables (by @supertylerc)
124 | - BUGFIX: various ((orly))  (by @marnovdm, @danbaugher, @MrRJ45, @asynet, @nickhilliard)
125 | 
126 | # 0.9.0
127 | - FEATURE: input log now uses devices name as file, instead of string from config (by @skoef)
128 | - FEATURE: Dell Networkign OS (dnos) support (by @erefre)
129 | - BUGFIX: CiscoSMB, powerconnect, comware, xos, ironware, nos fixes
130 | 
131 | # 0.8.1
132 | - BUGFIX: restore ruby 1.9.3 compatibility
133 | 
134 | # 0.8.0
135 | - FEATURE: hooks (by @aakso)
136 | - FEATURE: MRV MasterOS support (by @kwibbly)
137 | - FEATURE: EdgeOS support (by @laf)
138 | - FEATURE: FTP input and Zyxel ZynOS support (by @ytti)
139 | - FEATURE: version and diffs API For oxidized-web (by @FlorianDoublet)
140 | - BUGFIX: aosw, ironware, routeros, xos models
141 | - BUGFIX: crash with 0 nodes
142 | - BUGFIX: ssh auth fail without keyboard-interactive
143 | - Full changelog https://github.com/ytti/oxidized/compare/0.7.1...HEAD
144 | 
145 | # 0.7.0
146 | - FEATURE: support http source (by @laf)
147 | - FEATURE: support Palo Alto PANOS (by @rixxxx)
148 | - BUGFIX:  screenos fixes (by @rixxxx)
149 | - BUGFIX:  allow 'none' auth in ssh (spotted by @SaldoorMike, needed by ciscosmb+aireos)
150 | 
151 | # 0.6.0
152 | - FEATURE: support cumulus linux (by @FlorianDoublet)
153 | - FEATURE: support HP Comware SMB siwtches (by @sid3windr)
154 | - FEATURE: remove secret additions (by @rodecker)
155 | - FEATURE: option to put all groups in single repo (by @ytti)
156 | - FEATURE: expand path in source: csv: (so that ~/foo/bar works) (by @ytti)
157 | - BUGFIX: screenos fixes (by @rixxxx)
158 | - BUGFIX: ironware fixes (by @FlorianDoublet)
159 | - BUGFIX: powerconnect fixes (by @sid3windr)
160 | - BUGFIX: don't ask interactive password in new net/ssh (by @ytti)
161 | 
162 | # 0.5.0
163 | - FEATURE: Mikrotik RouterOS model (by @emjemj)
164 | - FEATURE: add support for Cisco VSS (by @MrRJ45)
165 | - BUGFIX: general fixes to powerconnect model (by @MrRJ45)
166 | - BUGFIX: fix initial commit issues with rugged (by @MrRJ45)
167 | - BUGFIX: pager error for old dell powerconnect switches (by @emjemj)
168 | - BUGFIX: logout error for old dell powerconnect switches (by @emjemj)
169 | 
170 | # 0.4.1
171 | - BUGFIX: handle missing output file (by @brandt)
172 | - BUGFIX: fix passwordless enable on Arista EOS model (by @brandt)
173 | 
174 | # 0.4.0
175 | - FEATURE: allow setting IP address in addition to name in source (SQL/CSV)
176 | - FEATURE: approximate how long it takes to get node from larger view than 1
177 | - FEATURE: unconditionally start new job if too long has passed since previous start
178 | - FEATURE: add enable to Arista EOS model
179 | - FEATURE: add rugged dependency in gemspec
180 | - FEATURE: log prompt detection failures
181 | - BUGFIX: xos while using telnet (by @fhibler)
182 | - BUGFIX: ironware logout on some models (by @fhibler)
183 | - BUGFIX: allow node to be removed while it is being collected
184 | - BUGFIX: if model returns non string value, return empty string
185 | - BUGFIX: better prompt for Arista EOS model (by @rodecker)
186 | - BUGFIX: improved configuration handling for Arista EOS model (by @rodecker)
187 | 
188 | # 0.3.0
189 | - FEATURE: *FIXME* bunch of stuff I did for richih, docs needed
190 | - FEATURE: ComWare model (by erJasp)
191 | - FEATURE: Add comment support for router.db file
192 | - FEATURE: Add input debugging and related configuration options
193 | - BUGFIX: Fix ASA model prompt
194 | - BUGFIX: Fix Aruba model display
195 | - BUGFIX: Fix changing output in PowerConnect model
196 | 
197 | # 0.2.4
198 | - FEATURE: Cisco SMB (Nikola series VxWorks) model by @thetamind
199 | - FEATURE: Extreme Networks XOS model (access by sjm)
200 | - FEATURE: Brocade NOS (Network Operating System) (access by sjm)
201 | - BUGFIX: Match exactly to node[:name] if node[name] is an ip address.
202 | 
203 | # 0.2.3
204 | - BUGFIX: rescue @ssh.close when far end closes disgracefully (ALU ISAM)
205 | - BUGFIX: bugfixes to models
206 | - FEATURE: Alcatel-Lucent ISAM 7302/7330 model added by @jalmargyyk
207 | - FEATURE: Huawei VRP model added by @jalmargyyk
208 | - FEATURE: Ubiquiti AirOS added by @willglyn
209 | - FEATURE: Support 'input' debug in config, ssh/telnet use it to write session log
210 | 
211 | # 0.2.2
212 | - BUGFIX: mark node as failure if unknown error is raised
213 | 
214 | # 0.2.1
215 | - BUGFIX: vars variable resolving for main level vars
216 | 
217 | # 0.2.0
218 | - FEATURE: Force10 model added by @lysiszegerman
219 | - FEATURE: ScreenOS model added by @lysiszegerman
220 | - FEATURE: FabricOS model added by @thakala
221 | - FEATURE: ASA model added by @thakala
222 | - FEATURE: Vyattamodel added by @thakala
223 | - BUGFIX: Oxidized::String convenience methods for models fixed
224 | 
225 | # 0.1.1
226 | - BUGFIX: vars needs to return value of r, not value of evaluation
227 | 


--------------------------------------------------------------------------------