net-snmp2 0.3.0 → 0.3.1

data/lib/net/snmp/trap_handler/trap_handler.rb

@@ -3,13 +3,9 @@ module Net::SNMP
     include Net::SNMP::Debug
     extend Forwardable
 
-    attr_accessor :listener, :v1_handler, :v2_handler, :message, :pdu
+    attr_accessor :listener, :v1_handler, :v2_handler, :inform_handler, :message, :pdu
     def_delegators :listener, :start, :run, :listen, :stop, :kill
 
-    def self.listen(port = 162, interval = 2, max_packet_size = 65_000, &block)
-      self.new
-    end
-
     def initialize(&block)
       @listener = Net::SNMP::Listener.new
       @listener.on_message(&method(:process_trap))
@@ -18,15 +14,19 @@ module Net::SNMP
 
     private
 
-    def process_trap(message, from_address, from_port)
-      if message.pdu.command == Net::SNMP::Constants::SNMP_MSG_TRAP
+    def process_trap(message)
+      case message.pdu.command
+      when Constants::SNMP_MSG_TRAP
         handler = V1TrapDsl.new(message)
         handler.instance_eval(&v1_handler)
-      elsif message.pdu.command == Net::SNMP::Constants::SNMP_MSG_TRAP2
+      when Constants::SNMP_MSG_TRAP2
         handler = V2TrapDsl.new(message)
         handler.instance_eval(&v2_handler)
+      when Constants::SNMP_MSG_INFORM
+        handler = V2InformDsl.new(message)
+        handler.instance_eval(&inform_handler)
       else
-        warn "Trap handler receive invalid command: #{message.pdu.command}"
+        warn "Trap handler received non-trap PDU. Command type was: #{message.pdu.command}"
       end
       message.pdu.free
     end
@@ -38,5 +38,9 @@ module Net::SNMP
     def v2(&handler)
       @v2_handler = handler
     end
+
+    def inform(&handler)
+      @inform_handler = handler
+    end
   end
 end

data/lib/net/snmp/trap_handler/v2_inform_dsl.rb

@@ -0,0 +1,16 @@
+module Net::SNMP
+  class V2InformDsl < V2TrapDsl
+    include Debug
+
+    attr_accessor :response
+
+    def initialize(message)
+      super
+    end
+
+    def ok
+      message.echo
+    end
+
+  end
+end

data/lib/net/snmp/trap_session.rb

@@ -3,9 +3,10 @@ module Net
     class TrapSession < Session
       # == Represents a session for sending SNMP traps
 
-      # +options+
-      # * :peername The address where the trap will be sent
-      # * :port     The port where the trap will be sent (default = 162)
+      # Options
+      #
+      # - peername: The address where the trap will be sent
+      # - port:     The port where the trap will be sent (default = 162)
       def initialize(options = {})
         # Unless the port was supplied in the peername...
         unless options[:peername][":"]
@@ -20,11 +21,62 @@ module Net
       #
       # Options
       #
-      # - enterprise: The Oid of the enterprise
-      # - trap_type:  The generic trap type.
+      # - enterprise:    The Oid of the enterprise
+      # - trap_type:     The generic trap type.
       # - specific_type: The specific trap type
-      # - uptime: The uptime for this agent
+      # - uptime:        The uptime for this agent
       def trap(options = {})
+        pdu = build_v1_trap_pdu(options)
+        send_pdu(pdu)
+      end
+
+      # Send an SNMPv2 trap
+      #
+      # Options
+      #
+      # - oid:    The OID of the inform
+      # - uptime: Integer indicating the uptime of this agent
+      #
+      # TODO: You can only send v1 traps on a v1 session, and same for v2.
+      # So, we could always have the client call `trap` and just do the right
+      # thing based on the session.
+      def trap_v2(options = {})
+        pdu = build_v2_trap_pdu(Constants::SNMP_MSG_TRAP2, options)
+        send_pdu(pdu)
+      end
+
+      # Send an SNMPv2 inform
+      #
+      # Options
+      #
+      # - oid:      The OID of the inform
+      # - uptime:   Integer indicating the uptime of this agent
+      # - varbinds: An array of hashes, like those used for PDU#add_varbind
+      def inform(options = {})
+        pdu = build_v2_trap_pdu(Constants::SNMP_MSG_INFORM, options)
+        response = send_pdu(pdu)
+        if response.kind_of?(PDU)
+          response.free # Always free the response PDU
+          :success # If Session#send_pdu didn't raise, we succeeded
+        else
+          # If the result was other than a PDU, that's a problem
+          raise "Unexpected response type for inform: #{response.class}"
+        end
+      end
+
+      private
+
+      def send_pdu(pdu)
+        result = super(pdu)
+        if pdu.command == Constants::SNMP_MSG_INFORM
+          pdu.free_own_memory
+        else
+          pdu.free
+        end
+        result
+      end
+
+      def build_v1_trap_pdu(options = {})
         pdu = PDU.new(Constants::SNMP_MSG_TRAP)
         options[:enterprise] ||= '1.3.6.1.4.1.3.1.1'
         pdu.enterprise = OID.new(options[:enterprise].to_s)
@@ -37,48 +89,16 @@ module Net
             pdu.add_varbind(vb)
           end
         end
-        result = send_pdu(pdu)
-        pdu.free
-        result
+        pdu
       end
 
-      # Send an SNMPv2 trap
-      # +options
-      # * :oid The Oid of the trap
-      # * :varbinds A list of Varbind objects to send with the trap
-      #
-      # TODO: You can only send v1 traps on a v1 session, and same for v2.
-      # So, we could always have the client call `trap` and just do the right
-      # thing based on the session.
-      def trap_v2(options = {})
+      def build_v2_trap_pdu(pdu_type, options = {})
         if options[:oid].kind_of?(String)
           options[:oid] = Net::SNMP::OID.new(options[:oid])
         end
-        pdu = PDU.new(Constants::SNMP_MSG_TRAP2)
-        build_trap_pdu(pdu, options)
-        result = send_pdu(pdu)
-        pdu.free
-        result
-      end
-
-      # Send an SNMPv2 inform.  Can accept a callback to execute on confirmation of the inform
-      # +options
-      # * :oid The OID of the inform
-      # * :varbinds A list of Varbind objects to send with the inform
-      def inform(options = {}, &callback)
-        if options[:oid].kind_of?(String)
-          options[:oid] = Net::SNMP::OID.new(options[:oid])
-        end
-        pdu = PDU.new(Constants::SNMP_MSG_INFORM)
-        build_trap_pdu(pdu, options)
-        result = send_pdu(pdu, &callback)
-        pdu.free
-        result
-      end
-
-      private
-      def build_trap_pdu(pdu, options = {})
         options[:uptime] ||= 1
+
+        pdu = PDU.new(pdu_type)
         pdu.add_varbind(:oid => OID.new('sysUpTime.0'), :type => Constants::ASN_TIMETICKS, :value => options[:uptime].to_i)
         pdu.add_varbind(:oid => OID.new('snmpTrapOID.0'), :type => Constants::ASN_OBJECT_ID, :value => options[:oid])
         if options[:varbinds]
@@ -86,7 +106,9 @@ module Net
             pdu.add_varbind(vb)
           end
         end
+        pdu
       end
+
     end
   end
 end

data/lib/net/snmp/version.rb

@@ -1,5 +1,5 @@
 module Net
   module SNMP
-    VERSION = "0.3.0"
+    VERSION = "0.3.1"
   end
 end

data/lib/net/snmp/wrapper.rb

@@ -282,7 +282,7 @@ module Wrapper
   attach_function :snmp_oidsubtree_compare, [ :pointer, :uint, :pointer, :uint ], :int
   attach_function :netsnmp_oid_compare_ll, [ :pointer, :uint, :pointer, :uint, :pointer ], :int
   attach_function :netsnmp_oid_equals, [ :pointer, :uint, :pointer, :uint ], :int
-  attach_function :netsnmp_oid_tree_equals, [ :pointer, :uint, :pointer, :uint ], :int
+  attach_function :netsnmp_oid_tree_equals, [ :pointer, :size_t, :pointer, :size_t ], :int
   attach_function :netsnmp_oid_is_subtree, [ :pointer, :uint, :pointer, :uint ], :int
   attach_function :netsnmp_oid_find_prefix, [ :pointer, :uint, :pointer, :uint ], :int
   attach_function :netsnmp_transport_open_client, [:string, :pointer], :pointer
@@ -290,7 +290,7 @@ module Wrapper
   attach_function :snmp_pdu_build, [ :pointer, :pointer, :pointer ], :pointer
   attach_function :snmpv3_parse, [ :pointer, :pointer, :pointer, :pointer, :pointer ], :int
   attach_function :snmpv3_packet_build, [ :pointer, :pointer, :pointer, :pointer, :pointer, :uint ], :int
-  attach_function :snmpv3_packet_rbuild, [ :pointer, :pointer, :pointer, :pointer, :pointer, :uint ], :int
+  attach_function :snmpv3_packet_rbuild, [ :pointer, :pointer, :pointer, :pointer, :pointer, :size_t ], :int
   attach_function :snmpv3_make_report, [ :pointer, :int ], :int
   attach_function :snmpv3_get_report_type, [ :pointer ], :int
   attach_function :snmp_pdu_parse, [ :pointer, :pointer, :pointer ], :int
@@ -306,7 +306,6 @@ module Wrapper
   attach_function :snmp_get_statistic, [ :int ], :u_int
   attach_function :snmp_init_statistics, [  ], :void
   attach_function :create_user_from_session, [ :pointer ], :int
-  attach_function :snmp_get_fd_for_session, [ :pointer ], :int
   attach_function :snmp_open_ex, [ :pointer, callback([ :pointer, :pointer, :pointer, :int ], :int), callback([ :pointer, :pointer, :pointer, :uint ], :int), callback([ :pointer, :pointer, :int ], :int), callback([ :pointer, :pointer, :pointer, :pointer ], :int), callback([ :pointer, :pointer, :pointer, :pointer, :pointer ], :int), callback([ :pointer, :uint ], :int) ], :pointer
   attach_function :snmp_set_do_debugging, [ :int ], :void
   attach_function :snmp_get_do_debugging, [  ], :int
@@ -389,11 +388,6 @@ module Wrapper
   # struct module  *find_module(int modid);
   attach_function :find_module, [:int], Module.typed_pointer
 
-  # Trap functions
-  attach_function :send_easy_trap, [:int, :int], :void
-  attach_function :send_trap_vars, [:int, :int, :pointer], :void
-  attach_function :send_v2trap, [:pointer], :void
-
   def self.get_fd_set
     FFI::MemoryPointer.new(:pointer, 128)
   end

data/net-snmp2.gemspec

@@ -21,7 +21,7 @@ Gem::Specification.new do |s|
   # Documentation options
   s.has_rdoc = true
   s.extra_rdoc_files = %w{ README.md }
-  s.rdoc_options = ["--main=README.md", "--line-numbers", "--inline-source", "--title=#{s.name}-#{s.version} Documentation"]
+  s.rdoc_options = ["--main=README.md", "--markup=markdown", "--line-numbers", "--inline-source", "--title=#{s.name}-#{s.version} Documentation"]
 
   s.add_dependency 'nice-ffi'
   s.add_dependency 'pry'

data/spec/README.md

@@ -1,10 +1,9 @@
 Notes
 -----
 
-- To test sets, you have to have a local snmpd running with write permissions
-- For your local agent, use read community "public" & write community "private"
-- A free simulator can be downloaded from [veraxsystems](http://www.veraxsystems.com/en/products/free-snmp-agent-simulator)
-  + TODO: This simulator could be used to replace the dependency on test.net-snmp.org
+- For the tests to run, you must first run `ruby spec/test_agent.r`
+- You also need to run an external trap receiver
+  + I'm currently using MIBBrowser's builtin receiver
 
 Latest Results
 --------------
@@ -14,16 +13,14 @@ Generated with `rspec -f d -o spec/spec.txt --no-color`
 ```
 async
   version 1
-    get should work
-    get should return an error
     getnext should work
+    get
+      retrieves scalar values
+      when a timeout occurrs
+        calls back with :timeout when a timeout occurrs
   version 2
     get should work
     getnext should work
-  version 3
-    should get async using snmpv3
-    get should work
-    getnext should work
 
 em
   should work in event_machine
@@ -35,16 +32,28 @@ snmp errors
 in fiber
   get should work in a fiber with synchronous calling style
   getnext
-  should get using snmpv3
+  should get using snmpv3 (PENDING: No reason given)
+
+Net::SNMP::MIB
+  ::translate
+    translates OIDs to variable names including instance indexes
+    translates variable names to OIDs including instance indexes
+  ::[]
+    can retrieve MIB nodes by variable name
+    can retrieve MIB nodes by numeric oid
 
 Net::SNMP::MIB::Node
-  should get info for sysDescr
-  should get parent
-  should get node children
-  should get siblings
-  should get oid
-  should get by oid
-  should do stuff
+  ::get_node
+    retrieves MIB nodes by variable name
+    retrieves MIB nodes by numeric oid
+  #parent
+    links to the parent node
+  #children
+    contains Node objects for all child nodes
+  #siblings
+    contains an array of sibling nodes
+  #oid
+    is an OID object for the node
 
 Net::SNMP::OID
   should instantiate valid oid with numeric
@@ -60,24 +69,20 @@ synchronous calls
     getnext should succeed
     getbulk should succeed
     getbulk should succeed with multiple oids
-    get should return error with invalid oid
+    rasises an when a non-existant MIB variable is requested
     get_table should work
     walk should work
     walk should work with multiple oids
     get_columns should work
     get a value with oid type should work
-  version 3
-    should get using snmpv3
-    should set using snmpv3 (PENDING: No reason given)
-    should get using authpriv (PENDING: No reason given)
 
 in a thread
   should get an oid asynchronously in a thread
 
-snmp traps
+Net::SNMP::TrapSession
   should send a v1 trap
-  should send a v2 inform (PENDING: still working on it)
-  should send v2 trap (PENDING: still working on it)
+  should send v2 trap
+  should send a v2 inform
 
 Net::SNMP::Utility
   should compare oids
@@ -87,19 +92,10 @@ Net::SNMP::Wrapper
   wrapper should snmpget asynchronously
 
 Pending:
-  synchronous calls version 3 should set using snmpv3
-    # No reason given
-    # ./spec/sync_spec.rb:117
-  synchronous calls version 3 should get using authpriv
+  in fiber should get using snmpv3
     # No reason given
-    # ./spec/sync_spec.rb:125
-  snmp traps should send a v2 inform
-    # still working on it
-    # ./spec/trap_spec.rb:14
-  snmp traps should send v2 trap
-    # still working on it
-    # ./spec/trap_spec.rb:26
-
-Finished in 25.41 seconds (files took 0.38735 seconds to load)
-47 examples, 0 failures, 4 pending
+    # ./spec/fiber_spec.rb:32
+
+Finished in 29.01 seconds (files took 0.34884 seconds to load)
+44 examples, 0 failures, 1 pending
 ```

data/spec/async_spec.rb

@@ -1,123 +1,128 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require_relative './spec_helper'
 
 describe "async" do
   context "version 1" do
-    it "get should work" do
-      did_callback = false
-      sess = Net::SNMP::Session.open(:peername => 'test.net-snmp.org', :community => 'demopublic') do |s|
-        s.get(["sysDescr.0", "sysContact.0"]) do |op, pdu|
-          did_callback = true
-          pdu.varbinds[0].value.should eql("test.net-snmp.org")
-          pdu.varbinds[1].value.should match(/Coders/)
+
+    describe 'get' do
+      it "retrieves scalar values" do
+        did_callback = false
+        sess = Net::SNMP::Session.open(:peername => 'localhost', port: 161, :community => 'public', version: '2c') do |s|
+          s.get(["sysDescr.0", "sysContact.0"]) do |op, pdu|
+            did_callback = true
+            expect(pdu.varbinds[0].value).to eq($test_mib['sysDescr.0'])
+            expect(pdu.varbinds[1].value).to eq($test_mib['sysContact.0'])
+          end
         end
+        Net::SNMP::Dispatcher.select(false)
+        expect(did_callback).to be(true)
       end
-      Net::SNMP::Dispatcher.select(false)
-      did_callback.should be(true)
-    end
 
-    it "get should return an error" do
-      did_callback = false
-      sess = Net::SNMP::Session.open(:peername => 'www.yahoo.com', :timeout => 1, :retries => 0) do |sess|
-        sess.get("sysDescr.0") do |op, pdu|
-          did_callback = true
-          op.should eql(:timeout)
+      context "when a timeout occurrs" do
+        it "calls back with :timeout when a timeout occurrs" do
+          did_callback = false
+          sess = Net::SNMP::Session.open(:peername => 'www.yahoo.com', :timeout => 1, :retries => 0) do |sess|
+            sess.get("sysDescr.0") do |op, pdu|
+              did_callback = true
+              expect(op).to eql(:timeout)
+            end
+          end
+          sleep 2
+          num_ready = sess.select(10)
+          expect(num_ready).to eql(0)
+          expect(did_callback).to eq(true)
         end
       end
-      sleep 2
-      pdu = sess.select(10)
-
-      pdu.should eql(0)
-      did_callback.should eq(true)
     end
 
-    it "getnext should work" do
-      did_callback = false
-      Net::SNMP::Session.open(:peername => 'test.net-snmp.org', :community => 'demopublic') do |s|
-        s.get_next(["sysDescr", "sysContact"]) do |op, pdu|
-          did_callback = true
-          pdu.varbinds[0].value.should eql("test.net-snmp.org")
-          pdu.varbinds[1].value.should match(/Coders/)
+    describe 'get_next'
+      it "getnext should work" do
+        did_callback = false
+        Net::SNMP::Session.open(:peername => 'localhost', :community => 'public', version: '2c') do |s|
+          s.get_next(["sysDescr", "sysContact"]) do |op, pdu|
+            did_callback = true
+            expect(pdu.varbinds[0].value).to eq $test_mib['sysDescr.0']
+            expect(pdu.varbinds[1].value).to eq $test_mib['sysContact.0']
+          end
         end
+        Net::SNMP::Dispatcher.select(false)
+        expect(did_callback).to be(true)
       end
-      Net::SNMP::Dispatcher.select(false)
-      did_callback.should be(true)
     end
-  end
 
   context "version 2" do
     it "get should work" do
       did_callback = false
-      Net::SNMP::Session.open(:peername => 'test.net-snmp.org', :community => 'demopublic', :version => '2c') do |s|
+      Net::SNMP::Session.open(:peername => 'localhost', :community => 'public', :version => '2c') do |s|
         s.get(["sysDescr.0", "sysContact.0"]) do |op, pdu|
           did_callback = true
-          pdu.varbinds[0].value.should eql("test.net-snmp.org")
-          pdu.varbinds[1].value.should match(/Coders/)
+          expect(pdu.varbinds[0].value).to eq $test_mib['sysDescr.0']
+          expect(pdu.varbinds[1].value).to eq $test_mib['sysContact.0']
         end
       end
       Net::SNMP::Dispatcher.select(false)
-      did_callback.should be(true)
+      expect(did_callback).to be(true)
     end
 
     it "getnext should work" do
       did_callback = false
-      Net::SNMP::Session.open(:peername => 'test.net-snmp.org', :community => 'demopublic', :version => '2c') do |s|
+      Net::SNMP::Session.open(:peername => 'localhost', :community => 'public', :version => '2c') do |s|
         s.get_next(["sysDescr", "sysContact"]) do |op, pdu|
           did_callback = true
-          pdu.varbinds[0].value.should eql("test.net-snmp.org")
-          pdu.varbinds[1].value.should match(/Coders/)
+          expect(pdu.varbinds[0].value).to eq $test_mib['sysDescr.0']
+          expect(pdu.varbinds[1].value).to eq $test_mib['sysContact.0']
         end
       end
       Net::SNMP::Dispatcher.select(false)
-      did_callback.should be(true)
+      expect(did_callback).to be(true)
     end
 
   end
 
-  context "version 3" do
-    #failing intermittently
-    it "should get async using snmpv3" do
-      did_callback = false
-      Net::SNMP::Session.open(:peername => 'test.net-snmp.org', :version => 3, :username => 'MD5User',:security_level => Net::SNMP::Constants::SNMP_SEC_LEVEL_AUTHNOPRIV, :auth_protocol => :md5, :password => 'The Net-SNMP Demo Password') do |sess|
-          sess.get(["sysDescr.0"]) do |op, pdu|
-            did_callback = true
-            pdu.varbinds[0].value.should eql('test.net-snmp.org')
-          end
-          sleep(0.5)
-          Net::SNMP::Dispatcher.select(false)
-          #Net::SNMP::Dispatcher.select(false)
-          #puts "done select"
-          did_callback.should be(true)
-      end
-    end
-
-    it "get should work" do
-      did_callback = false
-      sess = Net::SNMP::Session.open(:peername => 'test.net-snmp.org', :version => 3, :username => 'MD5User',:security_level => Net::SNMP::Constants::SNMP_SEC_LEVEL_AUTHNOPRIV, :auth_protocol => :md5, :password => 'The Net-SNMP Demo Password') do |sess|
-        sess.get(["sysDescr.0", "sysContact.0"]) do |op,pdu|
-          did_callback = true
-          pdu.varbinds[0].value.should eql("test.net-snmp.org")
-          pdu.varbinds[1].value.should match(/Coders/)
-        end
-      end
-      Net::SNMP::Dispatcher.select(false)
-      sess.close
-      did_callback.should be(true)
-    end
-
-    #  XXX  occasionally segfaulting
-    it "getnext should work" do
-      did_callback = false
-
-      sess = Net::SNMP::Session.open(:peername => 'test.net-snmp.org', :version => 3, :username => 'MD5User',:security_level => Net::SNMP::Constants::SNMP_SEC_LEVEL_AUTHNOPRIV, :auth_protocol => :md5, :password => 'The Net-SNMP Demo Password') do |sess|
-        sess.get_next(["sysDescr", "sysContact"]) do |op, pdu|
-          did_callback = true
-          pdu.varbinds[0].value.should eql("test.net-snmp.org")
-          pdu.varbinds[1].value.should match(/Coders/)
-        end
-      end
-      Net::SNMP::Dispatcher.select(false)
-      sess.close
-      did_callback.should be(true)
-    end
-  end
+  # context "version 3" do
+  #   #failing intermittently
+  #   it "should get async using snmpv3" do
+  #     did_callback = false
+  #     Net::SNMP::Session.open(:peername => 'localhost', :version => 3, :username => 'MD5User',:security_level => Net::SNMP::Constants::SNMP_SEC_LEVEL_AUTHNOPRIV, :auth_protocol => :md5, :password => 'The Net-SNMP Demo Password') do |sess|
+  #         sess.get(["sysDescr.0"]) do |op, pdu|
+  #           did_callback = true
+  #           expect(pdu.varbinds[0].value).to eql("Linux nmsworker-devel 2.6.18-164.el5 #1 SMP Thu Sep 3 03:28:30 EDT 2009 x86_64")
+  #         end
+  #         sleep(0.5)
+  #         Net::SNMP::Dispatcher.select(false)
+  #         #Net::SNMP::Dispatcher.select(false)
+  #         #puts "done select"
+  #         expect(did_callback).to be(true)
+  #     end
+  #   end
+  #
+  #   it "get should work" do
+  #     did_callback = false
+  #     sess = Net::SNMP::Session.open(:peername => 'localhost', :version => 3, :username => 'MD5User',:security_level => Net::SNMP::Constants::SNMP_SEC_LEVEL_AUTHNOPRIV, :auth_protocol => :md5, :password => 'The Net-SNMP Demo Password') do |sess|
+  #       sess.get(["sysDescr.0", "sysContact.0"]) do |op,pdu|
+  #         did_callback = true
+  #         expect(pdu.varbinds[0].value).to eql("Linux nmsworker-devel 2.6.18-164.el5 #1 SMP Thu Sep 3 03:28:30 EDT 2009 x86_64")
+  #         expect(pdu.varbinds[1].value).to eql("Root <root@localhost> (configure /etc/snmp/snmp.local.conf)")
+  #       end
+  #     end
+  #     Net::SNMP::Dispatcher.select(false)
+  #     sess.close
+  #     expect(did_callback).to be(true)
+  #   end
+  #
+  #   #  XXX  occasionally segfaulting
+  #   it "getnext should work" do
+  #     did_callback = false
+  #
+  #     sess = Net::SNMP::Session.open(:peername => 'localhost', :version => 3, :username => 'MD5User',:security_level => Net::SNMP::Constants::SNMP_SEC_LEVEL_AUTHNOPRIV, :auth_protocol => :md5, :password => 'The Net-SNMP Demo Password') do |sess|
+  #       sess.get_next(["sysDescr", "sysContact"]) do |op, pdu|
+  #         did_callback = true
+  #         expect(pdu.varbinds[0].value).to eql("Linux nmsworker-devel 2.6.18-164.el5 #1 SMP Thu Sep 3 03:28:30 EDT 2009 x86_64")
+  #         expect(pdu.varbinds[1].value).to eql("Root <root@localhost> (configure /etc/snmp/snmp.local.conf)")
+  #       end
+  #     end
+  #     Net::SNMP::Dispatcher.select(false)
+  #     sess.close
+  #     expect(did_callback).to be(true)
+  #   end
+  #end
 end