src/lib/Torrus/Collector/SNMP.pm

   1 #  Copyright (C) 2002-2011  Stanislav Sinyagin
   2 #
   3 #  This program is free software; you can redistribute it and/or modify
   4 #  it under the terms of the GNU General Public License as published by
   5 #  the Free Software Foundation; either version 2 of the License, or
   6 #  (at your option) any later version.
   7 #
   8 #  This program is distributed in the hope that it will be useful,
   9 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11 #  GNU General Public License for more details.
  12 #
  13 #  You should have received a copy of the GNU General Public License
  14 #  along with this program; if not, write to the Free Software
  15 #  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
  16
  17 # Stanislav Sinyagin <ssinyagin@yahoo.com>
  18
  19 # this policy complains about accessing private methods in Net::SNMP
  20 ## no critic (Variables::ProtectPrivateVars)
  21
  22 # this policy complains about regexp result untested, although it is tested
  23 ## no critic (RegularExpressions::ProhibitCaptureWithoutTest)
  24
  25 package Torrus::Collector::SNMP;
  26 use strict;
  27 use warnings;
  28
  29 use Torrus::Collector::SNMP_Params;
  30 use Torrus::ConfigTree;
  31 use Torrus::Log;
  32 use Torrus::SNMP_Failures;
  33
  34 use Net::hostent;
  35 use Socket;
  36 use Net::SNMP qw(:snmp);
  37 use Math::BigInt;
  38
  39 our $VERSION = 1.0;
  40
  41 # Register the collector type
  42 $Torrus::Collector::collectorTypes{'snmp'} = 1;
  43
  44
  45 # List of needed parameters and default values
  46
  47 $Torrus::Collector::params{'snmp'} = {
  48     'snmp-ipversion'    => undef,
  49     'snmp-transport'    => undef,
  50     'snmp-version'      => undef,
  51     'snmp-port'         => undef,
  52     'snmp-community'    => undef,
  53     'snmp-username'     => undef,
  54     'snmp-authkey'      => undef,
  55     'snmp-authpassword' => undef,
  56     'snmp-authprotocol' => 'md5',
  57     'snmp-privkey'      => undef,
  58     'snmp-privpassword' => undef,
  59     'snmp-privprotocol' => 'des',
  60     'snmp-timeout'      => undef,
  61     'snmp-retries'      => undef,
  62     'domain-name'       => undef,
  63     'snmp-host'         => undef,
  64     'snmp-localaddr'    => undef,
  65     'snmp-localport'    => undef,
  66     'snmp-object'       => undef,
  67     'snmp-oids-per-pdu' => undef,
  68     'snmp-object-type'  => 'OTHER',
  69     'snmp-check-sysuptime' => 'yes',
  70     'snmp-max-msg-size' => undef,
  71     'snmp-maxrepetitions' => 10,
  72     'snmp-ignore-mib-errors' => undef,
  73     };
  74
  75 my $sysUpTime = '1.3.6.1.2.1.1.3.0';
  76
  77 # Hosts that are running SNMPv1. We do not reresh maps on them, as
  78 # they are too slow
  79 my %snmpV1Hosts;
  80
  81 # SNMP tables lookup maps
  82 my %maps;
  83
  84 # Old lookup maps, used temporarily during refresh cycle
  85 my %oldMaps;
  86
  87 # How frequent we refresh the SNMP mapping
  88 our $mapsRefreshPeriod;
  89
  90 # Random factor in refresh period
  91 our $mapsRefreshRandom;
  92
  93 # Time period after configuration re-compile when we refresh existing mappings
  94 our $mapsUpdateInterval;
  95
  96 # how often we check for expired maps
  97 our $mapsExpireCheckPeriod;
  98
  99 # expiration time for each map
 100 my %mapsExpire;
 101
 102 # Lookups scheduled for execution
 103 my %mapLookupScheduled;
 104
 105 # SNMP session objects for map lookups
 106 my @mappingSessions;
 107
 108
 109 # Timestamps of hosts last found unreachable
 110 my %hostUnreachableSeen;
 111
 112 # Last time we tried to reach an unreachable host
 113 my %hostUnreachableRetry;
 114
 115 # Hosts that were deleted because of unreachability for too long
 116 my %unreachableHostDeleted;
 117
 118
 119 our $db_failures;
 120
 121 # Flush stats after a restart or recompile
 122 $Torrus::Collector::initCollectorGlobals{'snmp'} =
 123     \&Torrus::Collector::SNMP::initCollectorGlobals;
 124
 125 sub initCollectorGlobals
 126 {
 127     my $tree = shift;
 128     my $instance = shift;
 129
 130     if( not defined( $db_failures ) )
 131     {
 132         $db_failures =
 133             Torrus::SNMP_Failures->new( -Tree => $tree,
 134                                        -Instance => $instance,
 135                                        -WriteAccess => 1 );
 136     }
 137
 138     if( defined( $db_failures ) )
 139     {
 140         $db_failures->init();
 141     }
 142
 143     # re-init counters and collect garbage
 144     %oldMaps = ();
 145     %hostUnreachableSeen = ();
 146     %hostUnreachableRetry = ();
 147     %unreachableHostDeleted = ();
 148
 149     # Configuration re-compile was probably caused by new object instances
 150     # appearing on the monitored devices. Here we force the maps to refresh
 151     # soon enough in order to catch up with the changes
 152
 153     my $now = time();
 154     for my $maphash ( keys %mapsExpire )
 155     {
 156         $mapsExpire{$maphash} = int( $now + rand( $mapsUpdateInterval ) );
 157     }
 158     return;
 159 }
 160
 161
 162 # This is first executed per target
 163
 164 $Torrus::Collector::initTarget{'snmp'} = \&Torrus::Collector::SNMP::initTarget;
 165
 166
 167
 168 sub initTarget
 169 {
 170     my $collector = shift;
 171     my $token = shift;
 172
 173     my $tref = $collector->tokenData( $token );
 174
 175     $collector->registerDeleteCallback
 176         ( $token, \&Torrus::Collector::SNMP::deleteTarget );
 177
 178     my $hosthash = getHostHash( $collector, $token );
 179     if( not defined( $hosthash ) )
 180     {
 181         return 0;
 182     }
 183
 184     $tref->{'hosthash'} = $hosthash;
 185
 186     return Torrus::Collector::SNMP::initTargetAttributes( $collector, $token );
 187 }
 188
 189
 190 sub initTargetAttributes
 191 {
 192     my $collector = shift;
 193     my $token = shift;
 194
 195     &Torrus::DB::checkInterrupted();
 196
 197     my $tref = $collector->tokenData( $token );
 198     my $cref = $collector->collectorData( 'snmp' );
 199
 200     my $hosthash = $tref->{'hosthash'};
 201
 202     my $version = $collector->param($token, 'snmp-version');
 203     if( $version eq '1' )
 204     {
 205         $snmpV1Hosts{$hosthash} = 1;
 206     }
 207
 208     # If the object is defined as a map, retrieve the whole map
 209     # and cache it.
 210
 211     if( isHostDead( $collector, $hosthash ) )
 212     {
 213         return 0;
 214     }
 215
 216     if( not checkUnreachableRetry( $collector, $hosthash ) )
 217     {
 218         $cref->{'needsRemapping'}{$token} = 1;
 219         return 1;
 220     }
 221
 222     my $oid = $collector->param($token, 'snmp-object');
 223     $oid = expandOidMappings( $collector, $token, $hosthash, $oid );
 224
 225     if( not $oid )
 226     {
 227         if( $unreachableHostDeleted{$hosthash} )
 228         {
 229             # we tried our best, but the target is dead
 230             return 0;
 231         }
 232         else
 233         {
 234             # we return OK status, to let the storage initiate
 235             $cref->{'needsRemapping'}{$token} = 1;
 236             return 1;
 237         }
 238     }
 239     elsif( $oid eq 'notfound' )
 240     {
 241         return 0;
 242     }
 243
 244     # Collector should be able to find the target
 245     # by host, port, community, and oid.
 246     # There can be several targets with the same host|port|community+oid set.
 247
 248     $cref->{'targets'}{$hosthash}{$oid}{$token} = 1;
 249     $cref->{'activehosts'}{$hosthash} = 1;
 250
 251     $tref->{'oid'} = $oid;
 252
 253     $cref->{'oids_per_pdu'}{$hosthash} =
 254         $collector->param($token, 'snmp-oids-per-pdu');
 255
 256     if( $collector->paramString($token, 'snmp-object-type') eq 'COUNTER64' )
 257     {
 258         $cref->{'64bit_oid'}{$oid} = 1;
 259     }
 260
 261     if( $collector->paramDisabled($token, 'snmp-check-sysuptime') )
 262     {
 263         $cref->{'nosysuptime'}{$hosthash} = 1;
 264     }
 265
 266     if( $collector->paramEnabled($token, 'snmp-ignore-mib-errors') )
 267     {
 268         $cref->{'ignoremiberrors'}{$hosthash}{$oid} = 1;
 269     }
 270
 271     return 1;
 272 }
 273
 274
 275 sub getHostHash
 276 {
 277     my $collector = shift;
 278     my $token = shift;
 279
 280     my $hostname = $collector->param($token, 'snmp-host');
 281     my $domain = $collector->paramString($token, 'domain-name');
 282
 283     if( $domain ne '' and
 284         index($hostname, '.') < 0 and
 285         index($hostname, ':') < 0 )
 286     {
 287         $hostname .= '.' . $domain;
 288     }
 289
 290     my $port = $collector->param($token, 'snmp-port');
 291     my $version = $collector->param($token, 'snmp-version');
 292
 293     my $community;
 294     if( $version eq '1' or $version eq '2c' )
 295     {
 296         $community = $collector->param($token, 'snmp-community');
 297     }
 298     else
 299     {
 300         # We use community string to identify the agent.
 301         # For SNMPv3, it's the user name
 302         $community = $collector->param($token, 'snmp-username');
 303     }
 304
 305     return join('|', $hostname, $port, $community);
 306 }
 307
 308
 309 sub snmpSessionArgs
 310 {
 311     my $collector = shift;
 312     my $token = shift;
 313     my $hosthash = shift;
 314
 315     my $cref = $collector->collectorData( 'snmp' );
 316     if( defined( $cref->{'snmpargs'}{$hosthash} ) )
 317     {
 318         return $cref->{'snmpargs'}{$hosthash};
 319     }
 320
 321     my $transport = $collector->param($token, 'snmp-transport') . '/ipv' .
 322         $collector->param($token, 'snmp-ipversion');
 323
 324     my ($hostname, $port, $community) = split(/\|/o, $hosthash);
 325
 326     my $version = $collector->param($token, 'snmp-version');
 327     my $ret = [ -domain       => $transport,
 328                 -hostname     => $hostname,
 329                 -port         => $port,
 330                 -timeout      => $collector->param($token, 'snmp-timeout'),
 331                 -retries      => $collector->param($token, 'snmp-retries'),
 332                 -version      => $version ];
 333
 334     for my $arg ( qw(-localaddr -localport) )
 335     {
 336         my $val = $collector->param($token, 'snmp' . $arg);
 337         if( defined( $val ) )
 338         {
 339             push( @{$ret}, $arg, $val );
 340         }
 341     }
 342
 343     if( $version eq '1' or $version eq '2c' )
 344     {
 345         push( @{$ret}, '-community', $community );
 346     }
 347     else
 348     {
 349         push( @{$ret}, -username, $community);
 350
 351         for my $arg ( qw(-authkey -authpassword -authprotocol
 352                              -privkey -privpassword -privprotocol) )
 353         {
 354             my $val = $collector->param($token, 'snmp' . $arg);
 355             if( defined( $val ) )
 356             {
 357                 push( @{$ret}, $arg, $val );
 358             }
 359         }
 360     }
 361
 362     $cref->{'snmpargs'}{$hosthash} = $ret;
 363     return $ret;
 364 }
 365
 366
 367
 368 sub openBlockingSession
 369 {
 370     my $collector = shift;
 371     my $token = shift;
 372     my $hosthash = shift;
 373
 374     my $args = snmpSessionArgs( $collector, $token, $hosthash );
 375     my ($session, $error) =
 376         Net::SNMP->session( @{$args},
 377                             -nonblocking  => 0,
 378                             -translate    => ['-all', 0, '-octetstring', 1] );
 379     if( not defined($session) )
 380     {
 381         Error('Cannot create SNMP session for ' . $hosthash . ': ' . $error);
 382     }
 383     else
 384     {
 385         my $maxmsgsize = $collector->param($token, 'snmp-max-msg-size');
 386         if( defined( $maxmsgsize ) and $maxmsgsize > 0 )
 387         {
 388             $session->max_msg_size( $maxmsgsize );
 389         }
 390     }
 391
 392     return $session;
 393 }
 394
 395 sub openNonblockingSession
 396 {
 397     my $collector = shift;
 398     my $token = shift;
 399     my $hosthash = shift;
 400
 401     my $args = snmpSessionArgs( $collector, $token, $hosthash );
 402
 403     my ($session, $error) =
 404         Net::SNMP->session( @{$args},
 405                             -nonblocking  => 0x1,
 406                             -translate    => ['-timeticks' => 0] );
 407     if( not defined($session) )
 408     {
 409         Error('Cannot create SNMP session for ' . $hosthash . ': ' . $error);
 410         return
 411     }
 412
 413     if( $collector->param($token, 'snmp-transport') eq 'udp' )
 414     {
 415         # We set SO_RCVBUF only once, because Net::SNMP shares
 416         # one UDP socket for all sessions.
 417
 418         my $sock_name = $session->transport()->sock_name();
 419         my $refcount = $Net::SNMP::Transport::SOCKETS->{
 420             $sock_name}->[&Net::SNMP::Transport::_SHARED_REFC()];
 421
 422         if( defined($refcount) and $refcount == 1 )
 423         {
 424             my $buflen = int($Torrus::Collector::SNMP::RxBuffer);
 425             my $socket = $session->transport()->socket();
 426             my $ok = $socket->sockopt( SO_RCVBUF, $buflen );
 427             if( not $ok )
 428             {
 429                 Error('Could not set SO_RCVBUF to ' .
 430                       $buflen . ': ' . $!);
 431             }
 432             else
 433             {
 434                 Debug('Set SO_RCVBUF to ' . $buflen);
 435             }
 436         }
 437     }
 438
 439     my $maxmsgsize = $collector->param($token, 'snmp-max-msg-size');
 440     if( defined( $maxmsgsize ) and $maxmsgsize > 0 )
 441     {
 442         $session->max_msg_size( $maxmsgsize );
 443
 444     }
 445
 446     return $session;
 447 }
 448
 449
 450 sub expandOidMappings
 451 {
 452     my $collector = shift;
 453     my $token = shift;
 454     my $hosthash = shift;
 455     my $oid_in = shift;
 456
 457     my $cref = $collector->collectorData( 'snmp' );
 458
 459     my $oid = $oid_in;
 460
 461     # Process Map statements
 462
 463     while( index( $oid, 'M(' ) >= 0 )
 464     {
 465         if( not $oid =~ m/^(.*)M\(\s*([0-9\.]+)\s*,\s*([^\)]+)\)(.*)$/o )
 466         {
 467             Error("Error in OID mapping syntax: $oid");
 468             return
 469         }
 470
 471         my $head = $1;
 472         my $map = $2;
 473         my $key = $3;
 474         my $tail = $4;
 475
 476         # Remove trailing space from key
 477         $key =~ s/\s+$//o;
 478
 479         my $value =
 480             lookupMap( $collector, $token, $hosthash, $map, $key );
 481
 482         if( defined( $value ) )
 483         {
 484             if( $value eq 'notfound' )
 485             {
 486                 return 'notfound';
 487             }
 488             else
 489             {
 490                 $oid = $head . $value . $tail;
 491             }
 492         }
 493         else
 494         {
 495             return
 496         }
 497     }
 498
 499     # process value lookups
 500
 501     while( index( $oid, 'V(' ) >= 0 )
 502     {
 503         if( not $oid =~ /^(.*)V\(\s*([0-9\.]+)\s*\)(.*)$/o )
 504         {
 505             Error("Error in OID value lookup syntax: $oid");
 506             return
 507         }
 508
 509         my $head = $1;
 510         my $key = $2;
 511         my $tail = $4;
 512
 513         my $value;
 514
 515         if( not defined( $cref->{'value-lookups'}
 516                          {$hosthash}{$key} ) )
 517         {
 518             # Retrieve the OID value from host
 519
 520             my $session = openBlockingSession( $collector, $token, $hosthash );
 521             if( not defined($session) )
 522             {
 523                 return
 524             }
 525
 526             my $result = $session->get_request( -varbindlist => [$key] );
 527             $session->close();
 528             if( defined $result and defined($result->{$key}) )
 529             {
 530                 $value = $result->{$key};
 531                 $cref->{'value-lookups'}{$hosthash}{$key} = $value;
 532             }
 533             else
 534             {
 535                 Error("Error retrieving $key from $hosthash: " .
 536                       $session->error());
 537                 probablyDead( $collector, $hosthash );
 538                 return
 539             }
 540         }
 541         else
 542         {
 543             $value =
 544                 $cref->{'value-lookups'}{$hosthash}{$key};
 545         }
 546         if( defined( $value ) )
 547         {
 548             $oid = $head . $value . $tail;
 549         }
 550         else
 551         {
 552             return 'notfound';
 553         }
 554     }
 555
 556     # Debug('OID expanded: ' . $oid_in . ' -> ' . $oid');
 557     return $oid;
 558 }
 559
 560 # Look up table index in a map by value
 561
 562 sub lookupMap
 563 {
 564     my $collector = shift;
 565     my $token = shift;
 566     my $hosthash = shift;
 567     my $map = shift;
 568     my $key = shift;
 569
 570     my $cref = $collector->collectorData( 'snmp' );
 571     my $maphash = join('#', $hosthash, $map);
 572
 573     if( not defined( $maps{$hosthash}{$map} ) )
 574     {
 575         my $ret;
 576
 577         if( defined( $oldMaps{$hosthash}{$map} ) and
 578             defined( $key ) )
 579         {
 580             $ret = $oldMaps{$hosthash}{$map}{$key};
 581         }
 582
 583         if( $mapLookupScheduled{$maphash} )
 584         {
 585             return $ret;
 586         }
 587
 588         if( not $collector->didNotRun()
 589             and
 590             (scalar(@mappingSessions) >=
 591              $Torrus::Collector::SNMP::maxSessionsPerDispatcher) )
 592         {
 593             snmp_dispatcher();
 594             @mappingSessions = ();
 595             %mapLookupScheduled = ();
 596         }
 597
 598         # Retrieve map from host
 599         Debug('Retrieving map ' . $map . ' from ' . $hosthash);
 600
 601         my $session = openNonblockingSession( $collector, $token, $hosthash );
 602         if( not defined($session) )
 603         {
 604             return $ret;
 605         }
 606         else
 607         {
 608             push( @mappingSessions, $session );
 609         }
 610
 611         # Retrieve the map table
 612
 613         my $maxrepetitions = $collector->param($token, 'snmp-maxrepetitions');
 614         $session->get_table( -baseoid => $map,
 615                              -maxrepetitions => $maxrepetitions,
 616                              -callback => [\&mapLookupCallback,
 617                                            $collector, $hosthash, $map] );
 618
 619         $mapLookupScheduled{$maphash} = 1;
 620
 621         if( not $snmpV1Hosts{$hosthash} )
 622         {
 623             $mapsExpire{$maphash} =
 624                 int( time() + $mapsRefreshPeriod +
 625                      rand( $mapsRefreshPeriod * $mapsRefreshRandom ) );
 626         }
 627
 628         return $ret;
 629     }
 630
 631     if( defined( $key ) )
 632     {
 633         my $value = $maps{$hosthash}{$map}{$key};
 634         if( not defined $value )
 635         {
 636             Error("Cannot find value $key in map $map for $hosthash in ".
 637                   $collector->path($token));
 638             if( defined ( $maps{$hosthash}{$map} ) )
 639             {
 640                 Error('Current map follows');
 641                 while( my($mkey, $mval) = each
 642                        %{$maps{$hosthash}{$map}} )
 643                 {
 644                     Error("'$mkey' => '$mval'");
 645                 }
 646             }
 647             return 'notfound';
 648         }
 649         else
 650         {
 651             if( not $snmpV1Hosts{$hosthash} )
 652             {
 653                 $cref->{'mapsDependentTokens'}{$maphash}{$token} = 1;
 654                 $cref->{'mapsRelatedMaps'}{$token}{$maphash} = 1;
 655             }
 656
 657             return $value;
 658         }
 659     }
 660     else
 661     {
 662         return
 663     }
 664 }
 665
 666
 667 sub mapLookupCallback
 668 {
 669     my $session = shift;
 670     my $collector = shift;
 671     my $hosthash = shift;
 672     my $map = shift;
 673
 674     &Torrus::DB::checkInterrupted();
 675
 676     Debug('Received mapping PDU from ' . $hosthash);
 677
 678     my $result = $session->var_bind_list();
 679     if( defined $result )
 680     {
 681         my $preflen = length($map) + 1;
 682
 683         while( my( $oid, $key ) = each %{$result} )
 684         {
 685             my $val = substr($oid, $preflen);
 686             $maps{$hosthash}{$map}{$key} = $val;
 687             # Debug("Map $map discovered: '$key' -> '$val'");
 688         }
 689     }
 690     else
 691     {
 692         Error("Error retrieving table $map from $hosthash: " .
 693               $session->error());
 694         $session->close();
 695         probablyDead( $collector, $hosthash );
 696         return
 697     }
 698     return;
 699 }
 700
 701
 702 sub activeMappingSessions
 703 {
 704     return scalar( @mappingSessions );
 705 }
 706
 707 # The target host is unreachable. We try to reach it few more times and
 708 # give it the final diagnose.
 709
 710 sub probablyDead
 711 {
 712     my $collector = shift;
 713     my $hosthash = shift;
 714
 715     my $cref = $collector->collectorData( 'snmp' );
 716
 717     # Stop all collection for this host, until next initTargetAttributes
 718     # is successful
 719     delete $cref->{'activehosts'}{$hosthash};
 720
 721     my $probablyAlive = 1;
 722
 723     if( defined( $hostUnreachableSeen{$hosthash} ) )
 724     {
 725         if( $Torrus::Collector::SNMP::unreachableTimeout > 0 and
 726             time() -
 727             $hostUnreachableSeen{$hosthash} >
 728             $Torrus::Collector::SNMP::unreachableTimeout )
 729         {
 730             $probablyAlive = 0;
 731         }
 732     }
 733     else
 734     {
 735         $hostUnreachableSeen{$hosthash} = time();
 736
 737         if( defined( $db_failures ) )
 738         {
 739             $db_failures->host_failure('unreachable', $hosthash);
 740             $db_failures->set_counter('unreachable',
 741                                       scalar( keys %hostUnreachableSeen));
 742         }
 743     }
 744
 745     if( $probablyAlive )
 746     {
 747         Info('Target host is unreachable. Will try again later: ' . $hosthash);
 748     }
 749     else
 750     {
 751         # It is dead indeed. Delete all tokens associated with this host
 752         Info('Target host is unreachable during last ' .
 753              $Torrus::Collector::SNMP::unreachableTimeout .
 754              ' seconds. Giving it up: ' . $hosthash);
 755         my @deleteTargets = ();
 756         while( my ($oid, $ref1) =
 757                each %{$cref->{'targets'}{$hosthash}} )
 758         {
 759             while( my ($token, $dummy) = each %{$ref1} )
 760             {
 761                 push( @deleteTargets, $token );
 762             }
 763         }
 764
 765         Debug('Deleting ' . scalar( @deleteTargets ) . ' tokens');
 766         for my $token ( @deleteTargets )
 767         {
 768             $collector->deleteTarget($token);
 769         }
 770
 771         delete $hostUnreachableSeen{$hosthash};
 772         delete $hostUnreachableRetry{$hosthash};
 773         $unreachableHostDeleted{$hosthash} = 1;
 774
 775         if( defined( $db_failures ) )
 776         {
 777             $db_failures->host_failure('deleted', $hosthash);
 778             $db_failures->set_counter('unreachable',
 779                                       scalar( keys %hostUnreachableSeen));
 780             $db_failures->set_counter('deleted',
 781                                       scalar( keys %unreachableHostDeleted));
 782         }
 783     }
 784
 785     return $probablyAlive;
 786 }
 787
 788 # Return false if the try is too early
 789
 790 sub checkUnreachableRetry
 791 {
 792     my $collector = shift;
 793     my $hosthash = shift;
 794
 795     my $ret = 1;
 796     if( $hostUnreachableSeen{$hosthash} )
 797     {
 798         my $lastRetry = $hostUnreachableRetry{$hosthash};
 799
 800         if( not defined( $lastRetry ) )
 801         {
 802             $lastRetry = $hostUnreachableSeen{$hosthash};
 803         }
 804
 805         if( time() < $lastRetry +
 806             $Torrus::Collector::SNMP::unreachableRetryDelay )
 807         {
 808             $ret = 0;
 809         }
 810         else
 811         {
 812             $hostUnreachableRetry{$hosthash} = time();
 813         }
 814     }
 815
 816     return $ret;
 817 }
 818
 819
 820 sub isHostDead
 821 {
 822     my $collector = shift;
 823     my $hosthash = shift;
 824
 825     return $unreachableHostDeleted{$hosthash};
 826 }
 827
 828
 829 sub hostReachableAgain
 830 {
 831     my $collector = shift;
 832     my $hosthash = shift;
 833
 834     if( exists( $hostUnreachableSeen{$hosthash} ) )
 835     {
 836         delete $hostUnreachableSeen{$hosthash};
 837         if( defined( $db_failures ) )
 838         {
 839             $db_failures->remove_host($hosthash);
 840             $db_failures->set_counter('unreachable',
 841                                       scalar( keys %hostUnreachableSeen));
 842         }
 843     }
 844     return;
 845 }
 846
 847
 848 # Callback executed by Collector
 849
 850 sub deleteTarget
 851 {
 852     my $collector = shift;
 853     my $token = shift;
 854
 855     my $tref = $collector->tokenData( $token );
 856     my $cref = $collector->collectorData( 'snmp' );
 857
 858     my $hosthash = $tref->{'hosthash'};
 859     my $oid = $tref->{'oid'};
 860
 861     if( defined($oid) )
 862     {
 863         delete $cref->{'targets'}{$hosthash}{$oid}{$token};
 864         if( scalar(keys %{$cref->{'targets'}{$hosthash}{$oid}}) == 0 )
 865         {
 866             delete $cref->{'targets'}{$hosthash}{$oid};
 867
 868             if( scalar(keys %{$cref->{'targets'}{$hosthash}}) == 0 )
 869             {
 870                 delete $cref->{'targets'}{$hosthash};
 871             }
 872         }
 873     }
 874
 875     delete $cref->{'needsRemapping'}{$token};
 876
 877     for my $maphash ( keys %{$cref->{'mapsRelatedMaps'}{$token}} )
 878     {
 879         delete $cref->{'mapsDependentTokens'}{$maphash}{$token};
 880     }
 881     delete $cref->{'mapsRelatedMaps'}{$token};
 882     return;
 883 }
 884
 885 # Main collector cycle
 886
 887 $Torrus::Collector::runCollector{'snmp'} =
 888     \&Torrus::Collector::SNMP::runCollector;
 889
 890 sub runCollector
 891 {
 892     my $collector = shift;
 893     my $cref = shift;
 894
 895     # Info(sprintf('runCollector() Offset: %d, active hosts: %d, maps: %d',
 896     #              $collector->offset(),
 897     #              scalar( keys %{$cref->{'activehosts'}} ),
 898     #              scalar(keys %maps)));
 899
 900     # Create one SNMP session per host address.
 901     # We assume that version, timeout and retries are the same
 902     # within one address
 903
 904     # We limit the number of sessions per snmp_dispatcher run
 905     # because of some strange bugs: with more than 400 sessions per
 906     # dispatcher, some requests are not sent out
 907
 908     my @hosts = keys %{$cref->{'activehosts'}};
 909
 910     while( scalar(@mappingSessions) + scalar(@hosts) > 0 )
 911     {
 912         my @batch = ();
 913         while( ( scalar(@mappingSessions) + scalar(@batch) <
 914                  $Torrus::Collector::SNMP::maxSessionsPerDispatcher )
 915                and
 916                scalar(@hosts) > 0 )
 917         {
 918             push( @batch, pop( @hosts ) );
 919         }
 920
 921         &Torrus::DB::checkInterrupted();
 922
 923         my @sessions;
 924
 925         for my $hosthash ( @batch )
 926         {
 927             my @oids = sort keys %{$cref->{'targets'}{$hosthash}};
 928
 929             # Info(sprintf('Host %s: %d OIDs',
 930             #              $hosthash,
 931             #              scalar(@oids)));
 932
 933             # Find one representative token for the host
 934
 935             if( scalar( @oids ) == 0 )
 936             {
 937                 next;
 938             }
 939
 940             my @reptokens = keys %{$cref->{'targets'}{$hosthash}{$oids[0]}};
 941             if( scalar( @reptokens ) == 0 )
 942             {
 943                 next;
 944             }
 945             my $reptoken = $reptokens[0];
 946
 947             my $session =
 948                 openNonblockingSession( $collector, $reptoken, $hosthash );
 949
 950             &Torrus::DB::checkInterrupted();
 951
 952             if( not defined($session) )
 953             {
 954                 next;
 955             }
 956             else
 957             {
 958                 Debug('Created SNMP session for ' . $hosthash);
 959                 push( @sessions, $session );
 960             }
 961
 962             my $oids_per_pdu = $cref->{'oids_per_pdu'}{$hosthash};
 963
 964             my @pdu_oids = ();
 965             my $delay = 0;
 966
 967             while( scalar( @oids ) > 0 )
 968             {
 969                 my $oid = shift @oids;
 970                 push( @pdu_oids, $oid );
 971
 972                 if( scalar( @oids ) == 0 or
 973                     ( scalar( @pdu_oids ) >= $oids_per_pdu ) )
 974                 {
 975                     if( not $cref->{'nosysuptime'}{$hosthash} )
 976                     {
 977                         # We insert sysUpTime into every PDU, because
 978                         # we need it in further processing
 979                         push( @pdu_oids, $sysUpTime );
 980                     }
 981
 982                     if( Torrus::Log::isDebug() )
 983                     {
 984                         Debug('Sending SNMP PDU to ' . $hosthash . ':');
 985                         for my $oid ( @pdu_oids )
 986                         {
 987                             Debug($oid);
 988                         }
 989                     }
 990
 991                     # Generate the list of tokens that form this PDU
 992                     my $pdu_tokens = {};
 993                     for my $oid ( @pdu_oids )
 994                     {
 995                         if( defined( $cref->{'targets'}{$hosthash}{$oid} ) )
 996                         {
 997                             for my $token
 998                                 ( keys %{$cref->{'targets'}{$hosthash}{$oid}} )
 999                             {
1000                                 $pdu_tokens->{$oid}{$token} = 1;
1001                             }
1002                         }
1003                     }
1004                     my $result =
1005                         $session->
1006                         get_request( -delay => $delay,
1007                                      -callback =>
1008                                      [ \&Torrus::Collector::SNMP::callback,
1009                                        $collector, $pdu_tokens, $hosthash ],
1010                                      -varbindlist => \@pdu_oids );
1011                     if( not defined $result )
1012                     {
1013                         Error('Cannot create SNMP request: ' .
1014                               $session->error);
1015                     }
1016                     @pdu_oids = ();
1017                     $delay += 0.01;
1018                 }
1019             }
1020         }
1021
1022         &Torrus::DB::checkInterrupted();
1023
1024         snmp_dispatcher();
1025
1026         # Check if there were pending map lookup sessions
1027
1028         if( scalar( @mappingSessions ) > 0 )
1029         {
1030             @mappingSessions = ();
1031             %mapLookupScheduled = ();
1032         }
1033     }
1034     return;
1035 }
1036
1037
1038 sub callback
1039 {
1040     my $session = shift;
1041     my $collector = shift;
1042     my $pdu_tokens = shift;
1043     my $hosthash = shift;
1044
1045     &Torrus::DB::checkInterrupted();
1046
1047     my $cref = $collector->collectorData( 'snmp' );
1048
1049     Debug('SNMP Callback executed for ' . $hosthash);
1050
1051     if( not defined( $session->var_bind_list() ) )
1052     {
1053         Error('SNMP Error for ' . $hosthash . ': ' . $session->error() .
1054               ' when retrieving ' . join(' ', sort keys %{$pdu_tokens}));
1055
1056         probablyDead( $collector, $hosthash );
1057
1058         # Clear the mapping
1059         delete $maps{$hosthash};
1060         for my $oid ( keys %{$pdu_tokens} )
1061         {
1062             for my $token ( keys %{$pdu_tokens->{$oid}} )
1063             {
1064                 $cref->{'needsRemapping'}{$token} = 1;
1065             }
1066         }
1067         return;
1068     }
1069     else
1070     {
1071         hostReachableAgain( $collector, $hosthash );
1072     }
1073
1074     my $timestamp = time();
1075
1076     my $checkUptime = not $cref->{'nosysuptime'}{$hosthash};
1077     my $doSetValue = 1;
1078
1079     my $uptime = 0;
1080
1081     if( $checkUptime )
1082     {
1083         my $uptimeTicks = $session->var_bind_list()->{$sysUpTime};
1084         if( defined $uptimeTicks )
1085         {
1086             $uptime = $uptimeTicks / 100;
1087             Debug('Uptime: ' . $uptime);
1088         }
1089         else
1090         {
1091             Error('Did not receive sysUpTime for ' . $hosthash);
1092         }
1093
1094         if( $uptime < $collector->period() or
1095             ( defined($cref->{'knownUptime'}{$hosthash})
1096               and
1097               $uptime + $collector->period() <
1098               $cref->{'knownUptime'}{$hosthash} ) )
1099         {
1100             # The agent has reloaded. Clean all maps and push UNDEF
1101             # values to the storage
1102
1103             Info('Agent rebooted: ' . $hosthash);
1104             delete $maps{$hosthash};
1105
1106             $timestamp -= $uptime;
1107             for my $oid ( keys %{$pdu_tokens} )
1108             {
1109                 for my $token ( keys %{$pdu_tokens->{$oid}} )
1110                 {
1111                     $collector->setValue( $token, 'U', $timestamp, $uptime );
1112                     $cref->{'needsRemapping'}{$token} = 1;
1113                 }
1114             }
1115
1116             $doSetValue = 0;
1117         }
1118         $cref->{'knownUptime'}{$hosthash} = $uptime;
1119     }
1120
1121     if( $doSetValue )
1122     {
1123         while( my ($oid, $value) = each %{ $session->var_bind_list() } )
1124         {
1125             # Debug("OID=$oid, VAL=$value");
1126             if( $value eq 'noSuchObject' or
1127                 $value eq 'noSuchInstance' or
1128                 $value eq 'endOfMibView' )
1129             {
1130                 if( not $cref->{'ignoremiberrors'}{$hosthash}{$oid} )
1131                 {
1132                     Error("Error retrieving $oid from $hosthash: $value");
1133
1134                     for my $token ( keys %{$pdu_tokens->{$oid}} )
1135                     {
1136                         if( defined( $db_failures ) )
1137                         {
1138                             $db_failures->mib_error
1139                                 ($hosthash, $collector->path($token));
1140                         }
1141
1142                         $collector->deleteTarget($token);
1143                     }
1144                 }
1145             }
1146             else
1147             {
1148                 if( $cref->{'64bit_oid'}{$oid} )
1149                 {
1150                     $value = Math::BigInt->new($value);
1151                 }
1152
1153                 for my $token ( keys %{$pdu_tokens->{$oid}} )
1154                 {
1155                     $collector->setValue( $token, $value,
1156                                           $timestamp, $uptime );
1157                 }
1158             }
1159         }
1160     }
1161     return;
1162 }
1163
1164
1165 # Execute this after the collector has finished
1166
1167 $Torrus::Collector::postProcess{'snmp'} =
1168     \&Torrus::Collector::SNMP::postProcess;
1169
1170 sub postProcess
1171 {
1172     my $collector = shift;
1173     my $cref = shift;
1174
1175     # It could happen that postProcess is called for a collector which
1176     # has no targets, and therefore it's the only place where we can
1177     # initialize these variables
1178
1179     if( not defined( $cref->{'mapsLastExpireChecked'} ) )
1180     {
1181         $cref->{'mapsLastExpireChecked'} = 0;
1182     }
1183
1184     if( not defined( $cref->{'mapsRefreshed'} ) )
1185     {
1186         $cref->{'mapsRefreshed'} = [];
1187     }
1188
1189     # look if some maps are ready after last expiration check
1190     if( scalar( @{$cref->{'mapsRefreshed'}} ) > 0 )
1191     {
1192         for my $maphash ( @{$cref->{'mapsRefreshed'}} )
1193         {
1194             for my $token
1195                 ( keys %{$cref->{'mapsDependentTokens'}{$maphash}} )
1196             {
1197                 $cref->{'needsRemapping'}{$token} = 1;
1198             }
1199         }
1200         $cref->{'mapsRefreshed'} = [];
1201     }
1202
1203     my $now = time();
1204
1205     if( $cref->{'mapsLastExpireChecked'} + $mapsExpireCheckPeriod <= $now )
1206     {
1207         $cref->{'mapsLastExpireChecked'} = $now;
1208
1209         # Check the maps expiration and arrange lookup for expired
1210
1211         while( my ( $maphash, $expire ) = each %mapsExpire )
1212         {
1213             if( $expire <= $now and not $mapLookupScheduled{$maphash} )
1214             {
1215                 &Torrus::DB::checkInterrupted();
1216
1217                 my ( $hosthash, $map ) = split( /\#/o, $maphash );
1218
1219                 if( $unreachableHostDeleted{$hosthash} )
1220                 {
1221                     # This host is no longer polled. Remove the leftovers
1222
1223                     delete $mapsExpire{$maphash};
1224                     delete $maps{$hosthash};
1225                 }
1226                 else
1227                 {
1228                     # Find one representative token for the map
1229                     my @tokens =
1230                         keys %{$cref->{'mapsDependentTokens'}{$maphash}};
1231                     if( scalar( @tokens ) == 0 )
1232                     {
1233                         next;
1234                     }
1235                     my $reptoken = $tokens[0];
1236
1237                     # save the map for the time of refresh
1238                     $oldMaps{$hosthash}{$map} = $maps{$hosthash}{$map};
1239                     delete $maps{$hosthash}{$map};
1240
1241                     # this will schedule the map retrieval for the next
1242                     # collector cycle
1243                     Debug('Refreshing map: ' . $maphash);
1244
1245                     lookupMap( $collector, $reptoken,
1246                                $hosthash, $map, undef );
1247
1248                     # After the next collector period, the maps will be
1249                     # ready and tokens may be updated without losing the data
1250                     push( @{$cref->{'mapsRefreshed'}}, $maphash );
1251                 }
1252             }
1253         }
1254     }
1255
1256     for my $token ( keys %{$cref->{'needsRemapping'}} )
1257     {
1258         &Torrus::DB::checkInterrupted();
1259
1260         delete $cref->{'needsRemapping'}{$token};
1261         if( not Torrus::Collector::SNMP::initTargetAttributes
1262             ( $collector, $token ) )
1263         {
1264             $collector->deleteTarget($token);
1265         }
1266     }
1267     return;
1268 }
1269
1270
1271 ####  ====  SNMP Reachability Collector ====
1272
1273 # Register the collector type (it should always run after snmp collector)
1274 $Torrus::Collector::collectorTypes{'snmp-reachable'} = 2;
1275
1276
1277 # List of needed parameters and default values
1278
1279 $Torrus::Collector::params{'snmp-reachable'} = {
1280     'snmp-version'      => undef,
1281     'snmp-port'         => undef,
1282     'snmp-community'    => undef,
1283     'snmp-username'     => undef,
1284     'domain-name'       => undef,
1285     'snmp-host'         => undef,
1286 };
1287
1288
1289 # This is first executed per target
1290
1291 $Torrus::Collector::initTarget{'snmp-reachable'} = \&reachable_initTarget;
1292
1293
1294 sub reachable_initTarget
1295 {
1296     my $collector = shift;
1297     my $token = shift;
1298
1299     my $cref = $collector->collectorData('snmp-reachable');
1300     my $tref = $collector->tokenData( $token );
1301     my $hosthash = getHostHash( $collector, $token );
1302     if( not defined( $hosthash ) )
1303     {
1304         return 0;
1305     }
1306
1307     $tref->{'hosthash'} = $hosthash;
1308     $cref->{'targets'}{$hosthash}{$token} = 1;
1309
1310     return 1;
1311 }
1312
1313
1314 # Main collector cycle
1315
1316 $Torrus::Collector::runCollector{'snmp-reachable'} = \&reachable_runCollector;
1317
1318 sub reachable_runCollector
1319 {
1320     my $collector = shift;
1321     my $cref = shift;
1322
1323     if( not defined( $db_failures ) )
1324     {
1325         Error('$db_failures is not initialized. ' .
1326               'snmp-reachable collector cannot continue');
1327         return;
1328     }
1329
1330     my $timestamp = time();
1331
1332     while(my ($hosthash, $r) = each %{$cref->{'targets'}} )
1333     {
1334         for my $token (keys %{$r})
1335         {
1336             my $val = $db_failures->is_host_available($hosthash) ? 100:0;
1337             $collector->setValue( $token, $val, $timestamp, 0 );
1338         }
1339     }
1340     return;
1341 }
1342
1343
1344 1;
1345
1346
1347 # Local Variables:
1348 # mode: perl
1349 # indent-tabs-mode: nil
1350 # perl-indent-level: 4
1351 # End: