net-ops 0.0.5.pre → 0.0.6.pre

data/lib/net/ops/session.rb

@@ -0,0 +1,308 @@
+module Net; module Ops
+
+  # Provides a DSL for interacting with Cisco switches and routers.
+  class Session
+
+    attr_reader :transport
+    attr_reader :transports
+
+    # Initialize a new session.
+    #
+    # @param [String] host the target host.
+    #
+    # @param [Hash<Symbol, String>] options an Hash containing the transport options.
+    # @option options [String] :timeout The timeout before raising an exception while waiting for output.
+    # @option options [String, Regexp] :prompt A String or a Regexp that match the prompt of the device.
+    #
+    # @param [Logger] logger the logger to use.
+    #
+    # @return [Session] the new session.
+    def initialize(host, options = { timeout: 10, prompt: /.+(#|>|\])/ }, logger = nil)
+      @host    = host
+      @options = options
+      @transports = []
+
+      setup_logger(logger)
+
+      Net::Ops::Transport.constants.each do |c|
+        register_transport(c) if Class === Net::Ops::Transport.const_get(c)
+      end
+    end
+
+    # Open the session to the device.
+    #
+    # @param [Hash<Symbol, String>] credentials an Hash containing the credentials used to login.
+    # @option credentials [String] :username The username.
+    # @option credentials [String] :password The password.
+    #
+    # @return [void]
+    # @raise  [Net::Ops::TransportUnavailable] if the session cannot be opened.
+    def open(credentials)
+      @credentials = credentials
+
+      @logger.debug(@host) { "Opening session as #{ credentials[:username] }" }
+
+      @transports.each do |transport|
+        @transport ||= transport.open(@host, @options, credentials)
+      end
+
+      fail Net::Ops::TransportUnavailable unless @transport
+    end
+
+    # Close the session to the device.
+    #
+    # @return [void]
+    def close
+      @logger.debug(@host) { 'Closing session' }
+      @transport.close
+      @transport = nil
+    end
+
+    # Measure the latency.
+    #
+    # @return [Integer] the time to run and retrieve the output of a command in milliseconds.
+    def latency
+      t1 = Time.now
+      @transport.cmd('')
+      t2 = Time.now
+
+      (t2 - t1) * 1000.0
+    end
+
+    # Send the specified command to the device and wait for the output.
+    #
+    # @param  [String] command the command to run.
+    # @return [String] the output of the command.
+    def run(command)
+      @logger.debug("#{ @host } (#{ get_mode })") { "Executing #{ command }" }
+
+      output = ''
+      @transport.cmd(command) { |c| output += c }
+
+      # @logger.debug("#{ @host } (#{ get_mode })") { output }
+      # @logger.warn(@host) { 'Net::Ops::IOSInvalidInput'; puts output } if /nvalid input detected/.match(output)
+      fail Net::Ops::IOSInvalidInput if /nvalid input detected/.match(output)
+
+      output
+    end
+
+    # Get the specified item on the device.
+    # Equivalent to the Cisco show command.
+    #
+    # @param item [String] the item to get.
+    # @return [String] the item.
+    def get(item)
+      run("show #{ item }")
+    end
+
+    # Set the value for the specified item on the device.
+    #
+    # @param item  [String] the item to configure.
+    # @param value [String] the value to assign to the item.
+    # @return [String] the eventual output of the command.
+    def set(item, value)
+      run("#{ item } #{ value }")
+    end
+
+    # Enable the specified item on the device.
+    #
+    # @param item [String] the item to enable.
+    # @return [String] the eventual output of the command.
+    def enable(item)
+      run(item)
+    end
+
+    # Disable the specified item on the device.
+    # Equivalent to the Cisco no command.
+    #
+    # @param item [String] the item to enable.
+    # @return [String] the eventual output of the command.
+    def disable(item)
+      run("no #{ item }")
+    end
+
+    def zeroize(item)
+      @logger.debug(@host) { "Executing #{ item } zeroize" }
+
+      @transport.cmd('String' => "#{ item } zeroize", 'Match' => /.+/)
+      @transport.cmd('yes')
+    end
+
+    def generate(item, options)
+      run("#{ item } generate #{ options }")
+    end
+
+    # Run the specified command in the privileged mode on the device.
+    #
+    # @param  [String] command the command to run.
+    # @return [String] the output of the command.
+    def exec(command)
+      ensure_mode(:privileged)
+      run(command)
+    end
+
+    # Run the specified command in the configuration mode on the device.
+    #
+    # @param  [String] command the command to run.
+    # @return [String] the output of the command.
+    def config(command)
+      ensure_mode(:configuration)
+      run(command)
+    end
+
+    # Save the configuration of the device.
+    # Equivalent to the Cisco copy running-config startup-config command.
+    # @return [void]
+    def write!
+      ensure_mode(:privileged)
+      exec('write memory')
+    end
+
+    # Run the specified block in the privileged mode on the device.
+    #
+    # @param  [Block] block the block to run.
+    # @return [void]
+    def privileged(&block)
+      ensure_mode(:privileged)
+      instance_eval(&block)
+    end
+
+    # Run the specified block in the configuration mode on the device.
+    #
+    # @param  [Block] block the block to run.
+    # @return [void]
+    def configuration(options = nil, &block)
+      ensure_mode(:configuration)
+      instance_eval(&block)
+
+      write! if options == :enforce_save
+    end
+
+    def interface(interface, &block)
+      ensure_mode(:configuration)
+
+      run("interface #{ interface }")
+      instance_eval(&block)
+    end
+
+    def interfaces(interfaces = /.+/, &block)
+      ints = privileged do
+        get('interfaces status').select do |int|
+          interfaces.match("#{ int['short_type'] }#{ int['port_number'] }")
+        end
+      end
+
+      ints.each do |int|
+        interface("#{ int['short_type'] }#{ int['port_number'] }") do
+          instance_eval(&block)
+        end
+      end
+    end
+
+    def lines(lines, &block)
+      ensure_mode(:configuration)
+
+      run("line #{ lines }")
+      instance_eval(&block)
+    end
+
+    private
+
+    def register_transport(klass)
+      @logger.debug(@host) { "Registering transport #{ klass }" }
+      @transports << Net::Ops::Transport.const_get(klass)
+    end
+
+    # Create a default logger if none is specified.
+    #
+    # @param  [Logger] logger the logger to use.
+    # @return [void]
+    def setup_logger(logger = nil)
+      # If a logger is specified we replace the existing.
+      @logger = logger
+
+      # Otherwise we create a new one.
+      logger = Logger.new(STDOUT)
+      logger.level = Logger::DEBUG
+      @logger ||= logger
+    end
+
+    # Get the current command mode.
+    #
+    # @return [Symbol] the current command mode.
+    def get_mode
+      prompt = ''
+      @transport.cmd('') { |c| prompt += c }
+      match = /(?<hostname>[^\(-\)]+)(\((?<text>[\w\-]+)\))?(?<char>#|>)/.match(prompt)
+
+      mode  = nil
+
+      if match && match['char']
+
+        mode = case match['char']
+               when '>' then :user
+               when '#' then :privileged
+               end
+
+      end
+
+      if match && match['text']
+        mode = match['text'].to_sym
+      end
+
+      mode
+    end
+
+    # Ensure the CLI is currently in the specified command mode.
+    #
+    # @param  [Symbol] mode the target command mode.
+    # @return [void]
+    def ensure_mode(mode)
+      case mode
+
+      when :user
+        run('end') if configuration?
+
+      when :privileged
+        run('end') if configuration?
+        enable_privileged(@credentials[:password]) if user?
+
+      when :configuration
+        run('configure terminal') unless configuration?
+
+      end
+    end
+
+    # Check if the CLI is in user mode.
+    #
+    # @return [Boolean]
+    def user?
+      get_mode == :user
+    end
+
+    # Check if the CLI is in privileged mode.
+    #
+    # @return [Boolean]
+    def privileged?
+      get_mode == :privileged
+    end
+
+    # Check if the CLI is in configuration mode.
+    #
+    # @return [Boolean]
+    def configuration?
+      get_mode.to_s.include?('config')
+    end
+
+    # Go from user mode to privileged mode.
+    #
+    # @param  [String] the enable password.
+    # @return [void]
+    def enable_privileged(password)
+      @transport.cmd('String' => 'enable', 'Match' => /.+assword.+/)
+      @transport.cmd(password)
+    end
+
+  end
+
+end; end

data/lib/net/ops/task.rb

@@ -0,0 +1,32 @@
+module Net; module Ops
+
+  #
+  class Task
+    include Net::Ops
+
+    def initialize(id)
+      @id = id
+
+      @logger = Logger.new(STDOUT)
+      @logger.level = Logger::INFO
+    end
+
+    def log(severity, message)
+      @logger.add(severity, message, @id)
+    end
+
+    def info(message)
+      log(Logger::INFO, message)
+    end
+
+    def warn(message)
+      log(Logger::WARN, message)
+    end
+
+    def error(message)
+      log(Logger::ERROR, message)
+    end
+
+  end
+
+end; end

data/lib/net/ops/transport/ssh.rb

@@ -0,0 +1,35 @@
+require 'net/ssh/telnet'
+
+module Net; module Ops; module Transport
+
+  #
+  class SSH
+
+    # Open an SSH session to the specified host using net/ssh/telnet.
+    #
+    # @param host [String] the destination host.
+    # @param options [Hash]
+    # @param credentials [Hash] credentials to use to connect.
+    def self.open(host, options, credentials)
+      session = nil
+
+      ssh = Net::SSH.start(host, credentials[:username], :password => credentials[:password])
+      session = Net::SSH::Telnet.new('Session' => ssh,
+                                     'Timeout' => options[:timeout],
+                                     'Prompt'  => options[:prompt])
+
+    rescue Errno::ECONNREFUSED => e
+      session = nil
+
+    rescue Net::SSH::AuthenticationFailed => e
+      session = nil
+
+    rescue Exception => e
+      session = nil
+
+    return session
+    end
+
+  end
+
+end; end; end

data/lib/net/ops/transport/telnet.rb

@@ -0,0 +1,49 @@
+require 'net/telnet'
+
+module Net; module Ops; module Transport
+
+  #
+  class Telnet
+
+    # Open a Telnet session to the specified host using net/ssh.
+    #
+    # @param host [String] the destination host.
+    # @param options [Hash]
+    # @param credentials [Hash] credentials to use to connect.
+    def self.open(host, options, credentials)
+      session = nil
+
+      session = Net::Telsnet.new('Host' => host,
+                                'Timeout' => options[:timeout],
+                                'Prompt'  => options[:prompt])
+
+      output = ''
+      session.cmd('String' => '', 'Match'  => /.+/) { |c| output += c }
+
+      if /[Uu]sername:/.match(output) then
+        session.cmd('String' => credentials[:username],
+                  'Match'  => /.+/)
+        session.cmd(credentials[:password])
+      end
+
+      if /[Pp]assword:/.match(output) then
+        session.cmd(credentials[:password])
+      end
+
+      return session
+
+    rescue Errno::ECONNREFUSED => e
+      session = nil
+
+    rescue Net::OpenTimeout => e
+      session = nil
+
+    rescue Exception => e
+      session = nil
+
+    return session
+    end
+
+  end
+
+end; end; end

data/lib/net/ops/version.rb

@@ -0,0 +1,5 @@
+module Net
+  module Ops
+    VERSION = '0.0.6.pre'
+  end
+end

data/net-ops.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'net/ops/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'net-ops'
+  spec.version       = Net::Ops::VERSION
+  spec.authors       = ['Maxime Mouchet']
+  spec.email         = ['mouchet.max@gmail.com']
+  spec.description   = %q{Framework to automate daily operations on network devices.}
+  spec.summary       = %q{Net::Ops}
+  spec.homepage      = 'http://github.com/maxmouchet/qscripts'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'thread', '~> 0.1'
+  spec.add_runtime_dependency 'net-ssh-telnet', '~> 0.0.2'
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+end