#!/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
=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
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 = {};
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
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 = {};
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
Copyright (c) 2006 Manoj Srivastava <srivasta\@debian.org>
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
1;
__END__
Mini Shell