WebSVN – DevTools – Diff – /lxr_manager/trunk/src/jats_lxr.pl



# Module name   : jats_lxr.pl
# Module type   : JATS Utility
# Compiler(s)   : Perl
# Environment(s): jats
#
# Description   : Tools to maintain LXR information
#
# Possible imporvements
#       Delete files we don't want to index
#           .DMP,.dmp,.so,.gz,.zip,.lib,.bz,.bz2,.tbz,.jar,.deb,.exe,.a,.msb
#
#       Merge ripples package versions
#           Just keep one
#
#       Cots packages
#           Use contents from dpkg_archive instead of the package
#
# Usage         : See POD at the end of this file
#
#......................................................................#
 

use Pod::Usage;
use Getopt::Long;
use File::Path;
use FindBin;
use Socket;
use Fcntl ':flock';
 
use JatsError;
use JatsRmApi;
use DBI;
use JatsSystem;

#
#   Globals
#
my $scriptDir;
my $RM_DB;
my $Config;
my @addressList;
my %ReleaseData;
my %Packages;
my $PackageStore;
my $ReleaseStore;
my $StampTime = time;
my $dateTag = localtime($StampTime);
my $lockFile = '/tmp/JATSLXR_LOCK';
 
#-------------------------------------------------------------------------------
# Function        : Main
#
# Description     : Main entry point

$scriptDir = $FindBin::Bin;
InitFileUtils();
 
#
#   Read the tool configuration
#   Sed with Default config
#
$Config->{'releaseAge'} = 0;
$Config->{'packageAge'} = 0;
$Config->{'logAge'} = 0;
$Config->{'verbose'} = 0;
readConfig();
Error ("No LXR Data directory defined", $Config->{lxrFiles}) unless( exists $Config->{lxrFiles});
Error ("No LXR Data directory found", $Config->{lxrFiles}) unless( -d $Config->{lxrFiles});
Error ("No LXR Install directory defined",$Config->{lxr}) unless( exists $Config->{lxr});
Error ("No LXR Install directory found",$Config->{lxr}) unless( -d $Config->{lxr});
ErrorConfig( 'verbose' => $Config->{'verbose'} );
 
#
#   Start logging
#
startLogFile();
Message ("Start of LXR. " . localtime(time) ) if $opt_logfile;
Message("ScriptDir: $scriptDir");
 
#
#   Prevent multiple instances of the program running
#
#   PerlMonks say to use $0 as the lock file, but that did not work.
#   Perhaps the file was open in an editor
#   Solution: Create my own file
#
open( FW, '>',$lockFile);
print FW '';
close FW;
 
open (my $self, '<', $lockFile)    || Error("Couldn't open self: $!");
flock ($self, (LOCK_EX | LOCK_NB)) || Error("This script is already running");
 
#
#   Check required paths exist
#
$PackageStore = catdir($Config->{lxrFiles}, 'Packages');
$ReleaseStore = catdir($Config->{lxrFiles}, 'Releases');
mkpath($PackageStore);
mkpath($ReleaseStore);
Error ("Package Store not found ",$PackageStore) unless( -d $PackageStore);
Error ("Release Store not found ",$ReleaseStore) unless( -d $ReleaseStore);
 
#
 
 
 
 
 
 
#   Determine the various names for this machine
#   Include all the IP addresses too
#
my ($canonname, $aliases, $addrtype, $length, @addrs) = gethostbyname($ENV{GBE_HOSTNAME});
push @addressList, $canonname ;

 
#
#   Perform the hard work
#
getReleaseData();
 
updateReleaseViews() if $opt_createVersions;
cleanReleaseViews();
rebuildLxrConfig()  if $opt_index;
buildIndexes() if $opt_index;
cleanPackageStore() if $opt_purge;
cleanupLogFiles() if $opt_purge;
 
#
#   All done
#
unlink $lockFile;
Message ("End of LXR. " . localtime(time) ) if $opt_logfile;
exit 0;
 
#-------------------------------------------------------------------------------
# Function        : extractPackages 

# Description     : Extract Packages from VCS
#                   Don't extract them if they already exist
#   
#                   Kludge: Prevent extraction from MASS_Dev_Crypto Repo
#
# Inputs          : $rtagid         - Release To Process
#                                     Conatins PackageVersion data  
#
# Returns         : 
#
sub extractPackages
{
    my ($rtagid) = @_;
    foreach my $pvid (keys %{$ReleaseData{$rtagid}{data}})
    {
        my $entry = $Packages{$pvid};
        #DebugDumpData("Entry", \$entry);
        my $fullName = join('_', $entry->{name}, $entry->{ver});
        my $fullPath = catfile($PackageStore , $fullName);

        }
    }
}
 
#-------------------------------------------------------------------------------
# Function        : updateReleaseViews 
#
# Description     : 
 
#
# Inputs          : 
#
# Returns         : 
#
sub updateReleaseViews
{
 
 
 
    #
 
    #   Process each known Release
    #
 
 
    foreach my $rtagid (sort keys \%ReleaseData)
    {
 
 
 
        if ($ReleaseData{$rtagid}{release}{ACTIVE})
 
 
 
 
 
 
 
 
 
 
 
 
 
 
        {
            #
            #   Determinte last created view in this Release
            #
            my ($latestView, $latestAge) = getLatestVersion(catdir($ReleaseStore, $rtagid ));
            if ( ! defined($latestView) || $latestAge > 1 )
            {
 
 
 
 
                #
                #   If there is no latest view, then we need to create a new view
                #   If there is a recent view, but its older than a day then we may need
                #   to refresh it.
                #
                getReleasePakageData($rtagid);
                if (checkViewDiffs($latestView,$rtagid) )
                {
                    #
                    #   Need to create a view
                    #       Either one does not exist
                    #       Content has changed
                    #
                    createReleaseView($rtagid);
                }
                else
                {
                    #   No need to create a new view
                    #   Do need to tag it so that we don't examine it again ( for a while )
                    Message("No Changes to LXR View: $rtagid");
                    if (defined $latestView)
                    {
                        my $rv = utime $StampTime,$StampTime, $latestView; 
                        Debug0("Utime $rv: $latestView");
                    }
                }
 
            }
 
 
 
 
            else
 
            {
                Message("Recent LXR View: $rtagid");
 
 
            }
        }
        else
        {
            Message("Inactive LXR View: $rtagid");
        }
    }
}
 
#-------------------------------------------------------------------------------
# Function        : checkViewDiffs 
#
# Description     : Check a view against the current package versions in the
#                   Release 
#
# Inputs          : $vdir       - View entry to process
#                   $rtagid     - RtagId
#
# Returns         : True, If we need to create a new view
#
sub checkViewDiffs
{
    my ($vdir, $rtagid) = @_;
 
    #   No entry to process, then we need to create a view
    return 1 if not defined $vdir;
 
    my %pkgsUsed;
    my $needNewView = 0;
 
    if (opendir (my $ldir, $vdir))
    {
        while (my $ldirEntry = readdir($ldir))
        {
            #   Skip hidden files
            next if ($ldirEntry =~ m~^\.~);
            my $dirName = catdir($vdir, $ldirEntry );
 
            #
 
 
 
 
            #   Process each entry within the Version
            #
            my $pkgName = $ldirEntry;
            if (-l $dirName)
            {
                $pkgName = readlink($dirName);
 
                $pkgName =~ s~.*/~~;
 
 
            }
            $pkgsUsed{$pkgName} = 2;
        }
        close ($ldir);
 
        #
        #   Compare Package-Versions against those we need
        # 
        foreach my $pvid (keys %{$ReleaseData{$rtagid}{data}})
        {
            my $entry = $Packages{$pvid};
            my $fullName = join('_', $entry->{name}, $entry->{ver});
            $pkgsUsed{$fullName}++;
        }
 
        #
        #   Scan the pkgUsed
        #   A value of 1 indicates that it is used only in the New Version
        #   A value of 2 indicates that it is only used on the Last Version
        #   A value of 3 indicates that its used in both
        #   Detect those that are not a 3
        #
        foreach ( keys %pkgsUsed)
        {
            if ($pkgsUsed{$_} != 3)
            {
                $needNewView = 1;
                last;
            }
        }
    }
    else
    {
        Warning ("Cannot open directory: $vdir", $!);
        $needNewView = 1;
    }
    #DebugDumpData("pkgsUsed",\%pkgsUsed);
    return $needNewView;
}
 
#-------------------------------------------------------------------------------
# Function        : createReleaseView 
#
# Description     : Create a new view for a single Release
#
# Inputs          : $rtagid     - RtagId
#
# Returns         : 
#
sub createReleaseView
{
    my ($rtagid) = @_;
 
    #
    #   Ensure that packages have been extracted
    #
    extractPackages($rtagid);
 
    #
    #   Create the actual view directory
    #   Its simply a bunch of symlinks back to the package store
    #
    Message("Creating LXR View: $rtagid, $dateTag");
    my $releaseDir = catdir($ReleaseStore, $rtagid, $dateTag);
    mkpath($releaseDir);
    if (-d $releaseDir)
    {
        foreach my $pvid (keys %{$ReleaseData{$rtagid}{data}})
        {
            my $entry = $Packages{$pvid};
            my $alias = join('', $entry->{name}, $entry->{ext});
            my $fullName = join('_', $entry->{name}, $entry->{ver});
            my $PackageStore = catdir($PackageStore , $fullName);
            my $releaseDir = catdir($releaseDir, $alias );
            next if -l $releaseDir;
 
            Verbose("Symlink $PackageStore, $releaseDir");
            my $rv = symlink ($PackageStore, $releaseDir);
            unless ($rv)
            {
 
 
 
 
 
 
 
 
 
 
 
 
 
                Warning("Could not link $PackageStore, $releaseDir")
 
 
            }
        }
    }
}
 

    {
        my $entry = $ReleaseData{$rtagid};
        Information("Entry: $entry->{release}{Project}, $entry->{release}{Name}, $rtagid");
        $entry->{release}{VersionsString} = join( ',', map { '"' . $_ .'"'} @{$entry->{Versions}} );
        $entry->{release}{dbName} = genDatabaseName($rtagid);
        $entry->{release}{root} = catdir($ReleaseStore, $rtagid );
        #DebugDumpData("ENTRY", \$entry);
 
        my $tfileName = 'lxr.tree.template';
        open( my $tf, '<', $tfileName) || Error ("Cannot open $tfileName. $!");
        while (my $line = <$tf>)

    #   Insert tree sections into the main config file template
    #
    my $hostList = join( ',', map { '\'http://' . $_ .'\''} @addressList );
 
    my $tfileName = catfile($scriptDir, 'lxr.template');
    my $lxrFileName = catfile($Config->{lxr}, 'lxr.new.conf');
    unlink $lxrFileName;
    open( my $tf, '<', $tfileName) || Error ("Cannot open $tfileName. $!");
    open( my $to, '>', $lxrFileName) || Error ("Cannot open $lxrFileName. $!");
    while (my $line = <$tf>)
    {

    close $to;
 
    #
    #   Install the new config files
    #
    my $lxrLive = catfile($Config->{lxr}, 'lxr.conf');
    my $lxrBackup = catfile($Config->{lxr}, 'lxr.conf.bak');
    unlink $lxrBackup;
    rename ($lxrLive, $lxrBackup) || Warning("Renaming $lxrLive, $lxrBackup", $!);
    rename ($lxrFileName, $lxrLive) || Warning("Renaming $lxrFileName, $lxrLive", $!);
 
    #
    #   Create new database tables if required
    #   Use a customized shell script to do the hard work
    #
    foreach my $rtagid ( sort keys %ReleaseData )
    {
        my $entry = $ReleaseData{$rtagid};
        Verbose("Database:$entry->{release}{Name}, $entry->{release}{dbName} ");
        System('--NoExit', '--NoShell', catfile($scriptDir, 'lxr.initdb.sh'), $entry->{release}{dbName});
    }
}
 
#-------------------------------------------------------------------------------

{
    #
    #   Prep envonment for calling genxref
    #   See notes above
    #
    chdir ($Config->{lxr}) || Error ("Cannot chnage directory:$Config->{lxr}, $!");
    delete $ENV{PERL5LIB};
 
    #
    #   Examine each Version in each Release
    #   Generate command line like:
    #   genxref --tree RTAGID --url http://HOSTNAME/lxr --version 'VERSION'
    foreach my $rtagid ( sort keys %ReleaseData )
    {
        my $entry = $ReleaseData{$rtagid};
        foreach my $version (@{$entry->{Versions}})
        {
            my $markerFile = catfile(catdir($ReleaseStore, $rtagid ), $version, '.lxrIndexed');
            unless (-f $markerFile) {
                Message("Must index: $rtagid, $version");
                my $rv = System('--NoExit', 
                       '--NoShell', 
                       catfile($Config->{lxr}, 'genxref'),
                       '--url', 'http://' . $ENV{GBE_HOSTNAME} . '/lxr',
                       '--tree', $rtagid,
                       '--version', $version
                       );
               Verbose("genxref exit: $rv");

        next unless ( -d $vdirName );
        unless(exists $ReleaseData{$rdirEntry} && $ReleaseData{$rdirEntry}{release}{ACTIVE} )
        {
            #   Release is no longer configured - age it out
            #   Assume $rdirEntry is an rtag_id
            if (processAgeMarker($vdirName, $Config->{'releaseAge'} ))
            {
                Message("Delete Release: $rdirEntry");
                RmDirTree($vdirName);
                System('--NoExit', '--NoShell', catfile($scriptDir, 'lxr.dropdb.sh'), genDatabaseName($rdirEntry));
            }

#
#                   Used to determine the most recent version
#
# Inputs          : $vdirName - Dir to process - expecting a Release directory
#
# Returns         : latestName  - Patch to the latest directory
#                   Age (days ) - Of the named directory
#
sub getLatestVersion
{
    my  ($vdirName) = @_;
    my $latestName;
    my $latestAge = 0;
 
 
    if (-d $vdirName )
    {
        opendir (my $vdir, $vdirName) || Warning ("Cannot open directory: $vdirName", $!);
        while (my $vdirEntry = readdir($vdir))
        {
            #   Skip hidden files and directories
            next if ($vdirEntry =~ m~^\.~);
 
            my $ldirName = catdir($vdirName, $vdirEntry );
            next unless ( -d $ldirName );
 
            my $age = (stat $ldirName)[9];
            Verbose3("Age: $ldirName, $age");
 
            if  ($age > $latestAge )
            {
                $latestAge = $age;
                $latestName = $ldirName;
            }
        }
        close ($vdir);
        
        #   Convert to Days ago
        $latestAge = ($StampTime - $latestAge) / (60*60*24);
        #DebugDumpData("versionDataSorted",\@versionDataSorted);
        Verbose("Latest: $latestName, $latestAge");
    }
    else
    {
        Verbose("Latest: No directory found: $vdirName");
    }
 
 
    return $latestName, $latestAge;
 
 
}
 
 
#-------------------------------------------------------------------------------
# Function        : cleanPackageStore 
#
# Description     : Delete unused PAckages fromthe package store
#

        next if ($pdirEntry =~ m~^\.~);
        my $pdirName = catdir($PackageStore, $pdirEntry );
        next unless ( -d $pdirName );
        next if (exists $pkgsUsed{$pdirEntry} );
 
        if (processAgeMarker($pdirName, $Config->{packageAge})) 
        {
            Message("Purge Package: $pdirEntry");
            RmDirTree($pdirName);
        }
    }

    my ($rtagid) = @_;
    my (@row);
    my @releaseList;
    my $partSql = '';
 
    Verbose("getReleaseData");
    connectRM(\$RM_DB) unless $RM_DB;
 
    #
    #   Determine list of existing Releases
    #   Build up a Clause for the extraction SQL

                        {
                            $data->{ACTIVE} = 2;
                        }
                    }
 
 
                    $ReleaseData{$rtagid}{release} = $data;
                }
            }
            $sth->finish();
        }

    else
    {
        Error("getReleaseData:Prepare failure" );
    }
 
    if (IsVerbose(1))
    {
        DebugDumpData("ReleaseData", \%ReleaseData);
    }
 
    #
    #   Just a summary display for logging
    #
    foreach my $rtagid ( sort keys %ReleaseData)
    {
        my $state = $ReleaseData{$rtagid}{release}{ACTIVE} ? 'ACTIVE' : 'InActive';
        Information("Release: RtagId $rtagid, $state");
 
    }
}
 
#-------------------------------------------------------------------------------
# Function        : getReleasePakageData
#
# Description     : Get PackgeVersion information for one Release
#
# Inputs          : rtagid
#
# Returns         : 
#
sub getReleasePakageData
{
    my ($rtagid) = @_;
    my (@row);
 
    connectRM(\$RM_DB) unless $RM_DB;

            $sth->finish();
        }
    }
    else
    {
        Error("getReleasePakageData:Prepare failure" );
    }
}
 
#-------------------------------------------------------------------------------
# Function        : genDatabaseName 

    if ($opt_config)
    {
        Message ("Using alternate config: $opt_config");
        $cfile = $opt_config;
    }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
    #
    #   Slurp in the file and evaluate it as a perl expression
    #
    if (open(my $CONFIG, '<', $cfile))
    {
        local ($/) = undef;
        my $config_contents = <$CONFIG>;
        $config_contents =~ m/(.*)/s;
        $config_contents = $1;    #untaint it
        my $config = eval("\n#line 1 \"configuration file\"\n" . $config_contents);
        Error($@) if $@;
        close $CONFIG;
 
        #
        #   Merge read data with defaults
        #
        @$Config{ keys %$config } = values %$config;
    }
    else
    {
        Error("Couldn't open configuration file \"$cfile\".", $!);
    }
 
    if (IsVerbose(1))
    {
        DebugDumpData("Config", \$Config);
    }
}
 
#-------------------------------------------------------------------------------
# Function        : startLogFile 
#

#
sub startLogFile
{
    if ( $opt_logfile )
    {
        if (exists $Config->{lxrLogDir})
        {
            my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = gmtime($StampTime);
            my $name = sprintf("jats-lxr-%4.4d%2.2d%2.2d.%2.2d%2.2d%2.2d.log", 1900+$year, 1+$mon, $mday, $hour, $min, $sec);
            $name = catdir($Config->{lxrLogDir}, $name);
 
            mkpath($Config->{lxrLogDir}); 
            if (-d $Config->{lxrLogDir} )
            {
                open STDOUT, '>', $name  or die "Can't redirect STDOUT: $!";
                open STDERR, ">&STDOUT"  or die "Can't dup STDOUT: $!";
            }
            else
            {
                Warning("Can't create log dir: $Config->{lxrLogDir}. $!");
            }
        }
    }
}
 

#
# Returns         : 
#
sub cleanupLogFiles
{
    if (exists $Config->{lxrLogDir} && exists $Config->{logAge}  && $Config->{logAge} > 0 )
    {
        Verbose("cleanupLogFiles:$Config->{lxrLogDir}, $Config->{logAge}");
        if ( opendir my $logDir, $Config->{lxrLogDir} )
        {
            foreach my $fileName (readdir $logDir)
            {
                my $file = catfile($Config->{lxrLogDir}, $fileName);
                next unless -f $file;
                next unless -M $file > $Config->{logAge};
                Verbose("Purge logfile: $fileName");
                unlink $file;
            }
            closedir $logDir;
        }

    {
        TouchFile($markerfile);
    }
    else
    {
        my $fileAge = -M $markerfile;
        Verbose ("Age: $fileAge, $tdir");
        if ($fileAge > $age)
        {
            return 1
        }
    }
    return 0;

Rev 5212	Rev 5213
Line 4...	Line 4...
4	`# Module name : jats_lxr.pl`	4	`# Module name : jats_lxr.pl`
5	`# Module type : JATS Utility`	5	`# Module type : JATS Utility`
6	`# Compiler(s) : Perl`	6	`# Compiler(s) : Perl`
7	`# Environment(s): jats`	7	`# Environment(s): jats`
8	`#`	8	`#`
9	`# Description : Tiools to maintain LXR information`	9	`# Description : Tools to maintain LXR information`
-		10	`#`
-		11	`# Possible imporvements`
-		12	`# Delete files we don't want to index`
-		13	`# .DMP,.dmp,.so,.gz,.zip,.lib,.bz,.bz2,.tbz,.jar,.deb,.exe,.a,.msb`
-		14	`#`
-		15	`# Merge ripples package versions`
-		16	`# Just keep one`
-		17	`#`
-		18	`# Cots packages`
-		19	`# Use contents from dpkg_archive instead of the package`
10	`#`	20	`#`
11	`# Usage : See POD at the end of this file`	21	`# Usage : See POD at the end of this file`
12	`#`	22	`#`
13	`#......................................................................#`	23	`#......................................................................#`
14		24
Line 19...	Line 29...
19	`use Pod::Usage;`	29	`use Pod::Usage;`
20	`use Getopt::Long;`	30	`use Getopt::Long;`
21	`use File::Path;`	31	`use File::Path;`
22	`use FindBin;`	32	`use FindBin;`
23	`use Socket;`	33	`use Socket;`
-		34	`use Fcntl ':flock';`
24		35
25	`use JatsError;`	36	`use JatsError;`
26	`use JatsRmApi;`	37	`use JatsRmApi;`
27	`use DBI;`	38	`use DBI;`
28	`use JatsSystem;`	39	`use JatsSystem;`
Line 45...	Line 56...
45	`#`	56	`#`
46	`# Globals`	57	`# Globals`
47	`#`	58	`#`
48	`my $scriptDir;`	59	`my $scriptDir;`
49	`my $RM_DB;`	60	`my $RM_DB;`
50	`our $config;`	61	`my $Config;`
51	`my @addressList;`	62	`my @addressList;`
52	`my %ReleaseData;`	63	`my %ReleaseData;`
53	`my %Packages;`	64	`my %Packages;`
54	`my $PackageStore;`	65	`my $PackageStore;`
55	`my $ReleaseStore;`	66	`my $ReleaseStore;`
56	`my $stamptime = time;`	67	`my $StampTime = time;`
-		68	`my $dateTag = localtime($StampTime);`
-		69	`my $lockFile = '/tmp/JATSLXR_LOCK';`
57		70
58	`#-------------------------------------------------------------------------------`	71	`#-------------------------------------------------------------------------------`
59	`# Function : Main`	72	`# Function : Main`
60	`#`	73	`#`
61	`# Description : Main entry point`	74	`# Description : Main entry point`
Line 99...	Line 112...
99	`$scriptDir = $FindBin::Bin;`	112	`$scriptDir = $FindBin::Bin;`
100	`InitFileUtils();`	113	`InitFileUtils();`
101		114
102	`#`	115	`#`
103	`# Read the tool configuration`	116	`# Read the tool configuration`
-		117	`# Sed with Default config`
104	`#`	118	`#`
-		119	`$Config->{'releaseAge'} = 0;`
-		120	`$Config->{'packageAge'} = 0;`
-		121	`$Config->{'logAge'} = 0;`
-		122	`$Config->{'verbose'} = 0;`
105	`readConfig();`	123	`readConfig();`
106	`Error ("No LXR Data directory defined", $config->{lxrFiles}) unless( exists $config->{lxrFiles});`	124	`Error ("No LXR Data directory defined", $Config->{lxrFiles}) unless( exists $Config->{lxrFiles});`
107	`Error ("No LXR Data directory found", $config->{lxrFiles}) unless( -d $config->{lxrFiles});`	125	`Error ("No LXR Data directory found", $Config->{lxrFiles}) unless( -d $Config->{lxrFiles});`
108	`Error ("No LXR Install directory defined",$config->{lxr}) unless( exists $config->{lxr});`	126	`Error ("No LXR Install directory defined",$Config->{lxr}) unless( exists $Config->{lxr});`
109	`Error ("No LXR Install directory found",$config->{lxr}) unless( -d $config->{lxr});`	127	`Error ("No LXR Install directory found",$Config->{lxr}) unless( -d $Config->{lxr});`
-		128	`ErrorConfig( 'verbose' => $Config->{'verbose'} );`
110		129
111	`#`	130	`#`
112	`# Start logging`	131	`# Start logging`
113	`#`	132	`#`
114	`startLogFile();`	133	`startLogFile();`
115	`Message ("Start of LXR. " . localtime(time) ) if $opt_logfile;`	134	`Message ("Start of LXR. " . localtime(time) ) if $opt_logfile;`
116	`Message("ScriptDir: $scriptDir");`	135	`Message("ScriptDir: $scriptDir");`
117		136
118	`#`	137	`#`
-		138	`# Prevent multiple instances of the program running`
-		139	`#`
-		140	`# PerlMonks say to use $0 as the lock file, but that did not work.`
-		141	`# Perhaps the file was open in an editor`
-		142	`# Solution: Create my own file`
-		143	`#`
-		144	`open( FW, '>',$lockFile);`
-		145	`print FW '';`
-		146	`close FW;`
-		147
-		148	`open (my $self, '<', $lockFile) \|\| Error("Couldn't open self: $!");`
-		149	`flock ($self, (LOCK_EX \| LOCK_NB)) \|\| Error("This script is already running");`
-		150
-		151	`#`
119	`# Check required paths exist`	152	`# Check required paths exist`
120	`#`	153	`#`
121	`$PackageStore = catdir($config->{lxrFiles}, 'Packages');`	154	`$PackageStore = catdir($Config->{lxrFiles}, 'Packages');`
122	`$ReleaseStore = catdir($config->{lxrFiles}, 'Releases');`	155	`$ReleaseStore = catdir($Config->{lxrFiles}, 'Releases');`
123	`mkpath($PackageStore);`	156	`mkpath($PackageStore);`
124	`mkpath($ReleaseStore);`	157	`mkpath($ReleaseStore);`
125	`Error ("Package Store not found ",$PackageStore) unless( -d $PackageStore);`	158	`Error ("Package Store not found ",$PackageStore) unless( -d $PackageStore);`
126	`Error ("Release Store not found ",$ReleaseStore) unless( -d $ReleaseStore);`	159	`Error ("Release Store not found ",$ReleaseStore) unless( -d $ReleaseStore);`
127		160
128	`#`	161	`#`
129	`# Default config`	-
130	`#`	-
131	`$config->{'releaseAge'} = 0 unless exists $config->{'releaseAge'};`	-
132	`$config->{'packageAge'} = 0 unless exists $config->{'packageAge'};`	-
133		-
134	`#`	-
135	`# Determine the various names for this machine`	162	`# Determine the various names for this machine`
136	`# Include all the IP addresses too`	163	`# Include all the IP addresses too`
137	`#`	164	`#`
138	`my ($canonname, $aliases, $addrtype, $length, @addrs) = gethostbyname($ENV{GBE_HOSTNAME});`	165	`my ($canonname, $aliases, $addrtype, $length, @addrs) = gethostbyname($ENV{GBE_HOSTNAME});`
139	`push @addressList, $canonname ;`	166	`push @addressList, $canonname ;`
Line 146...	Line 173...
146		173
147	`#`	174	`#`
148	`# Perform the hard work`	175	`# Perform the hard work`
149	`#`	176	`#`
150	`getReleaseData();`	177	`getReleaseData();`
151	`extractPackages();`	-
152	`createReleaseViews() if $opt_createVersions;`	178	`updateReleaseViews() if $opt_createVersions;`
153	`cleanReleaseViews();`	179	`cleanReleaseViews();`
154	`rebuildLxrConfig();`	180	`rebuildLxrConfig() if $opt_index;`
155	`buildIndexes() if $opt_index;`	181	`buildIndexes() if $opt_index;`
156	`cleanPackageStore() if $opt_purge;`	182	`cleanPackageStore() if $opt_purge;`
157	`cleanupLogFiles() if $opt_purge;`	183	`cleanupLogFiles() if $opt_purge;`
158		184
159	`#`	185	`#`
160	`# All done`	186	`# All done`
161	`#`	187	`#`
-		188	`unlink $lockFile;`
162	`Message ("End of LXR. " . localtime(time) ) if $opt_logfile;`	189	`Message ("End of LXR. " . localtime(time) ) if $opt_logfile;`
163	`exit 0;`	190	`exit 0;`
164		191
165	`#-------------------------------------------------------------------------------`	192	`#-------------------------------------------------------------------------------`
166	`# Function : extractPackages`	193	`# Function : extractPackages`
Line 168...	Line 195...
168	`# Description : Extract Packages from VCS`	195	`# Description : Extract Packages from VCS`
169	`# Don't extract them if they already exist`	196	`# Don't extract them if they already exist`
170	`#`	197	`#`
171	`# Kludge: Prevent extraction from MASS_Dev_Crypto Repo`	198	`# Kludge: Prevent extraction from MASS_Dev_Crypto Repo`
172	`#`	199	`#`
173	`# Inputs :`	200	`# Inputs : $rtagid - Release To Process`
-		201	`# Conatins PackageVersion data`
174	`#`	202	`#`
175	`# Returns :`	203	`# Returns :`
176	`#`	204	`#`
177	`sub extractPackages`	205	`sub extractPackages`
178	`{`	206	`{`
-		207	`my ($rtagid) = @_;`
179	`foreach my $pvid ( keys{%Packages})`	208	`foreach my $pvid (keys %{$ReleaseData{$rtagid}{data}})`
180	`{`	209	`{`
181	`my $entry = $Packages{$pvid};`	210	`my $entry = $Packages{$pvid};`
182	`#DebugDumpData("Entry", \$entry);`	211	`#DebugDumpData("Entry", \$entry);`
183	`my $fullName = join('_', $entry->{name}, $entry->{ver});`	212	`my $fullName = join('_', $entry->{name}, $entry->{ver});`
184	`my $fullPath = catfile($PackageStore , $fullName);`	213	`my $fullPath = catfile($PackageStore , $fullName);`
Line 211...	Line 240...
211	`}`	240	`}`
212	`}`	241	`}`
213	`}`	242	`}`
214		243
215	`#-------------------------------------------------------------------------------`	244	`#-------------------------------------------------------------------------------`
216	`# Function : createReleaseViews`	245	`# Function : updateReleaseViews`
217	`#`	246	`#`
218	`# Description : Create a new view for each Release`	247	`# Description :`
219	`# Each view is basically a bunch of symlinks`	-
220	`#`	248	`#`
221	`# Inputs :`	249	`# Inputs :`
222	`#`	250	`#`
223	`# Returns :`	251	`# Returns :`
224	`#`	252	`#`
225	`sub createReleaseViews`	253	`sub updateReleaseViews`
226	`{`	254	`{`
227	`my $latestView;`	-
228	`my $needNewView;`	-
229		-
230	`#`	255	`#`
231	`# Create a name for the releases - based on a date-time`	-
232	`# Will be unqiue(ish)`	256	`# Process each known Release`
233	`#`	257	`#`
234	`my $dateTag = localtime($stamptime);`	-
235		-
236	`foreach my $rtagid (keys \%ReleaseData)`	258	`foreach my $rtagid (sort keys \%ReleaseData)`
237	`{`	259	`{`
238	`$latestView = undef;`	-
239	`$needNewView = 0;`	-
240		-
241	`my $entry = $ReleaseData{$rtagid};`	260	`if ($ReleaseData{$rtagid}{release}{ACTIVE})`
242	`if ($entry->{data} )`	-
243	`{`	-
244	`$latestView = getLatestVersion(catdir($ReleaseStore, $rtagid));`	-
245	`$needNewView = 1;`	-
246	`}`	-
247		-
248	`#`	-
249	`# Check to see if we really need to create a new view`	-
250	`# If the LATEST view contains all the package-versions that we need then`	-
251	`# don't create a new one.`	-
252	`#`	-
253	`# Scan each entry within the Last View`	-
254	`#`	-
255	`if ($latestView)`	-
256	`{`	261	`{`
-		262	`#`
-		263	`# Determinte last created view in this Release`
257	`my %pkgsUsed;`	264	`#`
258	`opendir (my $ldir, $latestView) \|\| Warning ("Cannot open directory: $latestView", $!);`	265	`my ($latestView, $latestAge) = getLatestVersion(catdir($ReleaseStore, $rtagid ));`
259	`while (my $ldirEntry = readdir($ldir))`	266	`if ( ! defined($latestView) \|\| $latestAge > 1 )`
260	`{`	267	`{`
261	`# Skip hidden files`	-
262	`next if ($ldirEntry =~ m~^\.~);`	-
263	`my $dirName = catdir($latestView, $ldirEntry );`	-
264		-
265	`#`	268	`#`
-		269	`# If there is no latest view, then we need to create a new view`
-		270	`# If there is a recent view, but its older than a day then we may need`
266	`# Process each entry within the Version`	271	`# to refresh it.`
267	`#`	272	`#`
268	`my $pkgName = $ldirEntry;`	273	`getReleasePakageData($rtagid);`
269	`if (-l $dirName)`	274	`if (checkViewDiffs($latestView,$rtagid) )`
270	`{`	275	`{`
-		276	`#`
-		277	`# Need to create a view`
-		278	`# Either one does not exist`
-		279	`# Content has changed`
-		280	`#`
271	`$pkgName = readlink($dirName);`	281	`createReleaseView($rtagid);`
-		282	`}`
-		283	`else`
-		284	`{`
-		285	`# No need to create a new view`
-		286	`# Do need to tag it so that we don't examine it again ( for a while )`
-		287	`Message("No Changes to LXR View: $rtagid");`
272	`$pkgName =~ s~.*/~~;`	288	`if (defined $latestView)`
-		289	`{`
-		290	`my $rv = utime $StampTime,$StampTime, $latestView;`
-		291	`Debug0("Utime $rv: $latestView");`
-		292	`}`
273	`}`	293	`}`
274	`$pkgsUsed{$pkgName} = 2;`	-
275	`}`	294	`}`
276	`close ($ldir);`	-
277		-
278	`#`	-
279	`# Compare Package-Versions against those we need`	-
280	`#`	295	`else`
281	`foreach my $pvid (keys $entry->{data})`	-
282	`{`	296	`{`
283	`my $entry = $Packages{$pvid};`	297	`Message("Recent LXR View: $rtagid");`
284	`my $fullName = join('_', $entry->{name}, $entry->{ver});`	-
285	`$pkgsUsed{$fullName}++;`	-
286	`}`	298	`}`
-		299	`}`
287		300	`else`
-		301	`{`
-		302	`Message("Inactive LXR View: $rtagid");`
-		303	`}`
-		304	`}`
-		305	`}`
-		306
-		307	`#-------------------------------------------------------------------------------`
-		308	`# Function : checkViewDiffs`
-		309	`#`
-		310	`# Description : Check a view against the current package versions in the`
-		311	`# Release`
-		312	`#`
-		313	`# Inputs : $vdir - View entry to process`
-		314	`# $rtagid - RtagId`
-		315	`#`
-		316	`# Returns : True, If we need to create a new view`
-		317	`#`
-		318	`sub checkViewDiffs`
-		319	`{`
-		320	`my ($vdir, $rtagid) = @_;`
-		321
-		322	`# No entry to process, then we need to create a view`
-		323	`return 1 if not defined $vdir;`
-		324
-		325	`my %pkgsUsed;`
-		326	`my $needNewView = 0;`
-		327
-		328	`if (opendir (my $ldir, $vdir))`
-		329	`{`
-		330	`while (my $ldirEntry = readdir($ldir))`
-		331	`{`
-		332	`# Skip hidden files`
-		333	`next if ($ldirEntry =~ m~^\.~);`
-		334	`my $dirName = catdir($vdir, $ldirEntry );`
-		335
288	`#`	336	`#`
289	`# Scan the pkgUsed`	-
290	`# A value of 1 indicates that it is used only in the New Version`	-
291	`# A value of 2 indicates that it is only used on the Last Version`	-
292	`# A value of 3 indicates that its used in both`	-
293	`# Detect those that are not a 3`	337	`# Process each entry within the Version`
294	`#`	338	`#`
295	`$needNewView = 0;`	339	`my $pkgName = $ldirEntry;`
296	`foreach ( keys %pkgsUsed)`	340	`if (-l $dirName)`
297	`{`	341	`{`
298	`if ($pkgsUsed{$_} != 3)`	342	`$pkgName = readlink($dirName);`
299	`{`	-
300	`$needNewView = 1;`	343	`$pkgName =~ s~.*/~~;`
301	`last;`	-
302	`}`	-
303	`}`	344	`}`
304	`#DebugDumpData("pkgsUsed",\%pkgsUsed);`	345	`$pkgsUsed{$pkgName} = 2;`
305	`}`	346	`}`
-		347	`close ($ldir);`
306		348
-		349	`#`
-		350	`# Compare Package-Versions against those we need`
-		351	`#`
-		352	`foreach my $pvid (keys %{$ReleaseData{$rtagid}{data}})`
-		353	`{`
-		354	`my $entry = $Packages{$pvid};`
-		355	`my $fullName = join('_', $entry->{name}, $entry->{ver});`
-		356	`$pkgsUsed{$fullName}++;`
-		357	`}`
-		358
-		359	`#`
-		360	`# Scan the pkgUsed`
-		361	`# A value of 1 indicates that it is used only in the New Version`
-		362	`# A value of 2 indicates that it is only used on the Last Version`
-		363	`# A value of 3 indicates that its used in both`
-		364	`# Detect those that are not a 3`
-		365	`#`
307	`unless ($needNewView)`	366	`foreach ( keys %pkgsUsed)`
308	`{`	367	`{`
-		368	`if ($pkgsUsed{$_} != 3)`
-		369	`{`
309	`Message("No Changes to LXR View: $rtagid");`	370	`$needNewView = 1;`
-		371	`last;`
-		372	`}`
310	`}`	373	`}`
-		374	`}`
311	`else`	375	`else`
-		376	`{`
-		377	`Warning ("Cannot open directory: $vdir", $!);`
-		378	`$needNewView = 1;`
-		379	`}`
-		380	`#DebugDumpData("pkgsUsed",\%pkgsUsed);`
-		381	`return $needNewView;`
-		382	`}`
-		383
-		384	`#-------------------------------------------------------------------------------`
-		385	`# Function : createReleaseView`
-		386	`#`
-		387	`# Description : Create a new view for a single Release`
-		388	`#`
-		389	`# Inputs : $rtagid - RtagId`
-		390	`#`
-		391	`# Returns :`
-		392	`#`
-		393	`sub createReleaseView`
-		394	`{`
-		395	`my ($rtagid) = @_;`
-		396
-		397	`#`
-		398	`# Ensure that packages have been extracted`
-		399	`#`
-		400	`extractPackages($rtagid);`
-		401
-		402	`#`
-		403	`# Create the actual view directory`
-		404	`# Its simply a bunch of symlinks back to the package store`
-		405	`#`
-		406	`Message("Creating LXR View: $rtagid, $dateTag");`
-		407	`my $releaseDir = catdir($ReleaseStore, $rtagid, $dateTag);`
-		408	`mkpath($releaseDir);`
-		409	`if (-d $releaseDir)`
-		410	`{`
-		411	`foreach my $pvid (keys %{$ReleaseData{$rtagid}{data}})`
312	`{`	412	`{`
-		413	`my $entry = $Packages{$pvid};`
-		414	`my $alias = join('', $entry->{name}, $entry->{ext});`
-		415	`my $fullName = join('_', $entry->{name}, $entry->{ver});`
313	`Message("Creating LXR View: $rtagid, $dateTag");`	416	`my $PackageStore = catdir($PackageStore , $fullName);`
314	`my $releaseDir = catdir($ReleaseStore, $rtagid, $dateTag);`	417	`my $releaseDir = catdir($releaseDir, $alias );`
315	`mkpath($releaseDir);`	418	`next if -l $releaseDir;`
-		419
-		420	`Verbose("Symlink $PackageStore, $releaseDir");`
-		421	`my $rv = symlink ($PackageStore, $releaseDir);`
316	`if (-d $releaseDir)`	422	`unless ($rv)`
317	`{`	423	`{`
318	`foreach my $pvid (keys $entry->{data})`	-
319	`{`	-
320	`my $entry = $Packages{$pvid};`	-
321	`my $alias = join('', $entry->{name}, $entry->{ext});`	-
322	`my $fullName = join('_', $entry->{name}, $entry->{ver});`	-
323	`my $PackageStore = catdir($PackageStore , $fullName);`	-
324	`my $releaseDir = catdir($releaseDir, $alias );`	-
325	`next if -l $releaseDir;`	-
326		-
327	`Verbose("Symlink $PackageStore, $releaseDir");`	-
328	`my $rv = symlink ($PackageStore, $releaseDir);`	-
329	`unless ($rv)`	-
330	`{`	-
331	`Warning("Could not link $PackageStore, $releaseDir")`	424	`Warning("Could not link $PackageStore, $releaseDir")`
332	`}`	-
333	`}`	-
334	`}`	425	`}`
335	`}`	426	`}`
336	`}`	427	`}`
337	`}`	428	`}`
338		429
Line 384...	Line 475...
384	`{`	475	`{`
385	`my $entry = $ReleaseData{$rtagid};`	476	`my $entry = $ReleaseData{$rtagid};`
386	`Information("Entry: $entry->{release}{Project}, $entry->{release}{Name}, $rtagid");`	477	`Information("Entry: $entry->{release}{Project}, $entry->{release}{Name}, $rtagid");`
387	`$entry->{release}{VersionsString} = join( ',', map { '"' . $_ .'"'} @{$entry->{Versions}} );`	478	`$entry->{release}{VersionsString} = join( ',', map { '"' . $_ .'"'} @{$entry->{Versions}} );`
388	`$entry->{release}{dbName} = genDatabaseName($rtagid);`	479	`$entry->{release}{dbName} = genDatabaseName($rtagid);`
-		480	`$entry->{release}{root} = catdir($ReleaseStore, $rtagid );`
389	`#DebugDumpData("ENTRY", \$entry);`	481	`#DebugDumpData("ENTRY", \$entry);`
390		482
391	`my $tfileName = 'lxr.tree.template';`	483	`my $tfileName = 'lxr.tree.template';`
392	`open( my $tf, '<', $tfileName) \|\| Error ("Cannot open $tfileName. $!");`	484	`open( my $tf, '<', $tfileName) \|\| Error ("Cannot open $tfileName. $!");`
393	`while (my $line = <$tf>)`	485	`while (my $line = <$tf>)`
Line 410...	Line 502...
410	`# Insert tree sections into the main config file template`	502	`# Insert tree sections into the main config file template`
411	`#`	503	`#`
412	`my $hostList = join( ',', map { '\'http://' . $_ .'\''} @addressList );`	504	`my $hostList = join( ',', map { '\'http://' . $_ .'\''} @addressList );`
413		505
414	`my $tfileName = catfile($scriptDir, 'lxr.template');`	506	`my $tfileName = catfile($scriptDir, 'lxr.template');`
415	`my $lxrFileName = catfile($config->{lxr}, 'lxr.new.conf');`	507	`my $lxrFileName = catfile($Config->{lxr}, 'lxr.new.conf');`
416	`unlink $lxrFileName;`	508	`unlink $lxrFileName;`
417	`open( my $tf, '<', $tfileName) \|\| Error ("Cannot open $tfileName. $!");`	509	`open( my $tf, '<', $tfileName) \|\| Error ("Cannot open $tfileName. $!");`
418	`open( my $to, '>', $lxrFileName) \|\| Error ("Cannot open $lxrFileName. $!");`	510	`open( my $to, '>', $lxrFileName) \|\| Error ("Cannot open $lxrFileName. $!");`
419	`while (my $line = <$tf>)`	511	`while (my $line = <$tf>)`
420	`{`	512	`{`
Line 439...	Line 531...
439	`close $to;`	531	`close $to;`
440		532
441	`#`	533	`#`
442	`# Install the new config files`	534	`# Install the new config files`
443	`#`	535	`#`
444	`my $lxrLive = catfile($config->{lxr}, 'lxr.conf');`	536	`my $lxrLive = catfile($Config->{lxr}, 'lxr.conf');`
445	`my $lxrBackup = catfile($config->{lxr}, 'lxr.conf.bak');`	537	`my $lxrBackup = catfile($Config->{lxr}, 'lxr.conf.bak');`
446	`unlink $lxrBackup;`	538	`unlink $lxrBackup;`
447	`rename ($lxrLive, $lxrBackup) \|\| Warning("Renaming $lxrLive, $lxrBackup", $!);`	539	`rename ($lxrLive, $lxrBackup) \|\| Warning("Renaming $lxrLive, $lxrBackup", $!);`
448	`rename ($lxrFileName, $lxrLive) \|\| Warning("Renaming $lxrFileName, $lxrLive", $!);`	540	`rename ($lxrFileName, $lxrLive) \|\| Warning("Renaming $lxrFileName, $lxrLive", $!);`
449		541
450	`#`	542	`#`
451	`# Create new database tables if required`	543	`# Create new database tables if required`
452	`# Use a customized shell script to do the hard work`	544	`# Use a customized shell script to do the hard work`
453	`#`	545	`#`
454	`foreach my $rtagid ( keys %ReleaseData )`	546	`foreach my $rtagid ( sort keys %ReleaseData )`
455	`{`	547	`{`
456	`my $entry = $ReleaseData{$rtagid};`	548	`my $entry = $ReleaseData{$rtagid};`
457	`Information("Database:$entry->{release}{Name}, $entry->{release}{dbName} ");`	549	`Verbose("Database:$entry->{release}{Name}, $entry->{release}{dbName} ");`
458	`System('--NoExit', '--NoShell', catfile($scriptDir, 'lxr.initdb.sh'), $entry->{release}{dbName});`	550	`System('--NoExit', '--NoShell', catfile($scriptDir, 'lxr.initdb.sh'), $entry->{release}{dbName});`
459	`}`	551	`}`
460	`}`	552	`}`
461		553
462	`#-------------------------------------------------------------------------------`	554	`#-------------------------------------------------------------------------------`
Line 486...	Line 578...
486	`{`	578	`{`
487	`#`	579	`#`
488	`# Prep envonment for calling genxref`	580	`# Prep envonment for calling genxref`
489	`# See notes above`	581	`# See notes above`
490	`#`	582	`#`
491	`chdir ($config->{lxr}) \|\| Error ("Cannot chnage directory:$config->{lxr}, $!");`	583	`chdir ($Config->{lxr}) \|\| Error ("Cannot chnage directory:$Config->{lxr}, $!");`
492	`delete $ENV{PERL5LIB};`	584	`delete $ENV{PERL5LIB};`
493		585
494	`#`	586	`#`
495	`# Examine each Version in each Release`	587	`# Examine each Version in each Release`
496	`# Generate command line like:`	588	`# Generate command line like:`
497	`# genxref --tree RTAGID --url http://HOSTNAME/lxr --version 'VERSION'`	589	`# genxref --tree RTAGID --url http://HOSTNAME/lxr --version 'VERSION'`
498	`foreach my $rtagid ( keys %ReleaseData )`	590	`foreach my $rtagid ( sort keys %ReleaseData )`
499	`{`	591	`{`
500	`my $entry = $ReleaseData{$rtagid};`	592	`my $entry = $ReleaseData{$rtagid};`
501	`foreach my $version (@{$entry->{Versions}})`	593	`foreach my $version (@{$entry->{Versions}})`
502	`{`	594	`{`
503	`my $markerFile = catfile($entry->{release}{root}, $version, '.lxrIndexed');`	595	`my $markerFile = catfile(catdir($ReleaseStore, $rtagid ), $version, '.lxrIndexed');`
504	`unless (-f $markerFile) {`	596	`unless (-f $markerFile) {`
505	`Message("Must index: $rtagid, $version");`	597	`Message("Must index: $rtagid, $version");`
506	`my $rv = System('--NoExit',`	598	`my $rv = System('--NoExit',`
507	`'--NoShell',`	599	`'--NoShell',`
508	`catfile($config->{lxr}, 'genxref'),`	600	`catfile($Config->{lxr}, 'genxref'),`
509	`'--url', 'http://' . $ENV{GBE_HOSTNAME} . '/lxr',`	601	`'--url', 'http://' . $ENV{GBE_HOSTNAME} . '/lxr',`
510	`'--tree', $rtagid,`	602	`'--tree', $rtagid,`
511	`'--version', $version`	603	`'--version', $version`
512	`);`	604	`);`
513	`Verbose("genxref exit: $rv");`	605	`Verbose("genxref exit: $rv");`
Line 559...	Line 651...
559	`next unless ( -d $vdirName );`	651	`next unless ( -d $vdirName );`
560	`unless(exists $ReleaseData{$rdirEntry} && $ReleaseData{$rdirEntry}{release}{ACTIVE} )`	652	`unless(exists $ReleaseData{$rdirEntry} && $ReleaseData{$rdirEntry}{release}{ACTIVE} )`
561	`{`	653	`{`
562	`# Release is no longer configured - age it out`	654	`# Release is no longer configured - age it out`
563	`# Assume $rdirEntry is an rtag_id`	655	`# Assume $rdirEntry is an rtag_id`
564	`if (processAgeMarker($vdirName, $config->{'releaseAge'} ))`	656	`if (processAgeMarker($vdirName, $Config->{'releaseAge'} ))`
565	`{`	657	`{`
566	`Message("Delete Release: $rdirEntry");`	658	`Message("Delete Release: $rdirEntry");`
567	`RmDirTree($vdirName);`	659	`RmDirTree($vdirName);`
568	`System('--NoExit', '--NoShell', catfile($scriptDir, 'lxr.dropdb.sh'), genDatabaseName($rdirEntry));`	660	`System('--NoExit', '--NoShell', catfile($scriptDir, 'lxr.dropdb.sh'), genDatabaseName($rdirEntry));`
569	`}`	661	`}`
Line 624...	Line 716...
624	`#`	716	`#`

Subversion Repositories DevTools

(root)/lxr_manager/trunk/src/jats_lxr.pl – Rev 5212 → 5213