snmpjr 0.1.4-java → 0.1.5-java

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MmUwZDc1YTk1N2M5MzY5ZjAxODgwNTU3ZjgzMjVlZTE5MWM5MWU5Mg==
+    ZDMzMmM5ZDlhMTIyMTMyODUxMjUxNTE5ZDk2YzA1YWJkMGRmMzFjZg==
   data.tar.gz: !binary |-
-    ZTRlZmVhNTg0ODEyNDBmYTc4ODE3ZjUwZTNmNDMzY2VmYjY1MDk0ZQ==
+    NDYzMGI3YzRiMzQxYWQxMThkOWM2ZjhhYzIzNDU1ZDFiYmUyNTFiMA==
 SHA512:
   metadata.gz: !binary |-
-    YjY5MjZhNWEwZTE4MGJhNTgzZmFhODcwMDRiNTY0MjAzOGE5ODExMDg5Y2Rl
-    ZjhlMGZiNjJkYzcxZTQ0OWE2Y2RjMWE5Y2Q1NjhiZDdiMmY1ZTE1YmQ1NjI1
-    OTAzYzViMDQ4ZjExNmE5MjY3NDVmZjhlNzRhNGUzZGEwMjZiMjI=
+    ZWQ2ZGVlM2I5ZWQyN2Y4ZDg1YjNiZWI0MGMzZjM1YmNkNjU3MTY5NWY0ZjU4
+    N2M4NjM1Njg0MWFlZmZjODA2MTA0MDI0NTE2NWVhMzdlYzZmZTVjMDVhZTUz
+    ODcxZDM2M2RmMTMxM2QxNGJjYjNmNjU4YmEwN2Q1NjgzMzYxZWI=
   data.tar.gz: !binary |-
-    MDNiMDE3MWM4NDUxMjIyZjZhZDBkZGQwZjViN2E5NWM4NGFjYWZkYWIyYWYy
-    MzgxNjU4MTgyODI1ODQ1YWQ2NWIwZDYwNjZiNGU4N2IwYjg4OTM2NWJlYzIw
-    M2EzNmU4MmI0MWZiZGU4OTIxY2E1YTc1MDQxMjA0MDQ2ZTU5NjU=
+    Njg0ZTlkYzExYjZkOWMzNjNhMTFhNmM0ODFmNGZjZWM5MWEzYmRmMGJjMDlj
+    ZGZjNzM1NDhkNGRkMTZmN2ZhNGE3MjRmYzY4NjcwNGRiYzFlNjZmNzA1NmZl
+    ZDNlOGRiMDMyMWQzZWQzNjRjYTU1NzU3MDlhMDQ5NThhZGMzZGM=

data/history.rdoc

@@ -1,3 +1,8 @@
+== 0.1.5 (14 October 2014)
+
+* Allow timeout to be specified in the initializer
+* Package Oids in a single PDU up to the default maximum of 30 which can be overidden using :max_oids_per_request
+
 == 0.1.4 (14 October 2014)
 
 * Returns a Response object rather than strings

data/lib/snmpjr/getter.rb

@@ -4,31 +4,32 @@ require "snmpjr/session"
 class Snmpjr
   class Getter
 
-    def initialize target
-      @target = target
+    def initialize args = {}
+      @target = args.fetch(:target)
+      @max_oids_per_request = args[:max_oids_per_request] || 30
       @session = Snmpjr::Session.new
     end
 
     def get_multiple oids
       @session.start
-      result = oids.map {|oid|
-        send_oid oid
-      }
+      result = oids.each_slice(@max_oids_per_request).map{|partial_oids|
+        get_request partial_oids
+      }.flatten
       @session.close
       result
     end
 
     def get oid
       @session.start
-      result = send_oid oid
+      result = get_request [oid]
       @session.close
-      result
+      result.first
     end
 
     private
 
-    def send_oid oid
-      pdu = Snmpjr::Pdu.new.create oid
+    def get_request oids
+      pdu = Snmpjr::Pdu.new.create oids
       @session.send(pdu, @target)
     end
 

data/lib/snmpjr/pdu.rb

@@ -1,14 +1,19 @@
+require 'snmpjr/wrappers/smi'
+require 'snmpjr/wrappers/snmp4j'
+
 class Snmpjr
   class Pdu
     module Constants
       GET = -96
     end
 
-    def create oid
+    def create oids
       pdu = Snmpjr::Wrappers::PDU.new
-      oid = Snmpjr::Wrappers::SMI::OID.new oid
-      variable_binding = Snmpjr::Wrappers::SMI::VariableBinding.new oid
-      pdu.add variable_binding
+      oids.map {|oid|
+        oid = Snmpjr::Wrappers::SMI::OID.new oid
+        variable_binding = Snmpjr::Wrappers::SMI::VariableBinding.new oid
+        pdu.add variable_binding
+      }
       pdu.type = Snmpjr::Pdu::Constants::GET
       pdu
     end

data/lib/snmpjr/session.rb

@@ -1,5 +1,6 @@
 require 'snmpjr/wrappers/transport'
 require 'snmpjr/response'
+require 'snmpjr/target_timeout_error'
 
 class Snmpjr
   class Session
@@ -15,18 +16,31 @@ class Snmpjr
     def send pdu, target
       begin
         result = @snmp.send(pdu, target)
-        if result.response.nil?
-          Snmpjr::Response.new(:error => 'Request timed out')
-        else
-          Snmpjr::Response.new(:value => result.response.variable_bindings.first.variable.to_s)
-        end
       rescue Exception => error
-        Snmpjr::Response.new(:error => error.to_s)
+        raise RuntimeError.new(error)
+      end
+      if result.response.nil?
+        raise Snmpjr::TargetTimeoutError.new('Request timed out')
+      else
+        result.response.variable_bindings.map{|vb|
+          construct_response(vb)
+        }
       end
     end
 
     def close
       @snmp.close
     end
+
+    private
+
+    def construct_response variable_binding
+      if variable_binding.is_exception
+        Snmpjr::Response.new(:error => variable_binding.variable.to_s)
+      else
+        Snmpjr::Response.new(:value => variable_binding.variable.to_s)
+      end
+    end
+
   end
 end

data/lib/snmpjr/target.rb

@@ -8,7 +8,7 @@ class Snmpjr
       target.community = Snmpjr::Wrappers::SMI::OctetString.new(options.fetch(:community))
       target.address = Snmpjr::Wrappers::SMI::GenericAddress.parse("udp:#{options.fetch(:host)}/#{options.fetch(:port)}")
       target.version = 1
-      target.timeout = 5000
+      target.timeout = options.fetch(:timeout)
       target
     end
   end

data/lib/snmpjr/target_timeout_error.rb

@@ -0,0 +1,5 @@
+class Snmpjr
+  class TargetTimeoutError < StandardError
+
+  end
+end

data/lib/snmpjr/version.rb

@@ -1,3 +1,3 @@
 class Snmpjr
-  VERSION = "0.1.4"
+  VERSION = "0.1.5"
 end

data/lib/snmpjr.rb

@@ -8,11 +8,13 @@ class Snmpjr
     @host = options.fetch(:host)
     @port = options.fetch(:port) || 161
     @community = options.fetch(:community)
+    @timeout = options[:timeout] || 5000
+    @max_oids_per_request = options[:max_oids_per_request] || 30
   end
 
   def get oids
-    target = Snmpjr::Target.new.create(:host => @host, :port => @port, :community => @community)
-    getter = Snmpjr::Getter.new(target)
+    target = Snmpjr::Target.new.create(:host => @host, :port => @port, :community => @community, :timeout => @timeout)
+    getter = Snmpjr::Getter.new(:target => target, :max_oids_per_request => @max_oids_per_request)
 
     case oids.class.to_s
     when 'String'

data/spec/integration/snmpjr_spec.rb

@@ -1,5 +1,6 @@
 require 'snmpjr'
 require 'snmpjr/response'
+require 'snmpjr/target_timeout_error'
 
 describe "snmpjr" do
 
@@ -19,20 +20,22 @@ describe "snmpjr" do
 
       context "when an invalid oid is requested" do
 
-        let(:expected) { [Snmpjr::Response.new(:error => 'Invalid first sub-identifier (must be 0, 1, or 2)'),
+        let(:expected) { [Snmpjr::Response.new(:error => 'noSuchInstance'),
                           Snmpjr::Response.new(:value => 'zeus.snmplabs.com')] }
 
         it "returns an error" do
-          expect(subject.get ['6.5.4.3.2.1', '1.3.6.1.2.1.1.5.0']).to eq expected
+          expect(subject.get ['1.3.6.1.2.1.1.5', '1.3.6.1.2.1.1.5.0']).to eq expected
         end
       end
     end
 
     context 'when the host is unreachable' do
-      subject { Snmpjr.new(:host => 'example.com', :port => 161, :community => 'public') }
+      subject { Snmpjr.new(:host => 'example.com', :port => 161, :community => 'public', :timeout => 50) }
 
       it "the request times out after 5 seconds" do
-        expect(subject.get '1.3.6.1.2.1.1.1.0').to eq Snmpjr::Response.new(:error => 'Request timed out')
+        expect{
+          subject.get '1.3.6.1.2.1.1.1.0'
+        }.to raise_error(Snmpjr::TargetTimeoutError)
       end
     end
   end

data/spec/snmpjr/getter_spec.rb

@@ -4,25 +4,28 @@ describe Snmpjr::Getter do
   let(:target) { double :target }
   let(:session) { double Snmpjr::Session }
   let(:pdu) { double Snmpjr::Pdu }
-  let(:created_pdu_1) { double :created_pdu_1 }
+  let(:created_pdu_single) { double :created_pdu_single }
 
-  subject { described_class.new(target) }
+  subject { described_class.new(:target => target, :max_oids_per_request => 1) }
 
   before do
     allow(Snmpjr::Pdu).to receive(:new).and_return pdu
-    allow(pdu).to receive(:create).with('1.2.3.4.5.6').and_return created_pdu_1
+    allow(pdu).to receive(:create).with(['1.2.3.4.5.6']).and_return created_pdu_single
     allow(Snmpjr::Session).to receive(:new).and_return session
     allow(session).to receive(:start)
-    allow(session).to receive(:send).with(created_pdu_1, target).and_return 'Foo'
+    allow(session).to receive(:send).with(created_pdu_single, target).and_return ['Foo']
     allow(session).to receive(:close)
   end
 
   describe "#get_multiple" do
-    let(:created_pdu_2) { double :created_pdu_2 }
+    let(:created_pdu_multiple_1) { double :created_pdu_multiple_1 }
+    let(:created_pdu_multiple_2) { double :created_pdu_multiple_2 }
 
     before do
-      allow(pdu).to receive(:create).with('6.5.4.3.2.1').and_return created_pdu_2
-      allow(session).to receive(:send).with(created_pdu_2, target).and_return 'Bar'
+      allow(pdu).to receive(:create).with(['1.2.3.4.5.6']).and_return created_pdu_multiple_1
+      allow(pdu).to receive(:create).with(['6.5.4.3.2.1']).and_return created_pdu_multiple_2
+      allow(session).to receive(:send).with(created_pdu_multiple_1, target).and_return ['Foo']
+      allow(session).to receive(:send).with(created_pdu_multiple_2, target).and_return ['Bar']
     end
 
     it 'starts an snmp session' do
@@ -32,8 +35,8 @@ describe Snmpjr::Getter do
 
     it 'performs multiple gets for each oid' do
       expect(subject.get_multiple ['1.2.3.4.5.6', '6.5.4.3.2.1']).to eq(['Foo', 'Bar'])
-      expect(session).to have_received(:send).with(created_pdu_1, target)
-      expect(session).to have_received(:send).with(created_pdu_2, target)
+      expect(session).to have_received(:send).with(created_pdu_multiple_1, target)
+      expect(session).to have_received(:send).with(created_pdu_multiple_2, target)
     end
 
     it 'closes the snmp session' do
@@ -50,7 +53,7 @@ describe Snmpjr::Getter do
 
     it 'performs a synchronous get' do
       expect(subject.get '1.2.3.4.5.6').to eq 'Foo'
-      expect(session).to have_received(:send).with(created_pdu_1, target)
+      expect(session).to have_received(:send).with(created_pdu_single, target)
     end
 
     it 'closes the snmp session' do

data/spec/snmpjr/pdu_spec.rb

@@ -4,26 +4,29 @@ describe Snmpjr::Pdu do
   describe "#create" do
 
     let(:pdu) { double Snmpjr::Wrappers::PDU }
-    let(:oid) { double Snmpjr::Wrappers::SMI::OID }
-    let(:variable_binding) { double Snmpjr::Wrappers::SMI::VariableBinding }
+    let(:oid_1) { double Snmpjr::Wrappers::SMI::OID }
+    let(:oid_2) { double Snmpjr::Wrappers::SMI::OID }
+    let(:variable_binding_1) { double Snmpjr::Wrappers::SMI::VariableBinding }
+    let(:variable_binding_2) { double Snmpjr::Wrappers::SMI::VariableBinding }
 
     before do
       allow(Snmpjr::Wrappers::PDU).to receive(:new).and_return pdu
-      allow(Snmpjr::Wrappers::SMI::OID).to receive(:new).and_return oid
-      allow(Snmpjr::Wrappers::SMI::VariableBinding).to receive(:new).and_return variable_binding
+      allow(Snmpjr::Wrappers::SMI::OID).to receive(:new).with('1.2.3.4').and_return oid_1
+      allow(Snmpjr::Wrappers::SMI::OID).to receive(:new).with('5.6.7.8').and_return oid_2
+      allow(Snmpjr::Wrappers::SMI::VariableBinding).to receive(:new).with(oid_1).and_return variable_binding_1
+      allow(Snmpjr::Wrappers::SMI::VariableBinding).to receive(:new).with(oid_2).and_return variable_binding_2
       allow(pdu).to receive(:type=)
       allow(pdu).to receive(:add)
     end
     it "creates a GET Pdu" do
       expect(pdu).to receive(:type=).with(Snmpjr::Pdu::Constants::GET)
-      subject.create '1.2.3.4'
+      subject.create ['1.2.3.4']
     end
 
     it "adds an SMI variable binding containing an oid to the pdu" do
-      expect(Snmpjr::Wrappers::SMI::OID).to receive(:new).with('1.2.3.4')
-      expect(Snmpjr::Wrappers::SMI::VariableBinding).to receive(:new).with(oid)
-      expect(pdu).to receive(:add).with variable_binding
-      subject.create '1.2.3.4'
+      expect(pdu).to receive(:add).with variable_binding_1
+      expect(pdu).to receive(:add).with variable_binding_2
+      subject.create ['1.2.3.4', '5.6.7.8']
     end
   end
 end

data/spec/snmpjr/session_spec.rb

@@ -28,13 +28,20 @@ describe Snmpjr::Session do
   end
 
   describe "#send" do
-    let(:result) { double :result }
+    let(:vb1) { double :vb1 }
+    let(:vb2) { double :vb2 }
+    let(:results) { [vb1, vb2] }
+    let(:response) { double :response }
     let(:pdu) { double :pdu }
     let(:target) { double :target }
 
     before do
-      allow(snmp_session).to receive(:send).and_return result
-      allow(result).to receive_message_chain('response.variable_bindings.first.variable.to_s')
+      allow(snmp_session).to receive(:send).and_return response
+      allow(vb1).to receive_message_chain('variable.to_s')
+      allow(vb1).to receive(:is_exception)
+      allow(vb2).to receive_message_chain('variable.to_s')
+      allow(vb2).to receive(:is_exception)
+      allow(response).to receive_message_chain('response.variable_bindings').and_return(results)
     end
 
     it "sends the pdu to the target" do
@@ -44,23 +51,25 @@ describe Snmpjr::Session do
 
     context 'the requests times out' do
       before do
-        allow(result).to receive(:response).and_return nil
+        allow(response).to receive(:response).and_return nil
       end
 
-      let(:expected_response) { Snmpjr::Response.new(:error => 'Request timed out') }
-      it 'returns a request timeout' do
-        expect(subject.send(pdu, target)).to eq expected_response
+      it 'raises a timeout error' do
+        expect {
+          subject.send(pdu, target)
+        }.to raise_error(Snmpjr::TargetTimeoutError)
       end
     end
 
     context 'an exception is raised' do
       before do
-        allow(snmp_session).to receive(:send).and_raise(RuntimeError.new('Some error'))
+        allow(snmp_session).to receive(:send).and_raise(Exception)
       end
 
-      let(:expected_response) { Snmpjr::Response.new(:error => 'Some error') }
-      it 'returns the error without blowing up' do
-        expect(subject.send(pdu, target)).to eq expected_response
+      it 'catches it and raises a ruby runtime error' do
+        expect{
+          subject.send(pdu, target)
+        }.to raise_error(RuntimeError)
       end
     end
   end

data/spec/snmpjr/target_spec.rb

@@ -3,7 +3,7 @@ require production_code
 describe Snmpjr::Target do
 
   describe "#create" do
-    let(:options) { { :host => '127.0.0.1', :port => 161, :community => 'some_community' } }
+    let(:options) { { :host => '127.0.0.1', :port => 161, :community => 'some_community', :timeout => 50 } }
 
     it "creates an octet string for the community string" do
       expect(Snmpjr::Wrappers::SMI::OctetString).to receive(:new).with(options[:community])
@@ -25,9 +25,9 @@ describe Snmpjr::Target do
       allow(community_target).to receive(:address=)
     end
 
-    it "sets the snmp version to v2c and the timeout to 5000ms" do
+    it "sets the snmp version to v2c and the timeout to 50ms" do
       expect(community_target).to receive(:version=).with(1)
-      expect(community_target).to receive(:timeout=).with(5000)
+      expect(community_target).to receive(:timeout=).with(50)
       subject.create(options)
     end
 

data/spec/snmpjr_spec.rb

@@ -11,12 +11,12 @@ describe Snmpjr do
       before do
         allow(Snmpjr::Target).to receive(:new).and_return target
         allow(target).to receive(:create).with(agent_details).and_return community_target
-        allow(Snmpjr::Getter).to receive(:new).with(community_target).and_return getter
+        allow(Snmpjr::Getter).to receive(:new).with(:target => community_target, :max_oids_per_request => 20).and_return getter
       end
 
-      let(:agent_details) { { :host => '127.0.0.1', :port => 161, :community => 'some_community' } }
+      let(:agent_details) { { :host => '127.0.0.1', :port => 161, :community => 'some_community', :timeout => 50 } }
 
-      subject { described_class.new(agent_details) }
+      subject { described_class.new(agent_details.merge({:max_oids_per_request => 20})) }
 
       context 'when passed a single oid' do
         it 'performs a synchronous get' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: snmpjr
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: java
 authors:
 - Zen Kyprianou
@@ -35,6 +35,7 @@ files:
 - lib/snmpjr/response.rb
 - lib/snmpjr/session.rb
 - lib/snmpjr/target.rb
+- lib/snmpjr/target_timeout_error.rb
 - lib/snmpjr/version.rb
 - lib/snmpjr/wrappers/smi.rb
 - lib/snmpjr/wrappers/snmp4j-2.3.1.jar