--- /dev/null
+# Copyright (C) 2002-2007 Stanislav Sinyagin
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
+
+# $Id: SNMP.pm,v 1.1 2010-12-27 00:03:58 ivan Exp $
+# Stanislav Sinyagin <ssinyagin@yahoo.com>
+
+package Torrus::Collector::SNMP;
+
+use Torrus::Collector::SNMP_Params;
+use Torrus::ConfigTree;
+use Torrus::Log;
+use Torrus::SNMP_Failures;
+
+use strict;
+use Net::hostent;
+use Socket;
+use Net::SNMP qw(:snmp);
+use Math::BigInt;
+
+
+# Register the collector type
+$Torrus::Collector::collectorTypes{'snmp'} = 1;
+
+
+# List of needed parameters and default values
+
+$Torrus::Collector::params{'snmp'} = {
+ 'snmp-ipversion' => undef,
+ 'snmp-transport' => undef,
+ 'snmp-version' => undef,
+ 'snmp-port' => undef,
+ 'snmp-community' => undef,
+ 'snmp-username' => undef,
+ 'snmp-authkey' => undef,
+ 'snmp-authpassword' => undef,
+ 'snmp-authprotocol' => 'md5',
+ 'snmp-privkey' => undef,
+ 'snmp-privpassword' => undef,
+ 'snmp-privprotocol' => 'des',
+ 'snmp-timeout' => undef,
+ 'snmp-retries' => undef,
+ 'domain-name' => undef,
+ 'snmp-host' => undef,
+ 'snmp-localaddr' => undef,
+ 'snmp-localport' => undef,
+ 'snmp-object' => undef,
+ 'snmp-oids-per-pdu' => undef,
+ 'snmp-object-type' => 'OTHER',
+ 'snmp-check-sysuptime' => 'yes',
+ 'snmp-max-msg-size' => undef,
+ 'snmp-ignore-mib-errors' => undef,
+ };
+
+my $sysUpTime = '1.3.6.1.2.1.1.3.0';
+
+# Hosts that are running SNMPv1. We do not reresh maps on them, as
+# they are too slow
+my %snmpV1Hosts;
+
+# SNMP tables lookup maps
+my %maps;
+
+# Old lookup maps, used temporarily during refresh cycle
+my %oldMaps;
+
+# How frequent we refresh the SNMP mapping
+our $mapsRefreshPeriod;
+
+# Random factor in refresh period
+our $mapsRefreshRandom;
+
+# Time period after configuration re-compile when we refresh existing mappings
+our $mapsUpdateInterval;
+
+# how often we check for expired maps
+our $mapsExpireCheckPeriod;
+
+# expiration time for each map
+my %mapsExpire;
+
+# Lookups scheduled for execution
+my %mapLookupScheduled;
+
+# SNMP session objects for map lookups
+my @mappingSessions;
+
+
+# Timestamps of hosts last found unreachable
+my %hostUnreachableSeen;
+
+# Last time we tried to reach an unreachable host
+my %hostUnreachableRetry;
+
+# Hosts that were deleted because of unreachability for too long
+my %unreachableHostDeleted;
+
+
+our $db_failures;
+
+# Flush stats after a restart or recompile
+$Torrus::Collector::initCollectorGlobals{'snmp'} =
+ \&Torrus::Collector::SNMP::initCollectorGlobals;
+
+sub initCollectorGlobals
+{
+ my $tree = shift;
+ my $instance = shift;
+
+ if( not defined( $db_failures ) )
+ {
+ $db_failures =
+ new Torrus::SNMP_Failures( -Tree => $tree,
+ -Instance => $instance,
+ -WriteAccess => 1 );
+ }
+
+ if( defined( $db_failures ) )
+ {
+ $db_failures->init();
+ }
+
+ # re-init counters and collect garbage
+ %oldMaps = ();
+ %hostUnreachableSeen = ();
+ %hostUnreachableRetry = ();
+ %unreachableHostDeleted = ();
+
+ # Configuration re-compile was probably caused by new object instances
+ # appearing on the monitored devices. Here we force the maps to refresh
+ # soon enough in order to catch up with the changes
+
+ my $now = time();
+ foreach my $maphash ( keys %mapsExpire )
+ {
+ $mapsExpire{$maphash} = int( $now + rand( $mapsUpdateInterval ) );
+ }
+}
+
+
+# This is first executed per target
+
+$Torrus::Collector::initTarget{'snmp'} = \&Torrus::Collector::SNMP::initTarget;
+
+
+
+sub initTarget
+{
+ my $collector = shift;
+ my $token = shift;
+
+ my $tref = $collector->tokenData( $token );
+ my $cref = $collector->collectorData( 'snmp' );
+
+ $collector->registerDeleteCallback
+ ( $token, \&Torrus::Collector::SNMP::deleteTarget );
+
+ my $hostname = getHostname( $collector, $token );
+ if( not defined( $hostname ) )
+ {
+ return 0;
+ }
+
+ $tref->{'hostname'} = $hostname;
+
+ return Torrus::Collector::SNMP::initTargetAttributes( $collector, $token );
+}
+
+
+sub initTargetAttributes
+{
+ my $collector = shift;
+ my $token = shift;
+
+ &Torrus::DB::checkInterrupted();
+
+ my $tref = $collector->tokenData( $token );
+ my $cref = $collector->collectorData( 'snmp' );
+
+ my $hostname = $tref->{'hostname'};
+ my $port = $collector->param($token, 'snmp-port');
+ my $version = $collector->param($token, 'snmp-version');
+
+ my $community;
+ if( $version eq '1' or $version eq '2c' )
+ {
+ $community = $collector->param($token, 'snmp-community');
+ }
+ else
+ {
+ # We use community string to identify the agent.
+ # For SNMPv3, it's the user name
+ $community = $collector->param($token, 'snmp-username');
+ }
+
+ my $hosthash = join('|', $hostname, $port, $community);
+ $tref->{'hosthash'} = $hosthash;
+
+ if( $version eq '1' )
+ {
+ $snmpV1Hosts{$hosthash} = 1;
+ }
+
+ # If the object is defined as a map, retrieve the whole map
+ # and cache it.
+
+ if( isHostDead( $collector, $hosthash ) )
+ {
+ return 0;
+ }
+
+ if( not checkUnreachableRetry( $collector, $hosthash ) )
+ {
+ $cref->{'needsRemapping'}{$token} = 1;
+ return 1;
+ }
+
+ my $oid = $collector->param($token, 'snmp-object');
+ $oid = expandOidMappings( $collector, $token, $hosthash, $oid );
+
+ if( not $oid )
+ {
+ if( $unreachableHostDeleted{$hosthash} )
+ {
+ # we tried our best, but the target is dead
+ return 0;
+ }
+ else
+ {
+ # we return OK status, to let the storage initiate
+ $cref->{'needsRemapping'}{$token} = 1;
+ return 1;
+ }
+ }
+ elsif( $oid eq 'notfound' )
+ {
+ return 0;
+ }
+
+ # Collector should be able to find the target
+ # by host, port, community, and oid.
+ # There can be several targets with the same host|port|community+oid set.
+
+ $cref->{'targets'}{$hosthash}{$oid}{$token} = 1;
+ $cref->{'activehosts'}{$hosthash} = 1;
+
+ $tref->{'oid'} = $oid;
+
+ $cref->{'oids_per_pdu'}{$hosthash} =
+ $collector->param($token, 'snmp-oids-per-pdu');
+
+ if( $collector->param($token, 'snmp-object-type') eq 'COUNTER64' )
+ {
+ $cref->{'64bit_oid'}{$oid} = 1;
+ }
+
+ if( $collector->param($token, 'snmp-check-sysuptime') eq 'no' )
+ {
+ $cref->{'nosysuptime'}{$hosthash} = 1;
+ }
+
+ if( $collector->param($token, 'snmp-ignore-mib-errors') eq 'yes' )
+ {
+ $cref->{'ignoremiberrors'}{$hosthash}{$oid} = 1;
+ }
+
+ return 1;
+}
+
+
+sub getHostname
+{
+ my $collector = shift;
+ my $token = shift;
+
+ my $cref = $collector->collectorData( 'snmp' );
+
+ my $hostname = $collector->param($token, 'snmp-host');
+ my $domain = $collector->param($token, 'domain-name');
+
+ if( length( $domain ) > 0 and
+ index($hostname, '.') < 0 and
+ index($hostname, ':') < 0 )
+ {
+ $hostname .= '.' . $domain;
+ }
+
+ return $hostname;
+}
+
+
+sub snmpSessionArgs
+{
+ my $collector = shift;
+ my $token = shift;
+ my $hosthash = shift;
+
+ my $cref = $collector->collectorData( 'snmp' );
+ if( defined( $cref->{'snmpargs'}{$hosthash} ) )
+ {
+ return $cref->{'snmpargs'}{$hosthash};
+ }
+
+ my $transport = $collector->param($token, 'snmp-transport') . '/ipv' .
+ $collector->param($token, 'snmp-ipversion');
+
+ my ($hostname, $port, $community) = split(/\|/o, $hosthash);
+
+ my $version = $collector->param($token, 'snmp-version');
+ my $ret = [ -domain => $transport,
+ -hostname => $hostname,
+ -port => $port,
+ -timeout => $collector->param($token, 'snmp-timeout'),
+ -retries => $collector->param($token, 'snmp-retries'),
+ -version => $version ];
+
+ foreach my $arg ( qw(-localaddr -localport) )
+ {
+ if( defined( $collector->param($token, 'snmp' . $arg) ) )
+ {
+ push( @{$ret}, $arg, $collector->param($token, 'snmp' . $arg) );
+ }
+ }
+
+ if( $version eq '1' or $version eq '2c' )
+ {
+ push( @{$ret}, '-community', $community );
+ }
+ else
+ {
+ push( @{$ret}, -username, $community);
+
+ foreach my $arg ( qw(-authkey -authpassword -authprotocol
+ -privkey -privpassword -privprotocol) )
+ {
+ if( defined( $collector->param($token, 'snmp' . $arg) ) )
+ {
+ push( @{$ret},
+ $arg, $collector->param($token, 'snmp' . $arg) );
+ }
+ }
+ }
+
+ $cref->{'snmpargs'}{$hosthash} = $ret;
+ return $ret;
+}
+
+
+
+sub openBlockingSession
+{
+ my $collector = shift;
+ my $token = shift;
+ my $hosthash = shift;
+
+ my $args = snmpSessionArgs( $collector, $token, $hosthash );
+ my ($session, $error) =
+ Net::SNMP->session( @{$args},
+ -nonblocking => 0,
+ -translate => ['-all', 0, '-octetstring', 1] );
+ if( not defined($session) )
+ {
+ Error('Cannot create SNMP session for ' . $hosthash . ': ' . $error);
+ }
+ else
+ {
+ my $maxmsgsize = $collector->param($token, 'snmp-max-msg-size');
+ if( defined( $maxmsgsize ) and $maxmsgsize > 0 )
+ {
+ $session->max_msg_size( $maxmsgsize );
+ }
+ }
+
+ return $session;
+}
+
+sub openNonblockingSession
+{
+ my $collector = shift;
+ my $token = shift;
+ my $hosthash = shift;
+
+ my $args = snmpSessionArgs( $collector, $token, $hosthash );
+
+ my ($session, $error) =
+ Net::SNMP->session( @{$args},
+ -nonblocking => 0x1,
+ -translate => ['-timeticks' => 0] );
+ if( not defined($session) )
+ {
+ Error('Cannot create SNMP session for ' . $hosthash . ': ' . $error);
+ return undef;
+ }
+
+ if( $collector->param($token, 'snmp-transport') eq 'udp' )
+ {
+ # We set SO_RCVBUF only once, because Net::SNMP shares
+ # one UDP socket for all sessions.
+
+ my $sock_name = $session->transport()->sock_name();
+ my $refcount = $Net::SNMP::Transport::SOCKETS->{
+ $sock_name}->[&Net::SNMP::Transport::_SHARED_REFC()];
+
+ if( $refcount == 1 )
+ {
+ my $buflen = int($Torrus::Collector::SNMP::RxBuffer);
+ my $socket = $session->transport()->socket();
+ my $ok = $socket->sockopt( SO_RCVBUF, $buflen );
+ if( not $ok )
+ {
+ Error('Could not set SO_RCVBUF to ' .
+ $buflen . ': ' . $!);
+ }
+ else
+ {
+ Debug('Set SO_RCVBUF to ' . $buflen);
+ }
+ }
+ }
+
+ my $maxmsgsize = $collector->param($token, 'snmp-max-msg-size');
+ if( defined( $maxmsgsize ) and $maxmsgsize > 0 )
+ {
+ $session->max_msg_size( $maxmsgsize );
+
+ }
+
+ return $session;
+}
+
+
+sub expandOidMappings
+{
+ my $collector = shift;
+ my $token = shift;
+ my $hosthash = shift;
+ my $oid_in = shift;
+
+ my $cref = $collector->collectorData( 'snmp' );
+
+ my $oid = $oid_in;
+
+ # Process Map statements
+
+ while( index( $oid, 'M(' ) >= 0 )
+ {
+ if( not $oid =~ /^(.*)M\(\s*([0-9\.]+)\s*,\s*([^\)]+)\)(.*)$/o )
+ {
+ Error("Error in OID mapping syntax: $oid");
+ return undef;
+ }
+
+ my $head = $1;
+ my $map = $2;
+ my $key = $3;
+ my $tail = $4;
+
+ # Remove trailing space from key
+ $key =~ s/\s+$//o;
+
+ my $value =
+ lookupMap( $collector, $token, $hosthash, $map, $key );
+
+ if( defined( $value ) )
+ {
+ if( $value eq 'notfound' )
+ {
+ return 'notfound';
+ }
+ else
+ {
+ $oid = $head . $value . $tail;
+ }
+ }
+ else
+ {
+ return undef;
+ }
+ }
+
+ # process value lookups
+
+ while( index( $oid, 'V(' ) >= 0 )
+ {
+ if( not $oid =~ /^(.*)V\(\s*([0-9\.]+)\s*\)(.*)$/o )
+ {
+ Error("Error in OID value lookup syntax: $oid");
+ return undef;
+ }
+
+ my $head = $1;
+ my $key = $2;
+ my $tail = $4;
+
+ my $value;
+
+ if( not defined( $cref->{'value-lookups'}
+ {$hosthash}{$key} ) )
+ {
+ # Retrieve the OID value from host
+
+ my $session = openBlockingSession( $collector, $token, $hosthash );
+ if( not defined($session) )
+ {
+ return undef;
+ }
+
+ my $result = $session->get_request( -varbindlist => [$key] );
+ $session->close();
+ if( defined $result and defined($result->{$key}) )
+ {
+ $value = $result->{$key};
+ $cref->{'value-lookups'}{$hosthash}{$key} = $value;
+ }
+ else
+ {
+ Error("Error retrieving $key from $hosthash: " .
+ $session->error());
+ probablyDead( $collector, $hosthash );
+ return undef;
+ }
+ }
+ else
+ {
+ $value =
+ $cref->{'value-lookups'}{$hosthash}{$key};
+ }
+ if( defined( $value ) )
+ {
+ $oid = $head . $value . $tail;
+ }
+ else
+ {
+ return 'notfound';
+ }
+ }
+
+ # Debug('OID expanded: ' . $oid_in . ' -> ' . $oid');
+ return $oid;
+}
+
+# Look up table index in a map by value
+
+sub lookupMap
+{
+ my $collector = shift;
+ my $token = shift;
+ my $hosthash = shift;
+ my $map = shift;
+ my $key = shift;
+
+ my $cref = $collector->collectorData( 'snmp' );
+ my $maphash = join('#', $hosthash, $map);
+
+ if( not defined( $maps{$hosthash}{$map} ) )
+ {
+ my $ret;
+
+ if( defined( $oldMaps{$hosthash}{$map} ) and
+ defined( $key ) )
+ {
+ $ret = $oldMaps{$hosthash}{$map}{$key};
+ }
+
+ if( $mapLookupScheduled{$maphash} )
+ {
+ return $ret;
+ }
+
+ if( scalar(@mappingSessions) >=
+ $Torrus::Collector::SNMP::maxSessionsPerDispatcher )
+ {
+ snmp_dispatcher();
+ @mappingSessions = ();
+ %mapLookupScheduled = ();
+ }
+
+ # Retrieve map from host
+ Debug('Retrieving map ' . $map . ' from ' . $hosthash);
+
+ my $session = openNonblockingSession( $collector, $token, $hosthash );
+ if( not defined($session) )
+ {
+ return $ret;
+ }
+ else
+ {
+ push( @mappingSessions, $session );
+ }
+
+ # Retrieve the map table
+
+ $session->get_table( -baseoid => $map,
+ -callback => [\&mapLookupCallback,
+ $collector, $hosthash, $map] );
+
+ $mapLookupScheduled{$maphash} = 1;
+
+ if( not $snmpV1Hosts{$hosthash} )
+ {
+ $mapsExpire{$maphash} =
+ int( time() + $mapsRefreshPeriod +
+ rand( $mapsRefreshPeriod * $mapsRefreshRandom ) );
+ }
+
+ return $ret;
+ }
+
+ if( defined( $key ) )
+ {
+ my $value = $maps{$hosthash}{$map}{$key};
+ if( not defined $value )
+ {
+ Error("Cannot find value $key in map $map for $hosthash in ".
+ $collector->path($token));
+ if( defined ( $maps{$hosthash}{$map} ) )
+ {
+ Error("Current map follows");
+ while( my($key, $val) = each
+ %{$maps{$hosthash}{$map}} )
+ {
+ Error("'$key' => '$val'");
+ }
+ }
+ return 'notfound';
+ }
+ else
+ {
+ if( not $snmpV1Hosts{$hosthash} )
+ {
+ $cref->{'mapsDependentTokens'}{$maphash}{$token} = 1;
+ $cref->{'mapsRelatedMaps'}{$token}{$maphash} = 1;
+ }
+
+ return $value;
+ }
+ }
+ else
+ {
+ return undef;
+ }
+}
+
+
+sub mapLookupCallback
+{
+ my $session = shift;
+ my $collector = shift;
+ my $hosthash = shift;
+ my $map = shift;
+
+ &Torrus::DB::checkInterrupted();
+
+ Debug('Received mapping PDU from ' . $hosthash);
+
+ my $result = $session->var_bind_list();
+ if( defined $result )
+ {
+ my $preflen = length($map) + 1;
+
+ while( my( $oid, $key ) = each %{$result} )
+ {
+ my $val = substr($oid, $preflen);
+ $maps{$hosthash}{$map}{$key} = $val;
+ # Debug("Map $map discovered: '$key' -> '$val'");
+ }
+ }
+ else
+ {
+ Error("Error retrieving table $map from $hosthash: " .
+ $session->error());
+ $session->close();
+ probablyDead( $collector, $hosthash );
+ return undef;
+ }
+}
+
+sub activeMappingSessions
+{
+ return scalar( @mappingSessions );
+}
+
+# The target host is unreachable. We try to reach it few more times and
+# give it the final diagnose.
+
+sub probablyDead
+{
+ my $collector = shift;
+ my $hosthash = shift;
+
+ my $cref = $collector->collectorData( 'snmp' );
+
+ # Stop all collection for this host, until next initTargetAttributes
+ # is successful
+ delete $cref->{'activehosts'}{$hosthash};
+
+ my $probablyAlive = 1;
+
+ if( defined( $hostUnreachableSeen{$hosthash} ) )
+ {
+ if( $Torrus::Collector::SNMP::unreachableTimeout > 0 and
+ time() -
+ $hostUnreachableSeen{$hosthash} >
+ $Torrus::Collector::SNMP::unreachableTimeout )
+ {
+ $probablyAlive = 0;
+ }
+ }
+ else
+ {
+ $hostUnreachableSeen{$hosthash} = time();
+
+ if( defined( $db_failures ) )
+ {
+ $db_failures->host_failure('unreachable', $hosthash);
+ $db_failures->set_counter('unreachable',
+ scalar( keys %hostUnreachableSeen));
+ }
+ }
+
+ if( $probablyAlive )
+ {
+ Info('Target host is unreachable. Will try again later: ' . $hosthash);
+ }
+ else
+ {
+ # It is dead indeed. Delete all tokens associated with this host
+ Info('Target host is unreachable during last ' .
+ $Torrus::Collector::SNMP::unreachableTimeout .
+ ' seconds. Giving it up: ' . $hosthash);
+ my @deleteTargets = ();
+ while( my ($oid, $ref1) =
+ each %{$cref->{'targets'}{$hosthash}} )
+ {
+ while( my ($token, $dummy) = each %{$ref1} )
+ {
+ push( @deleteTargets, $token );
+ }
+ }
+
+ Debug('Deleting ' . scalar( @deleteTargets ) . ' tokens');
+ foreach my $token ( @deleteTargets )
+ {
+ $collector->deleteTarget($token);
+ }
+
+ delete $hostUnreachableSeen{$hosthash};
+ delete $hostUnreachableRetry{$hosthash};
+ $unreachableHostDeleted{$hosthash} = 1;
+
+ if( defined( $db_failures ) )
+ {
+ $db_failures->host_failure('deleted', $hosthash);
+ $db_failures->set_counter('unreachable',
+ scalar( keys %hostUnreachableSeen));
+ $db_failures->set_counter('deleted',
+ scalar( keys %unreachableHostDeleted));
+ }
+ }
+
+ return $probablyAlive;
+}
+
+# Return false if the try is too early
+
+sub checkUnreachableRetry
+{
+ my $collector = shift;
+ my $hosthash = shift;
+
+ my $cref = $collector->collectorData( 'snmp' );
+
+ my $ret = 1;
+ if( $hostUnreachableSeen{$hosthash} )
+ {
+ my $lastRetry = $hostUnreachableRetry{$hosthash};
+
+ if( not defined( $lastRetry ) )
+ {
+ $lastRetry = $hostUnreachableSeen{$hosthash};
+ }
+
+ if( time() < $lastRetry +
+ $Torrus::Collector::SNMP::unreachableRetryDelay )
+ {
+ $ret = 0;
+ }
+ else
+ {
+ $hostUnreachableRetry{$hosthash} = time();
+ }
+ }
+
+ return $ret;
+}
+
+
+sub isHostDead
+{
+ my $collector = shift;
+ my $hosthash = shift;
+
+ my $cref = $collector->collectorData( 'snmp' );
+ return $unreachableHostDeleted{$hosthash};
+}
+
+
+sub hostReachableAgain
+{
+ my $collector = shift;
+ my $hosthash = shift;
+
+ my $cref = $collector->collectorData( 'snmp' );
+ if( exists( $hostUnreachableSeen{$hosthash} ) )
+ {
+ delete $hostUnreachableSeen{$hosthash};
+ if( defined( $db_failures ) )
+ {
+ $db_failures->remove_host($hosthash);
+ $db_failures->set_counter('unreachable',
+ scalar( keys %hostUnreachableSeen));
+ }
+ }
+}
+
+
+# Callback executed by Collector
+
+sub deleteTarget
+{
+ my $collector = shift;
+ my $token = shift;
+
+ my $tref = $collector->tokenData( $token );
+ my $cref = $collector->collectorData( 'snmp' );
+
+ my $hosthash = $tref->{'hosthash'};
+ my $oid = $tref->{'oid'};
+
+ delete $cref->{'targets'}{$hosthash}{$oid}{$token};
+ if( not %{$cref->{'targets'}{$hosthash}{$oid}} )
+ {
+ delete $cref->{'targets'}{$hosthash}{$oid};
+
+ if( not %{$cref->{'targets'}{$hosthash}} )
+ {
+ delete $cref->{'targets'}{$hosthash};
+ }
+ }
+
+ delete $cref->{'needsRemapping'}{$token};
+
+ foreach my $maphash ( keys %{$cref->{'mapsRelatedMaps'}{$token}} )
+ {
+ delete $cref->{'mapsDependentTokens'}{$maphash}{$token};
+ }
+ delete $cref->{'mapsRelatedMaps'}{$token};
+}
+
+# Main collector cycle
+
+$Torrus::Collector::runCollector{'snmp'} =
+ \&Torrus::Collector::SNMP::runCollector;
+
+sub runCollector
+{
+ my $collector = shift;
+ my $cref = shift;
+
+ # Info(sprintf('runCollector() Offset: %d, active hosts: %d, maps: %d',
+ # $collector->offset(),
+ # scalar( keys %{$cref->{'activehosts'}} ),
+ # scalar(keys %maps)));
+
+ # Create one SNMP session per host address.
+ # We assume that version, timeout and retries are the same
+ # within one address
+
+ # We limit the number of sessions per snmp_dispatcher run
+ # because of some strange bugs: with more than 400 sessions per
+ # dispatcher, some requests are not sent out
+
+ my @hosts = keys %{$cref->{'activehosts'}};
+
+ while( scalar(@mappingSessions) + scalar(@hosts) > 0 )
+ {
+ my @batch = ();
+ while( ( scalar(@mappingSessions) + scalar(@batch) <
+ $Torrus::Collector::SNMP::maxSessionsPerDispatcher )
+ and
+ scalar(@hosts) > 0 )
+ {
+ push( @batch, pop( @hosts ) );
+ }
+
+ &Torrus::DB::checkInterrupted();
+
+ my @sessions;
+
+ foreach my $hosthash ( @batch )
+ {
+ my @oids = sort keys %{$cref->{'targets'}{$hosthash}};
+
+ # Info(sprintf('Host %s: %d OIDs',
+ # $hosthash,
+ # scalar(@oids)));
+
+ # Find one representative token for the host
+
+ if( scalar( @oids ) == 0 )
+ {
+ next;
+ }
+
+ my @reptokens = keys %{$cref->{'targets'}{$hosthash}{$oids[0]}};
+ if( scalar( @reptokens ) == 0 )
+ {
+ next;
+ }
+ my $reptoken = $reptokens[0];
+
+ my $session =
+ openNonblockingSession( $collector, $reptoken, $hosthash );
+
+ &Torrus::DB::checkInterrupted();
+
+ if( not defined($session) )
+ {
+ next;
+ }
+ else
+ {
+ Debug('Created SNMP session for ' . $hosthash);
+ push( @sessions, $session );
+ }
+
+ my $oids_per_pdu = $cref->{'oids_per_pdu'}{$hosthash};
+
+ my @pdu_oids = ();
+ my $delay = 0;
+
+ while( scalar( @oids ) > 0 )
+ {
+ my $oid = shift @oids;
+ push( @pdu_oids, $oid );
+
+ if( scalar( @oids ) == 0 or
+ ( scalar( @pdu_oids ) >= $oids_per_pdu ) )
+ {
+ if( not $cref->{'nosysuptime'}{$hosthash} )
+ {
+ # We insert sysUpTime into every PDU, because
+ # we need it in further processing
+ push( @pdu_oids, $sysUpTime );
+ }
+
+ if( Torrus::Log::isDebug() )
+ {
+ Debug('Sending SNMP PDU to ' . $hosthash . ':');
+ foreach my $oid ( @pdu_oids )
+ {
+ Debug($oid);
+ }
+ }
+
+ # Generate the list of tokens that form this PDU
+ my $pdu_tokens = {};
+ foreach my $oid ( @pdu_oids )
+ {
+ if( defined( $cref->{'targets'}{$hosthash}{$oid} ) )
+ {
+ foreach my $token
+ ( keys %{$cref->{'targets'}{$hosthash}{$oid}} )
+ {
+ $pdu_tokens->{$oid}{$token} = 1;
+ }
+ }
+ }
+ my $result =
+ $session->
+ get_request( -delay => $delay,
+ -callback =>
+ [ \&Torrus::Collector::SNMP::callback,
+ $collector, $pdu_tokens, $hosthash ],
+ -varbindlist => \@pdu_oids );
+ if( not defined $result )
+ {
+ Error("Cannot create SNMP request: " .
+ $session->error);
+ }
+ @pdu_oids = ();
+ $delay += 0.01;
+ }
+ }
+ }
+
+ &Torrus::DB::checkInterrupted();
+
+ snmp_dispatcher();
+
+ # Check if there were pending map lookup sessions
+
+ if( scalar( @mappingSessions ) > 0 )
+ {
+ @mappingSessions = ();
+ %mapLookupScheduled = ();
+ }
+ }
+}
+
+
+sub callback
+{
+ my $session = shift;
+ my $collector = shift;
+ my $pdu_tokens = shift;
+ my $hosthash = shift;
+
+ &Torrus::DB::checkInterrupted();
+
+ my $cref = $collector->collectorData( 'snmp' );
+
+ Debug('SNMP Callback executed for ' . $hosthash);
+
+ if( not defined( $session->var_bind_list() ) )
+ {
+ Error('SNMP Error for ' . $hosthash . ': ' . $session->error() .
+ ' when retrieving ' . join(' ', sort keys %{$pdu_tokens}));
+
+ probablyDead( $collector, $hosthash );
+
+ # Clear the mapping
+ delete $maps{$hosthash};
+ foreach my $oid ( keys %{$pdu_tokens} )
+ {
+ foreach my $token ( keys %{$pdu_tokens->{$oid}} )
+ {
+ $cref->{'needsRemapping'}{$token} = 1;
+ }
+ }
+ return;
+ }
+ else
+ {
+ hostReachableAgain( $collector, $hosthash );
+ }
+
+ my $timestamp = time();
+
+ my $checkUptime = not $cref->{'nosysuptime'}{$hosthash};
+ my $doSetValue = 1;
+
+ my $uptime = 0;
+
+ if( $checkUptime )
+ {
+ my $uptimeTicks = $session->var_bind_list()->{$sysUpTime};
+ if( defined $uptimeTicks )
+ {
+ $uptime = $uptimeTicks / 100;
+ Debug('Uptime: ' . $uptime);
+ }
+ else
+ {
+ Error('Did not receive sysUpTime for ' . $hosthash);
+ }
+
+ if( $uptime < $collector->period() or
+ ( defined($cref->{'knownUptime'}{$hosthash})
+ and
+ $uptime + $collector->period() <
+ $cref->{'knownUptime'}{$hosthash} ) )
+ {
+ # The agent has reloaded. Clean all maps and push UNDEF
+ # values to the storage
+
+ Info('Agent rebooted: ' . $hosthash);
+ delete $maps{$hosthash};
+
+ $timestamp -= $uptime;
+ foreach my $oid ( keys %{$pdu_tokens} )
+ {
+ foreach my $token ( keys %{$pdu_tokens->{$oid}} )
+ {
+ $collector->setValue( $token, 'U', $timestamp, $uptime );
+ $cref->{'needsRemapping'}{$token} = 1;
+ }
+ }
+
+ $doSetValue = 0;
+ }
+ $cref->{'knownUptime'}{$hosthash} = $uptime;
+ }
+
+ if( $doSetValue )
+ {
+ while( my ($oid, $value) = each %{ $session->var_bind_list() } )
+ {
+ # Debug("OID=$oid, VAL=$value");
+ if( $value eq 'noSuchObject' or
+ $value eq 'noSuchInstance' or
+ $value eq 'endOfMibView' )
+ {
+ if( not $cref->{'ignoremiberrors'}{$hosthash}{$oid} )
+ {
+ Error("Error retrieving $oid from $hosthash: $value");
+
+ foreach my $token ( keys %{$pdu_tokens->{$oid}} )
+ {
+ if( defined( $db_failures ) )
+ {
+ $db_failures->mib_error
+ ($hosthash, $collector->path($token));
+ }
+
+ $collector->deleteTarget($token);
+ }
+ }
+ }
+ else
+ {
+ if( $cref->{'64bit_oid'}{$oid} )
+ {
+ $value = Math::BigInt->new($value);
+ }
+
+ foreach my $token ( keys %{$pdu_tokens->{$oid}} )
+ {
+ $collector->setValue( $token, $value,
+ $timestamp, $uptime );
+ }
+ }
+ }
+ }
+}
+
+
+# Execute this after the collector has finished
+
+$Torrus::Collector::postProcess{'snmp'} =
+ \&Torrus::Collector::SNMP::postProcess;
+
+sub postProcess
+{
+ my $collector = shift;
+ my $cref = shift;
+
+ # It could happen that postProcess is called for a collector which
+ # has no targets, and therefore it's the only place where we can
+ # initialize these variables
+
+ if( not defined( $cref->{'mapsLastExpireChecked'} ) )
+ {
+ $cref->{'mapsLastExpireChecked'} = 0;
+ }
+
+ if( not defined( $cref->{'mapsRefreshed'} ) )
+ {
+ $cref->{'mapsRefreshed'} = [];
+ }
+
+ # look if some maps are ready after last expiration check
+ if( scalar( @{$cref->{'mapsRefreshed'}} ) > 0 )
+ {
+ foreach my $maphash ( @{$cref->{'mapsRefreshed'}} )
+ {
+ foreach my $token
+ ( keys %{$cref->{'mapsDependentTokens'}{$maphash}} )
+ {
+ $cref->{'needsRemapping'}{$token} = 1;
+ }
+ }
+ $cref->{'mapsRefreshed'} = [];
+ }
+
+ my $now = time();
+
+ if( $cref->{'mapsLastExpireChecked'} + $mapsExpireCheckPeriod <= $now )
+ {
+ $cref->{'mapsLastExpireChecked'} = $now;
+
+ # Check the maps expiration and arrange lookup for expired
+
+ while( my ( $maphash, $expire ) = each %mapsExpire )
+ {
+ if( $expire <= $now and not $mapLookupScheduled{$maphash} )
+ {
+ &Torrus::DB::checkInterrupted();
+
+ my ( $hosthash, $map ) = split( /\#/o, $maphash );
+
+ if( $unreachableHostDeleted{$hosthash} )
+ {
+ # This host is no longer polled. Remove the leftovers
+
+ delete $mapsExpire{$maphash};
+ delete $maps{$hosthash};
+ }
+ else
+ {
+ # Find one representative token for the map
+ my @tokens =
+ keys %{$cref->{'mapsDependentTokens'}{$maphash}};
+ if( scalar( @tokens ) == 0 )
+ {
+ next;
+ }
+ my $reptoken = $tokens[0];
+
+ # save the map for the time of refresh
+ $oldMaps{$hosthash}{$map} = $maps{$hosthash}{$map};
+ delete $maps{$hosthash}{$map};
+
+ # this will schedule the map retrieval for the next
+ # collector cycle
+ Debug('Refreshing map: ' . $maphash);
+
+ lookupMap( $collector, $reptoken,
+ $hosthash, $map, undef );
+
+ # After the next collector period, the maps will be
+ # ready and tokens may be updated without losing the data
+ push( @{$cref->{'mapsRefreshed'}}, $maphash );
+ }
+ }
+ }
+ }
+
+ foreach my $token ( keys %{$cref->{'needsRemapping'}} )
+ {
+ &Torrus::DB::checkInterrupted();
+
+ delete $cref->{'needsRemapping'}{$token};
+ if( not Torrus::Collector::SNMP::initTargetAttributes
+ ( $collector, $token ) )
+ {
+ $collector->deleteTarget($token);
+ }
+ }
+}
+
+1;
+
+
+# Local Variables:
+# mode: perl
+# indent-tabs-mode: nil
+# perl-indent-level: 4
+# End:
projects / freeside.git / blobdiff