use List::Compare;

my @required_patches= qw(patch numbers that are required);
my @current_machine_patches= ....;

my $lc =  List::Compare->new(
  {lists => [\@required_patches, \@current_machine_patches],
        accelerated => 1,
        unsorted => 1
  });

my @missing_patches = $lc->get_Lonly;
[download]

Look in perlfaq4 for "How do I compute the difference of two arrays?".

open( P, "<", "Two.txt" ) or die "Two.txt: $!";
my @patches = sort <P>;
chomp @patches;
close P;

my %patch_id;
my $seq_num = 0;
$patch_id{$_} = $seq_num++ for ( @patches );
[download]

my %comp_patch;  # will be a hash of arrays
my $comp_name;   # will store most recently seen computer name

open( C, "<", "One.log" ) or die "One.log: $!";
while (<C>) {
    chomp;
    if ( /^KB\d+/ ) { # this is a patch name
        if ( not exists( $patch_id{$_} )) {
            warn "Computer $comp_name has unknown patch: $_\n";
            next;  # (might want to do something else here)
        }
        $comp_patch{$comp_name}[$patch_id{$_}] = $_;
    }
    elsif ( /^\S+/ ) { # not a patch name, must be a computer name
        $comp_name = $_;
    }
}
[download]

for my $cname ( sort keys %comp_patch ) {
    for my $pnum ( 0 .. $#patches ) {
        print "$cname lacks $patches[$pnum]\n"
            unless ( defined( $comp_patch{$cname}[$pnum] ));
    }
}
[download]

• Create a HOH, with the first level keys being your computer names, and the second level keys being the patches installed on each computer.
• Assign the list of required patches to an array.
• Then iterate through the array using a for loop, and within that check whether the current element exists as a secondary key within your hash for each computer.

I hope that makes sense. Here is some code to demonstrate:

#!/usr/bin/perl -w
use strict;

my %computers;
my $computer;

my @required_patches = qw(
        KB893756
        KB893803
        KB896422
        KB896423
        KB899588
        KB899591
        KB911927
        KB921883
        );

while (my $line = <DATA>) {
    chomp($line);
    if ($line =~ /^KB\d{6}/) {
        $computers{$computer}{$line}++;
    }
    else {
        $computer = $line;
    }
}

for my $patch (@required_patches) {
    for my $computer (keys %computers) {
        if (!exists $computers{$computer}{$patch}) {
            print "$computer is missing patch $patch\n";
        }
    }
}

__DATA__
Computer1
KB893756
KB896422
KB896423
KB899588
KB899591
KB921883
Computer2
KB893756
KB896422
KB896423
KB899591
KB917159
KB921883
Computer3
KB893756
KB896422
KB899588
KB899591
KB917159
KB921883
[download]

Computer3 is missing patch KB893803
Computer2 is missing patch KB893803
Computer1 is missing patch KB893803
Computer3 is missing patch KB896423
Computer2 is missing patch KB899588
Computer3 is missing patch KB911927
Computer2 is missing patch KB911927
Computer1 is missing patch KB911927
[download]

Cheers,
Darren :)

So I get my Computer information from a script I have created that gets the information and parses through another file to get the list I gave you guys (of course it is only a snipet of my list because I thought putting 150+ computers worth of data was a bit much).

In your code, you have the line, while (my $line = <DATA>) {

The <DATA> would that be me openining the file using a statement beforehand that looks as such?



open (DATA, "One.txt") or die "One.txt: $!";

while (my $line = <DATA>) {
    chomp($line);
    if ($line =~ /^KB\d{6}/) {
        $computers{$computer}{$line}++;
    }
    else {
        $computer = $line;
    }
}
[download]

I have it and it works now. The end rsult is an excel sheet that outputs the information in alphabetical order. SWEET!

Though I still want to learn more so I am trying the rest of the suggestions here. Have to see what i can and cannot understand.

1. Assign IDs to the machines by increasing powers of 2 (machine1 =>1; machine2=>2; machine3=>4;etc)
2. Build a hash keyed by the patch-id, whose value is the sum of the machine-ids who have that patch applied. (for example -- $patchs{$patch_id} += $machine_id;)
3. Sort the hash by value, in descending order, and display in the medium of your choice.
4. The patches at the top of the list are on more machines that those lower down.
5. Sum the machine-id's you assigned in step one (S = 1 + 2 + 4 + ... +2^^n).
6. For each patch-id in the hash whose value is less than S, there is a unique combination of powers of 2 the add up to the difference. Those machines do not have this patch.
7. Apply the patches
8. Repeat this process until there are no patches left to apply. (This is to account for the case which __never__ happens in real life -- PatchA requires Patches B through F, and PatchC wasn't on your original list...)

This is not going to be a simple process; and if you have a lot of machines, it will be basically a non-starter. In that case, I throw up my hands, build me a "golden machine" with all of the patches applied and then clone its system disk to all the other machines. Come to think of it, that might be the best policy from the git-go.

Good Luck & Good Hunting

@ Gray Bear

Oh how I wish it could be that easy. Our problem is that we have over 150 machines that need to be checked and while we have images for each type of system (oh ya we have 4 different computer types that are used so that means 4 different images), we have a problem when a system goes down and we have patched but not taken an image yet that things start to get convoluted.

So the best way i see right now is a system such as this where I check each system against a list and see what systems need what patch.

A solution that doesn't use the second file, but builds the property table while reading the first file. This assumes that all required properties are present somewhere in the first file.

use strict;
use warnings;

my %properties;
my @computers;

while (<DATA>) {
    chomp;
    next if ! length;
    
    push @computers, $_;
    
    while (<DATA>) {
        chomp;
        last if ! length;
        push @{$properties{$_}}, $computers[-1];
    }
}

for my $computer (@computers) {
    my @missing = grep {! grep {$_ eq $computer} @{$properties{$_}}} k
+eys %properties;
    
    $computer = [$computer, [@missing]];
}

print join "\n", map {"$_->[0]: @{$_->[1]}"} @computers;

__DATA__
Computer1
KB893756
KB896423
KB899588
KB899591
KB921883

Computer2
KB893756
KB896422
KB896423
KB899591
KB917159
KB921883

Computer3
KB893756
KB896422
KB899588
KB899591
KB917159
KB921883
[download]

Prints:

Computer1: KB896422 KB917159
Computer2: KB899588
Computer3: KB896423
[download]

Note: computer one's data was edited slightly from OP's data so that it misses two properties.

Hm, I'd simply store the patch list in a hash and check on the fly.

#!/usr/bin/perl
use strict; use warnings;

my $patchlist_file = shift @ARGV;
my %patchlist;

# read patchlist 
open my $PATCHLIST, '<', $patchlist_file 
  or die "Can't read $patchlist_file: $!";
while (<$PATCHLIST>) {
   s/^\s+|\s+$//sg; #trim head/tail whitespace incl. newline
   $patchlist{$_} = 1;
}
close $PATCHLIST;

#now check files against the patchlist
foreach my $file (@ARGV) {
   open my $FILE, '<', $file or do {
      warn "Unable to read $file: $!";
      next;
   };

   local $/ = "\n\n";  #records separated by double-newline

   while (<$FILE>) {
      my ($computer, @patches) = split("\n", $_, 2);
      my %patch = map { $_ => 1 } @patches;
      my @missing;
      
      # see if each patch is there
      for (keys %patchlist) { push @missing, $_ unless $patch{$_} }
      
      # report
      printf '%s is missing %d patches.', $computer, scalar @missing;
      print (scalar @missing ? ' They are: '.join(',',@missing) : ''),
+"\n";
   }

   close $FILE;
}
[download]