root/morphix/trunk/morph-scripts/build_minimod

#!/usr/bin/perl -w
# build_minimod
# -- Rene Cunningham Mon,  7 Feb 2005 17:42:19 +0800

use strict;
use Getopt::Std;
use File::Basename;

=pod

=head1 NAME

build_minimod - build a minimod from the latest packages that you specify on the command line.

=head1 SYNOPSIS

build_minimod [MINIMOD NAME].. [MORPHIX DIR].. [OUTPUT MODULE].. [PACKAGES]..

=head1 DESCRIPTION

build_minimod is a perl script that builds a minimod from the latest packages that you specify on the command line.

It uses apt-cache to gather package meta information and downloads these packages from the repositorie(s) specified on the command line or located within /etc/apt/sources.list.

The output is a cloop iso image that can ulitimately be used with a morphix livecd.

=head1 OPTIONS

All options are mandetory unless specified optional.

-n [name]
    The minimod name

-m [directory]
    The morphix directory that will be copied within the minimod. This directory should contain the loadmod.sh shell script which will be sourced by the morphix base.

-r [repository]
    An optional argument where packages are specified instead of the repositories found within /etc/apt/sources.list

-o [file]
    The output cloop iso image.

-p [packages|file]
    A list of packages or a file that contains a list of packages that will be extracted and copied into the minimod.


=head1 EXAMPLES

build a minimod that is called sendmail, uses /home/rene/morphix as the morphix dir, contains a few sendmail and a spamassassin package and outputs to /home/rene/sendmail.mod

$ build_minimod -n sendmail -m /home/rene/morphix -o /home/rene/sendmail.mod -p sendmail sendmail-base sendmail-bin sendmail-cf spamassassin

=head1 NOTES

Debian packages are downloaded from the debian repositories that are found in your /etc/apt/sources.list file.

The packages {post,pre}insts are not used but are copied to /usr/src/build_mod/{minimod name}/build/{package}/control/. Its up to the user to move the code into mini module, usually done in morphix/loadmod.sh.

=head1 BUGS

Please email bug reports to rene@dclabs.com.au

=head1 AUTHOR

Rene Cunningham <rene@dclabs.com.au>

=cut

my $version = '0.5';

my $tmp;
my @tmp;
my $verbose = 1;
my %options;
my $minimod_name;
my $cache_file;
my $morphix_dir;
my $output_mod;
my $debian_mirror;
my $apt_archive = '/var/cache/apt/archive';
my $basename = basename($0);
my @needed_files = ('/usr/sbin/module-builder');

if ($> ne '0') {
    print "$basename: you must run this as root\n";
    exit(0);
}

foreach my $file (@needed_files) {
    if (not -f $file) {
        print "$basename: cant find file $file\n";
        exit(0);
    }
}

getopts("vr:hn:m:po:",\%options);

# needed argvs
if(defined $options{n}) {
    $minimod_name = $options{n};
} else {
    &usage;
    exit(0);
}

if(defined $options{m}) {
    $morphix_dir = $options{m};
} else {
    &usage;
    exit(0);
}

if(defined $options{o}) {
    $output_mod = $options{o};
} else {
    &usage;
    exit(0);
}

if (defined $options{v}) {
    $verbose = 1;
}

$minimod_name = "NULL" unless defined $minimod_name;

my $minimod_dir = "/usr/src/build_minimod/$minimod_name";
my $build_cache_dir = "$minimod_dir/packages";
my $build_temp_dir = "$minimod_dir/temp";
my $build_dir = "$minimod_dir/build";
my $exec_path = $ENV{PWD};
my $cmd;

# global hash used by most routines
our %package_info;

$build_cache_dir =~ s/\/+$// if substr($build_cache_dir,-1) eq '/';

#-- Helper Routines --#

# Find and return the latest package within our cache dir
sub find_package_in_cache ($) {
    my @files;
    my $p = shift;
    my $f;
    @files = `ls -1 $build_cache_dir | grep "^$p"`; 
    $f = pop(@files);
    chomp($f) if defined $f;
    if (defined $f) {
        return $f;
    } else {
        return;
    }
}

sub print_and_execute_cmd ($) {
    my $cmd = shift;
    print "Executing: $cmd\n";
    system("$cmd");
}

sub print_info {
    print "Packages were downloaded and stored in $build_cache_dir\n";
    print "The build dir for your mini module is $build_dir/temp\n";
}

# Copy contents of users morphix dir over to build_dir
sub copy_morphix_dir  {
    $cmd = "rm -rf $build_dir/temp/morphix/";
    &print_and_execute_cmd($cmd);
    $cmd = "mkdir $build_dir/temp/morphix/";
    &print_and_execute_cmd($cmd);
    $cmd = "cp -a $exec_path/$morphix_dir/* $build_dir/temp/morphix/";
    &print_and_execute_cmd($cmd);
}

# wrapper routine for module-builder
sub create_cloop ($) {
    my $cmd;
    my $dir = "$build_cache_dir/";
    print "dir is $dir\n";
    if (-d $dir) {
        $cmd = "sudo module-builder -t iso9660 $build_dir/temp $output_mod";
        &print_and_execute_cmd($cmd);
    }
}

sub setup_build_dir {
    my $cmd;

    $cmd = "mkdir -p $build_dir/temp";
    &print_and_execute_cmd($cmd);
}

sub clean_build_dir {
    my $cmd;
    $cmd = "rm -rf $build_dir/*";
    &print_and_execute_cmd($cmd);
}

sub usage {
    print <<EOF
name: $basename
author: Rene Cunningham <rene\@dclabs.com.au>
version: $version
description: build a minimod from the latest packages that you specify on the command line.

usage: $basename [MINIMOD NAME].. [MORPHIX DIR].. [OUTPUT MODULE].. [PACKAGES]..

-v                              verbose
-n [name]                       the name of the minimodule
-m [dir]                        the directory of your minimods /morphix
-r [repository]                 the debian repository <defaults to $debian_mirror>
-o [file]                       output mini module
-p [package(s)]                 a list of debian packages to install in the minimodule or a text file that contains a list of debian packages

example:
$basename -n sendmail -m /home/rene/morphix -o /home/rene/sendmail.mod -p sendmail sendmail-base sendmail-bin sendmail-cf spamassassin 

For more information, perldoc build_minimod

EOF

}

sub getdeb ($) {
    my $pkg = shift;
    my $uri;

    open(PIPE,"apt-get -q2 --print-uris --reinstall install $pkg 2>&1 | grep $pkg |") or die "cant open pipe : $!\n";

    while (my $line = <PIPE>) {
        $uri = (split /\'/, $line)[1];
    }
    system("wget -P $build_cache_dir -c $uri");
}

#-- Main Routines --#

# Populate %package_info with information regarding the package
sub get_package_info ($) {

    my $package = shift;
    my $flag;
    my (@version,$version);
    my $uri;
    my $arch;
    my $filename;
    my %seen = ();

    $cache_file = '';

    chomp($package);

    # clear %package_info
    %package_info = ();

    $package_info{package} = $package;
    $package_info{na} = 1;

    print "\nPackage name    : $package_info{package}\n" if $verbose eq 1;

    open(PIPE,"apt-cache show $package 2>/dev/null |") or die "Could not open a pipe from apt-cache command : $!\n";
    
    while (my $line = <PIPE>) {

        # Check to see if package is in our apt-cache.
        if($line =~ /^Package:/) {
            $package_info{na} = 0;
        }

        if ($line =~ /^Version:/) {
            chomp($line);
            $version = (split /Version:/, $line)[1];
            $version =~ s/\s//;
            $version =~ s/[\d\w]+://;
            if(defined $version and not defined $seen{version}) {
                $seen{version} = 1;
                $package_info{version} = $version;
                print "Package version : $package_info{version}\n" if $verbose eq 1;
            }
        }

        if ($line =~ /^Filename:/) {
            chomp($line);
            $uri = (split /:/, $line)[1];
            if(defined $uri and not defined $seen{uri}) {
                $seen{uri} = 1;
                $uri =~ s/\s//;
                $package_info{uri} = $uri;
                print "Package URI     : $package_info{uri}\n" if $verbose eq 1;
            }
        }

        if($line =~ /^Architecture:/) {
            chomp($line);
            $arch = (split /:/, $line)[1]; if(defined $arch and not defined $seen{arch}) {
                $seen{arch} = 1;
                $arch =~ s/\s//;
                $package_info{arch} = $arch;
                print "Package Arch    : $package_info{arch}\n" if $verbose eq 1;
            }
        }           

    }

    close(PIPE);

    # make warnings happy
    if (defined $package_info{arch}) {
        $filename = $package_info{package}
                    ."_"
                    .$package_info{version}
                    ."_"
                    .$package_info{arch}
                    .".deb";
    }

    $package_info{filename} = $filename;

    # Maybe apt-cache doesnt know about our package, though
    # we have the package file in our cache dir.
    if ($package_info{na} eq '1') {
        if($cache_file = &find_package_in_cache($package_info{package})) {
            $package_info{na} = '0';
            # Create meta information from cache file
            $cache_file =~ /([a-z-]+)_([\d\w\.-]+)_([\d\w]+)\.deb/;
            $package_info{version} = "$2";
            $package_info{arch} = "$3";
        }
    }

    # If apt-cache doesnt return a URI then check
    # to see if we have the package in our cache dir.
    # If we dont have a package in our cache dir, and 
    # the package doesnt have a URI mark it as NA
    if (not defined $package_info{uri} and
            $package_info{na} ne '1') {
        if (not $cache_file = &find_package_in_cache($package_info{package})) {
            $package_info{na} = 1;
        }
    }


}

sub download_package ($) {

    my $apt_sources = '/etc/apt/sources.list';
    my $version;
    my $fc;
    my $cmd;
    my $url;

    if ($package_info{na} eq '1') {
        print "$basename : $package_info{package} cant be found in apt-cache\n";
        return;
    }

    if (defined $package_info{filename}) {
        # return if we already have the file in our cache dir
        if (-f "$build_cache_dir/$package_info{filename}") {
            print "$basename : $package_info{filename} is already in cache dir.. not downloading\n";
            return;
        } elsif (-f "$apt_archive"."$package_info{filename}") {
            print "$basename : $package_info{filename} is already in apt archive dir.. not downloading\n";
            $cmd = "cp $apt_archive"."$package_info{filename}";
            &print_and_execute_cmd($cmd);
            return;
        }
    }

    # work out if the package belongs in a lib[a-z] pool dir
    if($package_info{package} =~ /lib[a-z]/) {
        $fc = substr($package_info{package}, 0, 4); 
    } else { 
        $fc = substr($package_info{package}, 0, 1);
    }

    # if the user specifies a repository, use it
    if (defined $package_info{uri}) {
        if (defined $options{r}) {
            $url = $options{r};
            $url =~ s/\/+$// if substr($url,-1) eq '/';
            $cmd = "wget -c $url/$package_info{uri} -P $build_cache_dir 2>/dev/null";
            &print_and_execute_cmd($cmd);
        } else {
            &getdeb($package_info{package});
        }
    } elsif (defined $cache_file) {
        print "$basename : couldnt download $package_info{package} from repositories within sources.list, but found $cache_file in cache dir\n";
        return;
    }

    # had to do this again because -w was complaining
    if (defined $cache_file and not -f $package_info{filename}) {
        print "$basename : couldnt download $package_info{filename} from repositories within sources.list, but found $cache_file in cache dir\n";
    }

}

sub unpack_and_copy_package {

    my $file;
    my $cmd;

    if ($package_info{na} eq '1') {
        return;
    }

    if (defined $package_info{uri}) {
        $file = "$build_cache_dir/$package_info{filename}";
        print "file is $build_cache_dir/$cache_file\n";
    } else {
        $file = "$build_cache_dir/$cache_file";
        print "file is $build_cache_dir/$cache_file\n";
    }

    if (-f $file) {
        $cmd = "rm -rf $build_dir/$package_info{package}";
        &print_and_execute_cmd($cmd);
        $cmd = "mkdir -p $build_dir/$package_info{package}";
        &print_and_execute_cmd($cmd);
        chdir "$build_dir/$package_info{package}";
        $cmd = "ar -x $file";
        &print_and_execute_cmd($cmd);
        $cmd = "mkdir control";
        &print_and_execute_cmd($cmd);
        $cmd = "tar zxvf control.tar.gz -C control";
        &print_and_execute_cmd($cmd);
        $cmd = "tar zxvf data.tar.gz -C ../temp";
        &print_and_execute_cmd($cmd);
    }

    print "\n\n";

}

if (defined $options{h}) {
    &usage;
    exit(0);
}

if(defined $options{p}) {

    if(not defined $minimod_name) {
        &usage;
        exit(0);
    }

    &clean_build_dir;
    &setup_build_dir;

    if (-f $ARGV[0]) {
        $tmp = $ARGV[0];
        open(PKGFILE, "$tmp") or die "cant open $tmp : $!\n";
        while (my $line = <PKGFILE>) {
            if($line =~ /^\w/) {
                chomp($line);
                push(@tmp,$line);
            }
        }
        close(PKGFILE);
        foreach my $p (@tmp) { 
            &get_package_info($p);
            &download_package;
            &unpack_and_copy_package;
        }
    } else {
        foreach my $p (@ARGV) {
            &get_package_info($p);
            &download_package;
            &unpack_and_copy_package;
        }
    }

    &copy_morphix_dir;
    &create_cloop;
    &print_info;
    exit(0);
}