openpkg-packages/perl-openpkg/perl-openpkg.pl

#!@l_prefix@/bin/perl -w
##
##  perl-openpkg -- OpenPKG Perl Module Build Utility
##  Copyright (c) 2000-2007 OpenPKG Foundation e.V. <http://openpkg.net/>
##  Copyright (c) 2000-2007 Ralf S. Engelschall <http://engelschall.com/>
##
##  Permission to use, copy, modify, and distribute this software for
##  any purpose with or without fee is hereby granted, provided that
##  the above copyright notice and this permission notice appear in all
##  copies.
##
##  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
##  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
##  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
##  IN NO EVENT SHALL THE AUTHORS AND COPYRIGHT HOLDERS AND THEIR
##  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
##  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
##  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
##  USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
##  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
##  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
##  OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
##  SUCH DAMAGE.
##

require 5;
use strict;
use Getopt::Long;
use IO qw(Handle Seekable File Pipe Socket Dir);

#   program information
my $ME = {
    prog_path => $0,
    prog_name => "perl-openpkg",
    prog_vers => "2.0.1",
    prog_date => "03-Dec-2004"
};

#   program configuration
my $CF = {
    path_prefix    => '@l_prefix@',
    path_libdir    => "",
    path_tmpdir    => ($ENV{"TMPDIR"} || "/tmp"),
    path_wrkdir    => "",
    path_buildroot => ($ENV{"RPM_BUILD_ROOT"} || ""),
    path_buildwork => ($ENV{"RPM_BUILD_DIR"} || ""),
    pkg_name       => ($ENV{"RPM_PACKAGE_NAME"} || ""),
    perl_schema    => "vendor",
    perl_args      => [],
    perl_stdin     => "/dev/null",
    files_file     => "-",
    files_unquoted => 0,
    prog_rpm       => '%path_prefix%/libexec/openpkg/rpm',
    prog_perl      => '%path_prefix%/bin/perl',
    mode_quiet     => 0,
    mode_verbose   => 0,
    run_version    => 0,
    run_help       => 0,
};

#   cleanup support
my @cleanup = ();
sub cleanup_remember {
    my ($cmd) = @_;
    push(@cleanup, $cmd);
}
sub cleanup_perform {
    foreach my $cmd (reverse @cleanup) {
        &runcmd($cmd);
    }
}

#   exception handling support
$SIG{__DIE__} = sub {
    my ($err) = @_;
    $err =~ s|\s+at\s+.*||s if (not $CF->{mode_verbose});
    print STDERR "$ME->{prog_name}:ERROR: $err ". ($! ? "($!)" : "") . "\n";
    &cleanup_perform() if (not $CF->{mode_verbose});
    exit(1);
};

#   verbose message printing
sub verbose {
    my ($msg) = @_;
    print STDERR "++ $msg\n" if (not $CF->{mode_quiet});
}

#   expand into a full filesystem path
sub fullpath {
    my ($prog) = @_;
    my $fullprog = '';
    foreach my $path (split(/:/, $ENV{PATH})) {
        if (-x "$path/$prog") {
            $fullprog = "$path/$prog";
            last;
        }
    }
    return $fullprog;
}

#   execution of external commands
sub runcmd {
    my ($cmd) = @_;
    print STDERR "\$ $cmd\n" if ($CF->{mode_verbose});
    $cmd = "($cmd) >/dev/null 2>&1" if ($CF->{mode_quiet});
    return (system($cmd) == 0);
}

#   create a directory (plus its missing parent dirs)
sub mkdirp {
    my ($dir) = @_;
    my $pdir = $dir;
    $pdir =~ s|/[^/]*$||s;
    if (not -d $pdir) {
        &mkdirp($pdir, 0755);
    }
    if (not -d $dir) {
        &runcmd("umask 022 && mkdir $dir");
    }
}

#   command line parsing
Getopt::Long::Configure("bundling");
my $result = GetOptions(
    'p|prefix=s'    => \$CF->{path_prefix},
    'l|libdir=s'    => \$CF->{path_libdir},
    't|tmpdir=s'    => \$CF->{path_tmpdir},
    'd|wrkdir=s'    => \$CF->{path_wrkdir},
    'r|buildroot=s' => \$CF->{path_buildroot},
    'w|buildwork=s' => \$CF->{path_buildwork},
    'R|rpm=s'       => \$CF->{prog_rpm},
    'P|perl=s'      => \$CF->{prog_perl},
    's|schema=s'    => \$CF->{perl_schema},
    'A|args=s'      => \@{$CF->{perl_args}},
    'I|stdin=s'     => \$CF->{perl_stdin},
    'F|files=s'     => \$CF->{files_file},
    'U|unquoted'    => \$CF->{files_unquoted},
    'n|pkgname=s'   => \$CF->{pkg_name},
    'q|quiet'       => \$CF->{mode_quiet},
    'v|verbose'     => \$CF->{mode_verbose},
    'V|version'     => \$CF->{run_version},
    'h|help'        => \$CF->{run_help}
) || die "option parsing failed";
if ($CF->{run_help}) {
    print "Usage: $ME->{prog_name} [options]\n" .
          "Available options:\n" .
          "\n" .
          " -p, --prefix <dir-path>      filesystem path to OpenPKG instance\n" .
          " -l, --libdir <dir-path>      filesystem path to Perl lib directory\n" .
          " -t, --tmpdir <dir-path>      filesystem path to temporary directory\n" .
          " -d, --wrkdir <dir-path>      filesystem path to working directory\n" .
          " -r, --buildroot <dir-path>   filesystem path to RPM build root directory\n" .
          " -w, --buildwork <dir-path>   filesystem path to RPM build work directory\n" .
          " -R, --rpm <file-path>        filesystem path to RPM program\n" .
          " -P, --perl <file-path>       filesystem path to Perl program\n" .
          "\n" .
          " -s, --schema <schema>        Perl INSTALLDIRS schema\n" .
          " -A, --args <arguments>       Perl Build.PL/Makefile.PL passed through arguments\n" .
          " -I, --stdin <file-path>      filesystem path to connect to stdin\n" .
          " -F, --files <file-path>      filesystem path to write RPM \%files list to\n" .
          " -U, --unquoted               output RPM \%files list in unquoted format\n" .
          " -n, --pkgname <package-name> name of involved RPM package\n" .
          "\n" .
          " -q, --quiet                  operate in quiet   run-time mode\n" .
          " -v, --verbose                operate in verbose run-time mode\n" .
          "\n" .
          " -V, --version                print out program version\n" .
          " -h, --help                   print out program usage help\n";
    exit(0);
}
if ($CF->{run_version}) {
    print "OpenPKG $ME->{prog_name} $ME->{prog_vers} ($ME->{prog_date})\n";
    exit(0);
}

#   fix configuration parameters
foreach my $cf (keys(%{$CF})) {
    $CF->{$cf} =~ s|\%([A-Za-z_][A-Za-z0-9_]*)\%|$CF->{$1}|sge;
}

#   determine operation steps
my @steps_exist = qw(prepare configure build install fixate cleanup);
my @steps_run = ();
if (@ARGV > 0) {
    foreach my $step (@ARGV) {
        if (not grep { $_ eq $step } @steps_exist) {
            die "operation step \"$step\" not existing";
        }
        push(@steps_run, $step);
    }
    my $steps_exist = "-".join("-", @steps_exist)."-";
    my $steps_run   = "-".join("-", @steps_run)."-";
    if ($steps_exist !~ m|^.*${steps_run}.*$|s) {
        die "invalid operation step order \"".join(" ", @ARGV)."\"";
    }
}
else {
    @steps_run = @steps_exist;
}

#   friendly header ;-)
&verbose("OpenPKG $ME->{prog_name} $ME->{prog_vers} ($ME->{prog_date})");

#   determine RPM program
if (not -x $CF->{prog_rpm}) {
    $CF->{prog_rpm} = &fullpath($CF->{prog_rpm});
}
my $V = `$CF->{prog_rpm} --version 2>/dev/null`;
$V =~ s/^(?:rpm \(OpenPKG RPM\)|RPM version|OpenPKG RPM|rpm\s+\(.+?\))\s+([0-9ab.]+)(\.(?:SNAPSHOT|DEVEL).*)?\s*$/$1/s ||
    die "program '$CF->{prog_rpm}' seems to be not RPM";
&verbose("determined RPM  program: $CF->{prog_rpm} ($V)");

#   determine Perl program
if (not -x $CF->{prog_perl}) {
    $CF->{prog_perl} = &fullpath($CF->{prog_perl});
}
$V = `$CF->{prog_perl} --version 2>/dev/null`;
$V =~ s|^.*This is perl, v?([\d+.]+) .*$|$1|s ||
    die "program '$CF->{prog_perl}' seems to be not Perl";
&verbose("determined Perl program: $CF->{prog_perl} ($V)");

#   check for existing paths
if ($CF->{path_buildroot} eq '') {
    die "RPM build root directory not known (specify one with option --buildroot)";
}
if ($CF->{path_buildwork} eq '') {
    die "RPM build work directory not known (specify one with option --buildwork)";
}
mkdir($CF->{path_buildroot}, 0700);
mkdir($CF->{path_buildwork}, 0700);

##
##  OPERATION SEQUENCE
##

#   establish standard environment
umask(022);

#   determine name of temporary directory
my $tmpdir = $CF->{path_tmpdir};
$tmpdir =~ s|/+$||s;
my $user    = (getlogin() || getpwuid($<) || $ENV{LOGNAME} || $ENV{USERNAME} || "unknown");
my $program = $ME->{prog_name};
my $package = ($CF->{pkg_name} || "unknown");
$tmpdir .= "/$user-$program-$package";

#   determine name of perl wrapper script
my $perlwrap = "$tmpdir/perl.sh";

#   optionally change working directory
my $dir = $CF->{path_wrkdir};
if ($dir ne '') {
    if (not -d $dir) {
        #   be smart and guess correct directory to
        #   reduce special cases during packaging
        $dir =~ s|^.+/||s;
        my $parent = "";
        my $child = $dir;
        $child =~ s|^(.+/)([^/]+)$|$parent = $1, $2|se;
        LOOP: while ($child ne '') {
            foreach my $dir (glob("${parent}${child}*")) {
                if (-d "$parent$dir") {
                    $child = $dir;
                    last LOOP;
                }
            }
            $child =~ s|\W\w+$||s || last;
            last if (-d "$parent$child");
        }
        $dir = "$parent$child";
    }
    chdir($dir) || die "cannot change to working directory \"$dir\"";
}

#   determine Perl configuration
my $pcfg = {};
my $cmd = "$CF->{prog_perl}" .
          " -V:installarchlib    -V:installprivlib" .
          " -V:installsitearch   -V:installsitelib    -V:sitelib_stem" .
          " -V:installvendorarch -V:installvendorlib  -V:vendorlib_stem";
my $out = `$cmd 2>/dev/null || true`;
$out =~ s|^(\S+)='([^'']*)';$|$pcfg->{$1} = $2, ''|mge;

#   ==== COMPAT prolog/epilog ====
if (grep { $_ eq "prolog" or $_ eq "epilog" } @steps_run) {
    print "This is the perl-openpkg >= 20040126 version.\n" .
          "It was redesigned and is incompatible to previous\n" .
          "versions. It does not support prolog/epilog steps.\n" .
          "Please upgrade the package that uses perl-openpkg\n" .
          "or, as a temporary workaround, downgrade perl-openpkg\n";
    die "package/perl-openpkg incompatiblity";
}

#   ==== STEP: 1. prepare ====
if (grep { $_ eq "prepare" } @steps_run) {
    &verbose("step 1: prepare");

    #   establish temporary directory
    system("rm -rf $tmpdir >/dev/null 2>&1");
    mkdir($tmpdir, 0700) || die "cannot create temporary directory '$tmpdir'";

    #   create Perl executable wrapper script
    my $io = new IO::File ">$perlwrap"
        || die "unable to open \"$perlwrap\" for writing";
    print $io
        "#!/bin/sh\n" .
        "exec $CF->{prog_perl} \\\n" .
        " -I$CF->{path_buildroot}$pcfg->{installarchlib}    \\\n" .
        " -I$CF->{path_buildroot}$pcfg->{installprivlib}    \\\n" .
        " -I$CF->{path_buildroot}$pcfg->{installsitearch}   \\\n" .
        " -I$CF->{path_buildroot}$pcfg->{installsitelib}    \\\n" .
        " -I$CF->{path_buildroot}$pcfg->{installvendorarch} \\\n" .
        " -I$CF->{path_buildroot}$pcfg->{installvendorlib}  \\\n" .
        " \"\$@\"\n";
    $io->close();
    &runcmd("chmod 755 $perlwrap");

    #   establish Perl module installation areas
    &mkdirp("$CF->{path_buildroot}$pcfg->{installarchlib}");
    &mkdirp("$CF->{path_buildroot}$pcfg->{installprivlib}");
    &mkdirp("$CF->{path_buildroot}$pcfg->{installsitearch}");
    &mkdirp("$CF->{path_buildroot}$pcfg->{installsitelib}");
    &mkdirp("$CF->{path_buildroot}$pcfg->{installvendorarch}");
    &mkdirp("$CF->{path_buildroot}$pcfg->{installvendorlib}");
}

#   ==== STEP: 2. configure ====
if (grep { $_ eq "configure" } @steps_run) {
    &verbose("step 2: configure");

    #   determine build environment and basic arguments
    my $environment = "";
    my $perl_args = '';
    if (-f "Build.PL" and (system("$perlwrap -MModule::Build -e '1;' >/dev/null 2>&1") >> 8) == 0) {
        #   new-style Module::Build "Build.PL"
        $perl_args .= " installdirs=$CF->{perl_schema}";
        $perl_args .= " --install_path libdoc=remove-me-later";
        $perl_args .= " destdir=$CF->{path_buildroot}";
        if ($CF->{path_prefix} ne '' and $CF->{path_prefix} ne '@l_prefix@') {
            $perl_args .= " install_base=$CF->{path_prefix}";
        }
        if ($CF->{path_libdir} ne '') {
            $perl_args .= " --install_path lib=$CF->{path_libdir}";
        }
        $environment = 'Module::Build';
    }
    elsif (-f "Makefile.PL") { # ExtUtils::MakeMaker is part of the Perl distribution
        #   old-style ExtUtils::MakeMaker "Makefile.PL"
        $perl_args .= " PERL=$perlwrap FULLPERL=$perlwrap";
        $perl_args .= " INSTALLDIRS=$CF->{perl_schema}";
        $perl_args .= " INSTALLMAN3DIR=none INSTALLSITEMAN3DIR=none INSTALLVENDORMAN3DIR=none";
        $perl_args .= " DESTDIR=$CF->{path_buildroot}";
        if ($CF->{path_prefix} ne '' and $CF->{path_prefix} ne '@l_prefix@') {
            $perl_args .= " PREFIX=$CF->{path_prefix}";
        }
        if ($CF->{path_libdir} ne '') {
            $perl_args .= " LIB=$CF->{path_libdir}";
        }
        $environment = 'ExtUtils::MakeMaker';
    }
    else {
        die "neither usable Module::Build \"Build.PL\" nor ExtUtils::MakeMaker \"Makefile.PL\" file found";
    }

    #   determine build-time extra arguments
    #   (assuming that they are either work for both Module::Build and
    #   ExtUtils::MakeMaker or the supplier knows what is used by us)
    if ($#{$CF->{perl_args}} >= 0) {
        my $user_args = join(" ", @{$CF->{perl_args}});
        if ($user_args =~ m|#|) {
            $user_args =~ s|#| $perl_args |;
            $perl_args = $user_args;
        }
        else {
            $perl_args .= " " . $user_args;
        }
    }

    #   determine stdin
    if ($CF->{perl_stdin} ne "-") {
        $perl_args .= " <$CF->{perl_stdin}";
    }

    #   setup the build environment
    if ($environment eq 'Module::Build') {
        &verbose("configuring module via Module::Build environment");
        &runcmd("chmod u+rw Build.PL");
        &runcmd("cp Build.PL Build.PL.orig");
        &runcmd("(cat Build.PL.orig; echo '') | sed -e \"s:\\\$^X:'$perlwrap':g\" >Build.PL");
        &runcmd("$perlwrap ./Build.PL $perl_args")
            or die "failed to \"configure\"";
    }
    elsif ($environment eq 'ExtUtils::MakeMaker') {
        &verbose("configuring module via ExtUtils::MakeMaker environment");
        &runcmd("chmod u+rw Makefile.PL");
        &runcmd("cp Makefile.PL Makefile.PL.orig");
        &runcmd("(cat Makefile.PL.orig; echo '') | sed -e \"s:\\\$^X:'$perlwrap':g\" >Makefile.PL");
        &runcmd("$perlwrap ./Makefile.PL $perl_args")
            or die "failed to \"configure\"";
    }
}

#   ==== STEP: 3. build ====
if (grep { $_ eq "build" } @steps_run) {
    &verbose("step 3: build");

    if (-f "Build.PL" and -f "Build") {
        #   execute Build script
        &verbose("building module via Module::Build environment");
        &runcmd("$perlwrap Build build")
            or die "failed to \"build\"";
    }
    elsif (-f "Makefile.PL" and -f "Makefile") {
        #   execute Makefile procedure
        &verbose("building module via ExtUtils::MakeMaker environment");
        my $make = `$CF->{prog_rpm} --eval '\%{l_make} \%{l_mflags}'`;
        $make =~ s|\n+$||s;
        my $make_args = "PERL=$perlwrap FULLPERL=$perlwrap";
        &runcmd("$make $make_args pure_all")
            or die "failed to \"build\"";
    }
    else {
        die "neither \"Build\" nor \"Makefile\" found in working directory";
    }
}

#   ==== STEP: 4. install ====
if (grep { $_ eq "install" } @steps_run) {
    &verbose("step 4: install");

    if (-f "Build.PL" and -f "Build") {
        #   execute Build script
        &verbose("installing module via Module::Build environment");
        &runcmd("$perlwrap Build install")
            or die "failed to \"install\"";
        &runcmd("rm -rf $CF->{path_buildroot}$CF->{path_prefix}/remove-me-later");
    }
    elsif (-f "Makefile.PL" and -f "Makefile") {
        #   execute Makefile procedure
        &verbose("installing module via ExtUtils::MakeMaker environment");
        my $make = `$CF->{prog_rpm} --eval '\%{l_make} \%{l_mflags}'`;
        $make =~ s|\n+$||s;
        my $make_args = "PERL=$perlwrap FULLPERL=$perlwrap";
        &runcmd("$make $make_args pure_install")
            or die "failed to \"install\"";
    }
    else {
        die "neither \"Build\" nor \"Makefile\" found in working directory";
    }
}

#   ==== STEP: 5. fixate ====
if (grep { $_ eq "fixate" } @steps_run) {
    &verbose("step 5: fixate");

    #   prune installation files
    my $libdir;
    if ($CF->{path_libdir} ne '') {
        $libdir = "$CF->{path_buildroot}$CF->{path_libdir}";
    }
    else {
        $libdir = "$CF->{path_buildroot}$CF->{path_prefix}/lib/perl";
    }
    &runcmd("find $libdir -name perllocal.pod -print | xargs rm -f");
    &runcmd("find $libdir -name .packlist -print | xargs rm -f");
    &runcmd("find $libdir -depth -type d -print | (xargs rmdir >/dev/null 2>&1 || true)");

    #   determine RPM installation file list
    my @files = ();
    if ($CF->{path_libdir} eq '') {
        push(@files, '%not %dir '.$CF->{path_prefix}.'/lib/perl');
        push(@files, '%not %dir '.$pcfg->{installarchlib}.'/auto');
        push(@files, '%not %dir '.$pcfg->{installarchlib});
        push(@files, '%not %dir '.$pcfg->{installprivlib}.'/auto');
        push(@files, '%not %dir '.$pcfg->{installprivlib});
        push(@files, '%not %dir '.$pcfg->{sitelib_stem});
        push(@files, '%not %dir '.$pcfg->{installsitearch}.'/auto');
        push(@files, '%not %dir '.$pcfg->{installsitearch});
        push(@files, '%not %dir '.$pcfg->{installsitelib}.'/auto');
        push(@files, '%not %dir '.$pcfg->{installsitelib});
        push(@files, '%not %dir '.$pcfg->{vendorlib_stem});
        push(@files, '%not %dir '.$pcfg->{installvendorarch}.'/auto');
        push(@files, '%not %dir '.$pcfg->{installvendorarch});
        push(@files, '%not %dir '.$pcfg->{installvendorlib}.'/auto');
        push(@files, '%not %dir '.$pcfg->{installvendorlib});
    }
    else {
        push(@files, $CF->{path_libdir});
    }

    #   output RPM installation file list
    my $out;
    if ($CF->{files_file} eq "-") {
        $out = new IO::Handle;
        $out->fdopen(fileno(STDOUT), "w");
    }
    else {
        $out = new IO::File ">$CF->{files_file}";
    }
    if ($CF->{files_unquoted}) {
        print $out join("\n", @files) . "\n";
    }
    else {
        print $out '"'. join('"'."\n".'"', @files).'"'."\n";
    }
    $out->close();
}

#   ==== STEP: 6. cleanup ====
if (grep { $_ eq "cleanup" } @steps_run) {
    &verbose("step 6: cleanup");

    #   remove temporary directory and its contents
    &runcmd("rm -rf $tmpdir");
}

#   die gracefully...
&verbose("cleaning up environment");
&cleanup_perform();
exit(0);

__END__

##
##  UNIX MANUAL PAGE
##

=pod

=head1 NAME

B<perl-openpkg> - B<OpenPKG Perl Module Build Utility>

=head1 SYNOPSIS

B<perl-openpkg>
[B<-p>|B<--prefix> I<dir-path>]
[B<-D>|B<--libdir> I<dir-path>]
[B<-t>|B<--tmpdir> I<dir-path>]
[B<-d>|B<--wrkdir> I<dir-path>]
[B<-r>|B<--buildroot> I<dir-path>]
[B<-w>|B<--buildwork> I<dir-path>]
[B<-R>|B<--rpm> I<file-path>]
[B<-P>|B<--perl> I<file-path>]
[B<-s>|B<--schema> I<schema>
[B<-A>|B<--args> I<arguments>]
[B<-I>|B<--stdin> I<file-path>]
[B<-F>|B<--files> I<file-path>]
[B<-U>|B<--unquoted>]
[B<-n>|B<--pkgname> I<name>]
[B<-q>|B<--quiet>]
[B<-v>|B<--verbose>]
[I<step> ...]

B<perl-openpkg>
[B<-v>|B<--version>]
[B<-h>|B<--help>]

=head1 DESCRIPTION

The B<perl-openpkg> program is an internal B<OpenPKG> packaging utility
for building C<ExtUtils::MakeMaker> based Perl modules during the build
procedure of Perl module based B<OpenPKG> packages. It provides an
adjustable C<ExtUtils::MakeMaker> environment.

=head1 OPTIONS

The following command line options are available:

=head2 Filesystem Paths

The following command-line options set various filesystem paths.

=over 4

=item B<-p>, B<--prefix> I<dir-path>

Filesystem path to OpenPKG instance. Default is C<@l_prefix@>.

=item B<-l>, B<--libdir> I<dir-path>

Filesystem path to Perl lib directory. Default is
"I<prefix>C</lib/perl>".

=item B<-t>, B<--tmpdir> I<dir-path>

Filesystem path to temporary directory. Default is C<$TMPDIR>,
as provided by the RPM build-time environment.

=item B<-d>, B<--wrkdir> I<dir-path>

Filesystem path to working directory. Default is current working directory
as provided by the RPM build-time environment.

=item B<-r>, B<--buildroot> I<dir-path>

Filesystem path to RPM build root directory. Default is C<$RPM_BUILD_ROOT>,
as provided by the RPM build-time environment.

=item B<-w>, B<--buildwork> I<dir-path>

Filesystem path to RPM build work directory. Default is C<$RPM_BUILD_DIR>,
as provided by the RPM build-time environment.

=item B<-R>, B<--rpm> I<file-path>

Filesystem path to RPM program. Default is "I<prefix>C</bin/openpkg rpm>".

=item B<-P>, B<--perl> I<file-path>

Filesystem path to Perl program. Default is I<prefix>C</bin/perl>.

=back

=head2 OpenPKG Package Information

The following command-line options set various package information.

=over 4

=item B<-s>, B<--schema> I<schema>

Sets the Perl C<INSTALLDIRS> schema. Allowed values are
"C<perl>", "C<site>" and "C<vendor>". The default is "C<vendor>".

=item B<-A>, B<--args> I<arguments>

Sets additional arguments which are passed through on the "C<perl
Makefile.PL>" command line. This option can be specified multiple times,
args are joined with a space between them. If joined args contain a '#' then
it is substituted by the automatically generated args otherwise joined args
are appended to automatically generated args. Default is empty.

=item B<-I>, B<--stdin> I<file-path>

Filesystem path to connect to F<stdin> on the "C<perl Makefile.PL>"
command line. Default is "C</dev/null>". A value of "C<->" means reading
from F<stdin>.

=item B<-F>, B<--files> I<file-path>

Filesystem path to write the RPM C<%files> entries to describing the
packaging list of all installed files. The default is "C<->" meaning
that the list is written to F<stdout>.

=item B<-U>, B<--unquoted>

By default the RPM <%files> list is written with each path entry
enclosed in quotation marks. For raw post-processing, this option allows
the list to be written without enclosing quotation marks.

=item B<-n>, B<--pkgname> I<name>

Name of involved RPM package.

=back

=head2 Run-Time Modes

The following command-line options set various run-time modes.

=over 4

=item B<-q>, B<--quiet>

Operate in quiet run-time mode.

=item B<-v>, B<--verbose>

Operate in verbose run-time mode.

=back

=head2 Stand-Alone Operations

The following command-line options trigger various stand-alone operations.

=over 4

=item B<-V>, B<--version>

Print program version only.

=item B<-h>, B<--help>

Print program usage help only.

=back

=head1 OPERATION STEPS

The operation procedure of B<perl-openpkg> is divided into the following
six distinguished steps:

=over 3

=item B<1. prepare>

This prepares the build environment by optionally creating a temporary
directory and establishing a Perl wrapper script.
This step can be shared between the configuration, building and installation
of multiple modules.

=item B<2. configure>

This configures the Perl module by performing the equivalent of
the command "C<perl Makefile.PL>". This step has to be performed
individually for each particular module.

=item B<3. build>

This builds the Perl module by performing the equivalent of the command
"C<make all>". This step has to be performed individually for each
particular module.

=item B<4. install>

This installs the Perl module by performing the equivalent of the
command "C<make install>". This step has to be performed individually
for each particular module.

=item B<5. fixate>

This fixates the installed files by removing unnecessary ones, fixing
permissions and determining the resulting file list. This step can be
shared between the configuration, building and installation of multiple
modules.

=item B<6. cleanup>

This cleans up the build environment by removing all temporary files.
This step can be shared between the configuration, building and
installation of multiple modules.

=back

By default all operation steps are performed in sequence. Alternatively,
the sequence of steps can be individually specified on the command
line as one or more I<step> arguments. The given sequence of I<step>s
has to be exactly a contiguous sub-sequence of the sequence listed
above. As the extrem cases, it can be "C<prepare configure build install
fixate cleanup>" (the same as not specifying any steps) or just perhaps
"C<build>" (for executing only a particular step).

=head1 EXAMPLE

 #   packaging of single module
 perl-openpkg

 #   packaging of multiple modules
 perl-openpkg prepare
 perl-openpkg -d Foo-1 configure build install
 perl-openpkg -d Bar-2 configure build install
 perl-openpkg -d Baz-3 configure build install
 perl-openpkg fixate cleanup

=head1 HISTORY

The B<perl-openpkg> utility was originally implemented as a small
Bourne-Shell script for use in OpenPKG 1.1. It was later rewritten from
scratch in Perl for OpenPKG 2.0 and especially made more flexible to
reduce the complexity in numerious packages.

=head1 SEE ALSO

perl(1), "C<perldoc ExtUtils::MakeMaker>".

=head1 AUTHORS

Ralf S. Engelschall E<lt>rse@engelschall.comE<gt>.

=cut