File Coverage

blib/lib/Rex/Apache/Build/rpm.pm

Criterion	Covered	Total	%
statement	16	18	88.8
branch			n/a
condition			n/a
subroutine	6	6	100.0
pod			n/a
total	22	24	91.6

#
# (c) Jan Gehring
#
# vim: set ts=3 sw=3 tw=0:
# vim: set expandtab:

=head1 NAME

Rex::Apache::Build::rpm - Build rpm packages

=head1 DESCRIPTION

With this module you can build RedHat packages to distribute your application.

=head1 SYNOPSIS

 build "my-software",
    type    => "rpm",
    version => "1.0",
    source  => "/path/to/your/software",
    path    => "/path/to/deploy/target",
    # below this, it is all optional
    description    => "some description of your package",
    url            => "website of the package",
    depends        => [qw/httpd perl/],
    release        => 1,
    epoch          => 1,
    vendor         => "some vendor",
    license        => "your license for ex. GPL2",
    section        => "some/section",
    conflicts      => [qw/somepkg/],
    provides       => "some-package-name",
    arch           => "x86_64",
    target         => "linux / the platform",
    post_install   => "filename or script to run after installation",
    pre_install    => "filename or script to run before installation",
    post_uninstall => "filename or script to run after uninstall",
    pre_uninstall  => "filename or script to run before uninstall",
    exclude        => [qw/file1 file2/],
    maintainer     => "your name",
    config_files   => [qw/special files for configuration mostly for etc directory/];


=cut

package Rex::Apache::Build::rpm;

use strict;
use warnings;
use attributes;

use Cwd qw(getcwd);
use Digest::MD5;
use Rex::Logger;
use Rex::Commands::Run;
use Rex::Commands::Fs;
use Rex::Commands::File;
use Rex::Template;
use Data::Dumper;

use Rex::Apache::Build::Base;
use base qw(Rex::Apache::Build::Base);

sub new {
   my $that = shift;
   my $proto = ref($that) || $that;
   my $self = $proto->SUPER::new(@_);

   bless($self, $proto);

   $self->{license}    ||= "unknown";
   $self->{file_user}  ||= "root";
   $self->{file_group} ||= "root";
   $self->{release}    ||= 1;
   $self->{exclude}    ||= [];

   push(@{ $self->{exclude} }, qr{^Rexfile$}, qr{^Rexfile\.lock$}, qr{^\.git}, qr{^\.svn}, qr{.*~$}, qr{\.sw[a-z]$}, qr{\.rpm$});

   return $self;
}

sub build {
   my ($self, $name) = @_;

   $name ||= $self->name;

   mkdir "temp-rpm-build";
   mkdir "temp-rpm-build/tree";
   mkdir "temp-rpm-build/tree" . $self->prefix;

   my @dirs  = $self->find_dirs;
   push(@dirs, $self->prefix);

   my @files = $self->find_files;

   file "temp-rpm-build/$name.spec",
      content => template('@spec.template', pkg => $self, cur_dir => getcwd(), files => \@files, dirs => \@dirs);

   chdir "temp-rpm-build";

   my $rpmbuild_path = Rex::Config->get("rpmbuild") || "rpmbuild";
   run "$rpmbuild_path --buildroot=" . getcwd() . "/tree -bb $name.spec";

   chdir "..";

   my $arch = $self->arch;
   cp "temp-rpm-build/$arch/*.rpm", ".";

   rmdir "temp-rpm-build";

   my $build_file = "$name-" . $self->version . "-" . $self->release . "." . $self->arch . ".rpm";
   Rex::Logger::info("Your build is now available: $build_file");

   return $build_file;
}

sub find_files {
   my ($self) = @_;

   my @ret;

   my @dirs = ($self->{source});
   for my $dir (@dirs) {
      opendir(my $dh, $dir) or die($!);
      while(my $entry = readdir($dh)) {
         next if($entry eq ".");
         next if($entry eq "..");

         if(-d "$dir/$entry") {
            push(@dirs, "$dir/$entry");
            next;
         }

         Rex::Logger::debug("Adding file: " . getcwd() . "/$dir/$entry => $dir/$entry");
         push(@ret, [getcwd() . "/$dir/$entry", "$dir/$entry"]);
      }
      closedir($dh);
   }

   # free conffiles
   for my $conf (@{ $self->config_files }) {
      @ret = grep { $_->[0] !~ m/$conf/ } @ret;
   }

   my $top = $self->source . "/";
   map { $_->[1] =~ s/^$top// } @ret;

   Rex::Logger::debug("==== files ====");
   Rex::Logger::debug(Dumper(\@ret));

   return @ret;
}

sub find_dirs {
   my ($self) = @_;

   my @ret;

   my @dirs = ($self->{source});
   for my $dir (@dirs) {
      opendir(my $dh, $dir) or die($!);
      while(my $entry = readdir($dh)) {
         next if($entry eq ".");
         next if($entry eq "..");

         if(-d "$dir/$entry") {
            push(@dirs, "$dir/$entry");

            Rex::Logger::debug("Adding directory: $dir/$entry");
            push(@ret, "$dir/$entry");
         }

      }
      closedir($dh);
   }

   my $top = $self->source;
   map { s/^$top//; $_ = $self->prefix . $_ } @ret;

   Rex::Logger::debug("==== directories ====");
   Rex::Logger::debug(Dumper(\@ret));

   return @ret;
}



1;

__DATA__