Class: SNMP::TrapListener

Inherits:
Object
  • Object
show all
Defined in:
lib/snmp/manager.rb

Overview

SNMP Trap Listener

Listens to a socket and processes received traps in a separate thread.

Example

require 'snmp'

m = SNMP::TrapListener.new(:Port => 1062, :Community => 'public') do |manager|
  manager.on_trap_default { |trap| p trap }
end
m.join

Constant Summary collapse

DefaultConfig = 
{
:Port => 162,
:Community => 'public',
:ServerTransport => UDPServerTransport,
:MaxReceiveBytes => 8000}
NULL_HANDLER = 
Proc.new {}

Instance Method Summary collapse

Constructor Details

#initialize(config = {}, &block) ⇒ TrapListener

Start a trap handler thread. If a block is provided then the block is executed before trap handling begins. This block is typically used to define the trap handler blocks.

The trap handler blocks execute in the context of the trap handler thread.

The most specific trap handler is executed when a trap arrives. Only one handler is executed. The handlers are checked in the following order:

  1. handler for a specific OID

  2. handler for a specific SNMP version

  3. default handler



423
424
425
426
427
428
429
430
431
432
433
434
 
# File 'lib/snmp/manager.rb', line 423

def initialize(config={}, &block)
    @config = DefaultConfig.dup.update(config)
    @transport = @config[:ServerTransport].new(@config[:Port])
    @max_bytes = @config[:MaxReceiveBytes]
    @handler_init = block
    @oid_handler = {}
    @v1_handler = nil
    @v2c_handler = nil
    @default_handler = nil
    @lock = Mutex.new
    @handler_thread = Thread.new(self) { |m| process_traps(m) }
end

Instance Method Details

#exit ⇒ Object Also known as: kill, terminate

Stops the trap handler thread and releases the socket.

See also Thread#exit.



488
489
490
491
 
# File 'lib/snmp/manager.rb', line 488

def exit
    @handler_thread.exit
    @transport.close
end

#join ⇒ Object

Joins the current thread to the trap handler thread.

See also Thread#join.



479
480
481
 
# File 'lib/snmp/manager.rb', line 479

def join
    @handler_thread.join
end

#on_trap(object_id, &block) ⇒ Object

Define a trap handler block for a specific trap ObjectId. This handler only applies to SNMPv2 traps. Note that symbolic OIDs are not supported by this method (like in the SNMP.Manager class).

Raises:

  • (ArgumentError) 


451
452
453
454
 
# File 'lib/snmp/manager.rb', line 451

def on_trap(object_id, &block)
    raise ArgumentError, "a block must be provided" unless block
    @lock.synchronize { @oid_handler[ObjectId.new(object_id)] = block }
end

#on_trap_default(&block) ⇒ Object

Define the default trap handler. The default trap handler block is executed only if no other block is applicable. This handler should expect to receive both SNMPv1_Trap and SNMPv2_Trap objects.

Raises:

  • (ArgumentError) 


441
442
443
444
 
# File 'lib/snmp/manager.rb', line 441

def on_trap_default(&block)
    raise ArgumentError, "a block must be provided" unless block
    @lock.synchronize { @default_handler = block }
end

#on_trap_v1(&block) ⇒ Object

Define a trap handler block for all SNMPv1 traps. The trap yielded to the block will always be an SNMPv1_Trap.

Raises:

  • (ArgumentError) 


460
461
462
463
 
# File 'lib/snmp/manager.rb', line 460

def on_trap_v1(&block)
    raise ArgumentError, "a block must be provided" unless block
    @lock.synchronize { @v1_handler = block }
end

#on_trap_v2c(&block) ⇒ Object

Define a trap handler block for all SNMPv2c traps. The trap yielded to the block will always be an SNMPv2_Trap.

Raises:

  • (ArgumentError) 


469
470
471
472
 
# File 'lib/snmp/manager.rb', line 469

def on_trap_v2c(&block)
    raise ArgumentError, "a block must be provided" unless block
    @lock.synchronize { @v2c_handler = block }
end