modules/Base.pm

   1 package Guardian::Base;
   2 use strict;
   3 use warnings;
   4
   5 use Exporter qw(import);
   6
   7 our @EXPORT_OK = qw(GenerateMonitoredFiles FilePositions);
   8
   9 #
  10 ## Function for fileposition initialization.
  11 #
  12 ## This function is used to get the cursor position of the end of file (EOF) of
  13 ## a specified file.
  14 #
  15 ## In order to prevent from permanently read and keep files opened, or dealing
  16 ## with huge logfiles, at initialization time of the worker processes, the file will
  17 ## be opened once and the cursor position of the end of file (EOF) get stored.
  18 #
  19 sub InitFileposition ($) {
  20         my $file = $_[0];
  21
  22         # Open the file.
  23         open(FILE, $file) or die "Could not open $file. $!";
  24
  25         # Just seek to the end of the file (EOF).
  26         seek(FILE, 0, 2);
  27
  28         # Get and store the position.
  29         my $position = tell(FILE),
  30
  31         # Close the file again.
  32         close(FILE);
  33
  34         # Return the position.
  35         return $position;
  36 }
  37
  38 #
  39 ## Function to generate a hash of monitored files and their file positions.
  40 #
  41 ## This function is responsible for creating the hash of which files should be
  42 ## monitored by guardian. In order to do this, all options from the given hash of
  43 ## main settings will be parsed and all files to monitor and their configured parsers
  44 ## get extracted, validated and stored into a temporary hash.
  45 #
  46 ## Next step will be to cleanup files which have been monitored in the past but have been
  47 ## requested for beeing unmonitored for now. To do this, a check if the the file name is
  48 ## part of the existing hash of monitored files and if true to transfer the data into the
  49 ## new temporary hash which get returned by the function.
  50 #
  51 sub GenerateMonitoredFiles (\%\%) {
  52         # Dereference the given hash-refs and store
  53         # them into a new temporary hashes.
  54         my %mainsettings = %{ $_[0] };
  55         my %current_monitored_files = %{ $_[1] };
  56
  57         # Private hash for storing the new monitored files.
  58         my %new_monitored_files = ();
  59
  60         # Loop through the temporary hash which contains the main settings.
  61         # Search for files which should be monitored and extract the requested
  62         # parser. Compare if the file already was a part of the hash which contains
  63         # the monitored files and add them to the private new hash of monitored
  64         # files which will be returned.
  65         foreach my $config_option (keys %mainsettings) {
  66                 # Skip option if it does not look like "Monitor_XYZ".
  67                 next unless($config_option =~ m/^Monitor_/);
  68
  69                 # Splitt monitor instruction into 2 parts, to grab the
  70                 # requested parser module.
  71                 my ($start, $parser) = split (/_/, $config_option);
  72
  73                 # Convert parser name into lower case format.
  74                 # Internally the parser module name is completely handled
  75                 # in this way. This also prevents from any problems related
  76                 # how the parser name has been spelled in the config file.
  77                 $parser = lc($parser);
  78
  79                 # Check if the configured parser is available and valid.
  80                 next unless(&Guardian::Parser::IsSupportedParser($parser));
  81
  82                 # Get the configured file for this option.
  83                 my $file = $mainsettings{$config_option};
  84
  85                 # Skip the file, if it does not exist or is not read-able.
  86                 next unless(-r "$file");
  87
  88                 # Check if the file not yet has been added to the hash
  89                 # of monitored files.
  90                 unless(exists($current_monitored_files{$file})) {
  91                         # Add the file, init and store the fileposition.
  92                         $new_monitored_files{$file} = $parser;
  93                 } else {
  94                         # Copy file and parser information to the new hash.
  95                         $new_monitored_files{$file} = $current_monitored_files{$file};
  96                 }
  97         }
  98
  99         # Return the new_monitored_files hash.
 100         return %new_monitored_files;
 101 }
 102
 103 #
 104 ## The FilePositions function.
 105 #
 106 ## This function is responsible for creating and/or updating the hash which
 107 ## stores the current cursor position of the end of file (EOF) of all
 108 ## monitored files.
 109 #
 110 ## The function requires the hash of currently monitored files and the old hash
 111 ## of the current file positions in order to work properly.
 112 #
 113 sub FilePositions (\%\%) {
 114         # Dereference the given hash-refs and store
 115         # them into a new temporary hashes.
 116         my %monitored_files = %{ $_[0] };
 117         my %current_file_positions = %{ $_[1] };
 118
 119         # Private hash for storing the new monitored files.
 120         my %new_file_positions = ();
 121
 122         # Loop through the hash of monitored files.
 123         # Compare if the file allready has been a part of the hash
 124         # which contains the file positions and transfer the stored
 125         # cursor position into the temporary hash which will be returned.
 126         #
 127         # Otherwise, call the responsible function to obtain the current
 128         # end of file (EOF) and store it.
 129         foreach my $file (keys %monitored_files) {
 130                 # Check if the filename is allready part of the hash
 131                 # of file positions.
 132                 if (exists($current_file_positions{$file})) {
 133                         # Copy file position into temporary hash.
 134                         $new_file_positions{$file} = $current_file_positions{$file};
 135                 } else {
 136                         # Call function to obtain the file position.
 137                         my $position = &InitFileposition($file);
 138
 139                         # Add filename and position to the temporary hash.
 140                         $new_file_positions{$file} = $position;
 141                 }
 142         }
 143
 144         # Return the new_file_positions hash.
 145         return %new_file_positions;
 146 }
 147
 148 1;