{Ninja-Shell}

Filename: //proc/self//root///proc/self/root/bin/ucfq

#!/usr/bin/perl
#                              -*- Mode: Cperl -*-
# ucfq ---
# Author           : Manoj Srivastava ( srivasta@glaurung.internal.golden-gryphon.com )
# Created On       : Wed Apr 12 14:51:16 2006
# Created On Node  : glaurung.internal.golden-gryphon.com
# Last Modified By : Manoj Srivastava
# Last Modified On : Fri Apr 14 19:30:45 2006
# Last Machine Used: glaurung.internal.golden-gryphon.com
# Update Count     : 81
# Status           : Unknown, Use with caution!
# HISTORY          :
# Description      :
#
# arch-tag: 1390e09f-ee31-4d7f-a968-bd539ea061a0
#
=head1 NAME

ucfq - query ucf registry and hashfile about configuration file details.

=cut

use strict;

package ucf;

use strict;
use Getopt::Long;

# set the version and revision
($main::MYNAME     = $main::0) =~ s|.*/||;
$main::Author      = "Manoj Srivastava";
$main::AuthorMail  = "srivasta\@debian.org";

=head1 SYNOPSIS

usage: ucfq [options] (file|package)[file|package  ...]

=cut

{  # scope for ultra-private meta-object for class attributes

my %Ucf =
    (
     Optdesc  =>
     {
      'help|h'         => sub {print ucf->Usage();     exit 0;},
      'with-colons|w!' => sub {$::ConfOpts{"Colons"}= "$_[1]";},
      'state-dir=s'    => sub {$::ConfOpts{"StateDir"}= "$_[1]";},
      'debug|d'        => sub {$::ConfOpts{"DEBUG"}+= "$_[1]";},
      'verbose|v'      => sub {$::ConfOpts{"VERBOSE"}+= "$_[1]";}
     },
     Usage => qq(Usage: $main::MYNAME [options]
Author: $main::Author <$main::AuthorMail>
  where options are:
 --help                This message.
 --debug               Turn on debugging mode.
 --verbose             Make the script more verbose.
 --with-colons         A compact, machine readable version of the output.
 --state-dir </path/>  Set the state directory to /path/ instead of the
                       default /var/lib/ucf.

),
     Defaults =>
     {
      "Colons"   => 0,
      "DEBUG"    => 0,
      "VERBOSE"  => 0,
      "StateDir" => '/var/lib/ucf'
     }
    );
  # tri-natured: function, class method, or object method
  sub _classobj {
    my $obclass = shift || __PACKAGE__;
    my $class   = ref($obclass) || $obclass;
    no strict "refs";   # to convert sym ref to real one
    return \%$class;
  }

for my $datum (keys %Ucf ) {
    no strict "refs";
    *$datum = sub {
      use strict "refs";
      my ($self, $newvalue) = @_;
      $Ucf{$datum} = $newvalue if @_ > 1;
      return $Ucf{$datum};
    }
  }
}

=head1 OPTIONS

=over 3

=item B<--help> B<h> Print out a usage message.

=item B<--debug> B<-d> Turn on debugging mode.

=item B<--verbose> B<-v> Make the script more verbose..

=item B<--with-colons> B<-w>

=over 2

Normally, the script presents the information in a human readable
tabular format, but that may be harder for a machine to parse. With
this option, the output is a compact, colon separated line, with no
dividers, headers, or footer.

=back

=item B<--state-dr> dir

=over 2

Set the state directory to C</path/to/dir> instead of the default
C</var/lib/ucf>.  Used mostly for testing.

=back

=cut

=head1 DESCRIPTION

This script takes a set of arguments, each of which is a package or a
path to a configuration file, and outputs the associated package, if
any, if the file exists on disk, and whether it has been modfied by te
user.  The output is either a human readable tabular form, or a
compact colon-separated machine friendly format.

This script can potentially be used in package C<postinst> scripts
during purge to query the system for configuration files that may
still exist on the system, and whether these files have been locally
modified by the user -- assuming that the package registered all the
configuration files with B<ucf> using C<ucfr>.

=cut

=head1 INTERNALS

=head2 Class Methods

All class methods mediate access to class variables.  All class
methods can be invoked with zero or one parameters. When invoked with
the optional parameter, the class method sets the value of the
underlying class data.  In either case, the value of the underlying
variable is returned.

=cut

=head1 Class ucf

This is a combination view and controller class that mediates between
the user and the internal model classes.

=head2 new

This is the constructor for the class. It takes a number of optional
parameters. If the parameter B<Colons> is present, then the output
will be compact. The parameters B<DEBUG> and B<VERBOSE> turn on
additional diagnostics from the script.

=cut

sub new {
  my $this = shift;
  my %params = @_;
  my $class = ref($this) || $this;
  my $self = {};

bless $self => $class;

# validate and sanitize the settings
  $self->validate(%params);

return $self;
}

=head2 validate

This routine is responsible for ensuring that the parameters passed in
(presumably from the command line) are given preference.

=cut

sub validate{
  my $this     = shift;
  my %params   = @_;
  my $defaults = $this->Defaults();

# Make sure runtime options override what we get from the config file
  for my $option (keys %params) {
    $this->{Con_Ref}->{"$option"} = $params{"$option"};
  }

# Ensure that if default parameters have not been set on the comman
  # line on in the configuration file, if any, we use the built in
  # defaults.
  for my $default (keys %$defaults) {
    if (! defined $this->{Con_Ref}->{"$default"}) {
      $this->{Con_Ref}->{"$default"} = $defaults->{"$default"};
    }
  }
}

=head2 get_config_ref

This routine returns a reference to the configuration hash

=cut

sub get_config_ref {

my $this     = shift;
  return $this->{Con_Ref};
}

=head2 dump_config

This routine returns a C<Data::Dumper> for debugging purposes

=cut

sub dump_config {
  my $this     = shift;
  for (keys %{$this->{Con_Ref}}) {
    print  "$_ = [${$this->{Con_Ref}}{$_}]\n"
  }
}

=head2 process

This routine is the work horse routine -- it parses the command line
arguments, and queries the on disk databases, determines of the files
exist, and have been modified.

=cut

sub process {
  my $this      = shift;

# Step 1: Process all arguments in sequence.
# Step 2: determine if the arument given is a package name (no / in
#         arg)

%{$this->{packages}}    = map { +"$_" => 1} grep {! m,/,} @ARGV;
  %{$this->{configs}}     = map { +"$_" => 1} grep {  m,/,} @ARGV;
  $this->{pkg_list}       = object_list->new;
  $this->{file_list}      = object_list->new;
  $this->{registry_proxy} =
    registry->new("StateDir" => $this->{Con_Ref}->{StateDir});
  $this->{hashfile_proxy} =
    hashfile->new("StateDir" => $this->{Con_Ref}->{StateDir});

for (keys %{$this->{packages}} ) {
    my $package = pkg->new('Name' => "$_");
    $this->{pkg_list}->element($_, $package);
  }
  for (keys %{$this->{configs}}) {
    warn "Need a fully qualified path name for config file \"$_\"\n"
      unless m,^/,;
    # Don't die for etch
    exit 0 unless m,^/,;

my $file = conffile->new('Name' => "$_");
    $this->{file_list}->element($_, $file);
  }
# Step 3: If so, gather all files associated with the package
  for my $package ($this->{pkg_list}->list) {
    my $pkg_files = $this->{registry_proxy}->list_files($package);
    for my $file (@$pkg_files) {
      if (! defined $this->{file_list}->element($file)) {
        my $ret = conffile->new('Name' => "$file");
        $this->{file_list}->element($file, $ret);
      }
      $this->{file_list}->element($file)->conffile_package($package);
    }
  }
# Step 4: for all configuration files, determine package (unless
#         already determined), if any
# Step 5: For each configuration file, check if it exists
# Step 6: For each existing file, see if it has been changed

for my $file ($this->{file_list}->list) {
    $this->{file_list}->element($file)->conffile_hash($file, $this->{hashfile_proxy}->hash($file));
    if (! defined $this->{file_list}->element($file)->conffile_package) {
      $this->{file_list}->element($file)->conffile_package($this->{registry_proxy}->find_pkg($file));
    }
  }
}

=head2 report

This routine generates a nicely formatted report based on the
information gathered during the processing. There are two kinds of
reports, the first being a user friendly tabular form, the second
(turned on by the C<-w> option) a easily parseable colon separated
report.

=cut

our ($out_pkg, $out_file, $there, $mod);

format STDOUT_TOP =
Configuration file                            Package             Exists Changed
.

format STDOUT =
@<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< @<<<<<<<<<<<<<<<<<< @|||   @|||
$out_file,                                    $out_pkg,           $there,$mod
.

sub report {
  my $this      = shift;
  for my $file (sort $this->{file_list}->list) {
    ($out_pkg, $out_file, $there, $mod) =
      $this->{file_list}->element($file)->conffile_report;
    if ($this->{Con_Ref}->{Colons}) {
      print "$out_file:$out_pkg:$there:$mod\n";
    }
    else {
      write;
    }
  }
}

=head1 Class registry

This moel class encapsulates the package-configuration file
associations registry.  It parses the data in the registry, and
provides methods to query the registry based either on package name,
or the full path of the configuration file.

=cut

package registry;
use strict;

=head2 new

This is the constructor for the class.  It takes a required parameter
B<StateDir>, and based on that, proceeds toparse the registry and
populate internal data structures.

=cut

sub new {
  my $this = shift;
  my %params = @_;
  my $class = ref($this) || $this;
  my $self = {};

die "Missing required parameter StateDir"
    unless $params{StateDir};

if (-e "$params{StateDir}/registry") {
    if (! -r "$params{StateDir}/registry") {
      die "Can't read registry file $params{StateDir}/registry:$!";
    }
    open (REG, "$params{StateDir}/registry") ||
      die "Can't read registry file $params{StateDir}/registry:$!";
    while (<REG>) {
      chomp;
      my ($pkg, $file) = m/^(\S+)\s+(\S+)$/;
      $self->{Packages}->{$file} = $pkg;
      if (exists $self->{List}->{$pkg}) {
        push @{$self->{List}->{$pkg}}, $file;
      }
      else {
        $self->{List}->{$pkg} = [ $file ];
      }
    }
  }

bless $self => $class;

return $self;
}

=head2 list_files

This routine queries the registry and lists all configuration files
associated with the given package.  Takes the package name as a
required parameter.

=cut

sub list_files {
  my $this      = shift;
  my $pkg       = shift;

if (exists $this->{List}->{$pkg}) {
    return [ @{$this->{List}->{$pkg}} ];
  }
  else {
    return [];
  }
}

=head2 find_pkg

This routine queries the registry for the package associated with the
given file.  Takes the path of the configuration file as a required
parameter.

=cut

sub find_pkg {
  my $this      = shift;
  my $file      = shift;

if (exists $this->{Packages}->{$file}) {
    return $this->{Packages}->{$file};
  }
  else {
    return undef;
  }
}

=head1 Class hashfile

This moel class encapsulates the configuration file hash database.  It
parses the data in the database, and provides methods to query the
hash of the configuration file.

=cut

package hashfile;
use strict;

sub new {
  my $this = shift;
  my %params = @_;
  my $class = ref($this) || $this;
  my $self = {};

die "Missing required parameter StateDir"
    unless $params{StateDir};

if (-e "$params{StateDir}/hashfile") {
    if (! -r "$params{StateDir}/hashfile") {
      die "Can't read registry file $params{StateDir}/hashfile:$!";
    }
    open (HASH, "$params{StateDir}/hashfile") ||
      die "Can't read registry file $params{StateDir}/hashfile:$!";
    while (<HASH>) {
      chomp;
      my ($hash, $file) = m/^(\S+)\s+(\S+)$/;
      $self->{$file} = $hash
    }
  }

bless $self => $class;

return $self;
}

=head2 hash

This routine queries the database for the hash associated with the
developers version of the given file.  Takes the path of the
configuration file as a required parameter.

=cut

sub hash {
  my $this      = shift;
  my $file      = shift;
  my $value     = shift;

if ($value) {
    $this->{$file} = $value;
  }
  return $this->{$file};
}

=head1 class conffile

This is the encapsulation of a configuration file metadata.

=cut

package conffile;
use strict;
use Cwd qw{abs_path};

=head2 new

=cut

sub new {
  my $this = shift;
  my %params = @_;
  my $class = ref($this) || $this;
  my $self = {};

die "Missing required parameter Name"
    unless $params{Name};
  $self->{Name}    = $params{Name};
  $self->{Package} = $params{Package}
    if $params{Package};
  $self->{Exists}  = 'Yes' if -e $self->{Name};
  if ($self->{Exists}) {
    $self->{Name}  = abs_path( $self->{Name});
  }
  bless $self => $class;

return $self;
}

=head2 conffile_package

This routine is the accessor method of the internal attribute that
holds package name associated with the file.  If an optional C<value>
is present, updates the value of the attribute.

=cut

sub conffile_package {
  my $this      = shift;
  my $value     = shift;

if ($value ) {
    $this->{Package} = $value;
  }
  if (exists $this->{Package}) {
    return $this->{Package};
  }
  else {
    return undef;
  }
}

=head2 conffile_exists

This routine is the accessor method of the internal attribute that
holds the information whether the file exists on disk or not.

=cut

sub conffile_exists {
  my $this      = shift;
  my $name      = shift;
  my $value     = shift;

die "Missing required parameter Name"
    unless $name;
  if (exists $this->{Exists}) {
    return $this->{Exists};
  }
  else {
    return undef;
  }
}

=head2 conffile_modified

This routine is the accessor method of the internal attribute that
holds the information whether the file exists on disk or not.  If an
optional C<value> is present, updates the value of the attribute.

=cut

sub conffile_modified {
  my $this      = shift;
  my $name      = shift;
  my $value     = shift;

die "Missing required parameter Name"
    unless $name;
  if ($value ) {
    $this->{Modified} = $value;
  }
  if (exists $this->{Modified}) {
    return $this->{Modified};
  }
  else {
    return undef;
  }
}

=head2 conffile_hash

This routine is the accessor method of the internal attribute that
holds the hash for the developers version of the file.  If an optional
C<value> is present, updates the value of the attribute.  It also
notes whether or not the file is modified from the developers version.

=cut

sub conffile_hash {
  my $this      = shift;
  my $name      = shift;
  my $value     = shift;

die "Missing required parameter Name"
    unless $name;
  if ($value ) {
    $this->{Hash} = $value;
    if (-e "$name") {
      if (-x "/usr/bin/md5sum") {
        open (NEWHASH, "/usr/bin/md5sum $name |") ||
          die "Could not run md5sum: $!";
        while (<NEWHASH>) {
          chomp;
          my ($hash, $dummy) = m/^(\S+)\s+(\S+)$/;
          if ("$hash" ne "$value") {
            $this->{Modified} = 'Yes';
          }
          else {
            $this->{Modified} = 'No';
          }
        }
        close NEWHASH;
      }
      else {
        die "Could not find /usr/bin/md5sum .\n";
      }
    }
  }
  if (exists $this->{Hash}) {
    return $this->{Hash};
  }
  else {
    return undef;
  }
}

sub conffile_report {
  my $this      = shift;
  return $this->{Package} ? $this->{Package} : "",
    $this->{Name}, $this->{Exists} ? $this->{Exists} : "",
      $this->{Modified}? $this->{Modified} : "";
}

=head1 CLASS PKG

This is an encapsulation of package metadata.  Packages may be
associated with configuration files.

=cut

package pkg;
use strict;

=head2 new

=cut

sub new {
  my $this = shift;
  my %params = @_;
  my $class = ref($this) || $this;
  my $self = {};

die "Missing required parameter Name"
    unless $params{Name};
  $self->{Name} = $params{Name};

bless $self => $class;

return $self;
}

sub list_files {
  my $this   = shift;
  return [];
}

=head1 CLASS object_list

This is a clas which holds lists of object names, either packages or
configuration file object names.  It provides methods to add, access,
and remove objects, as well as an option to list all elements in the
list.

=cut

package object_list;
use strict;

=head2 new

This is the constructor for the class. It takes no arguments.

=cut

sub new {
  my $this = shift;
  my %params = @_;
  my $class = ref($this) || $this;
  my $self = {};

$self->{"List"} = ();

bless $self => $class;

return $self;
}

=head2 element

This is an accessor method for elements of the list. If an optional
value argument exists, it creates or updates the element associtated
with the vaslue. Takes in a required name, which is used as a kay, and
an optional value argument. The value is returned.

=cut

sub element {
  my $this      = shift;
  my $name      = shift;
  my $value     = shift;

die "Missing required parameter Name"
    unless $name;
  if ($value) {
    $this->{"List"}->{$name} =  $value;
  }
  if (exists $this->{"List"}->{$name}) {
    return $this->{"List"}->{$name};
  }
  else {
    return undef;
  }
}

=head2 remove

Removes elements from the list.  Take in an required name, which is
used as the key for the element to delete.

=cut

sub remove {
  my $this      = shift;
  my $name      = shift;
  die "Missing required parameter Name"
    unless $name;
  delete $this->{"List"}->{$name}
    if (exists $this->{"List"}->{$name} );
}

=head2 list

This routine lists all the elements in the list.  It does not take any
options.

=cut

sub list {
  my $this      = shift;

return keys %{$this->{"List"}};
}

package main;
use Getopt::Long;

sub main {
  my $optdesc = ucf->Optdesc();
  my $parser  = new Getopt::Long::Parser;
  $parser->configure("bundling");
  $parser->getoptions (%$optdesc);
  my $query = ucf->new(%::ConfOpts);
  $query->process;
  $query->report;
}

&main;

exit 0;

=head1 CAVEATS

This is very inchoate, at the moment, and needs testing.

=cut

=head1 BUGS

None Known so far.

=cut

=head1 AUTHOR

Manoj Srivastava <srivasta\@debian.org>

=head1 COPYRIGHT AND LICENSE

This script is a part of the Ucf package, and is

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

=cut

__END__

./Ninja\.