package Iurt::Chroot;

use strict;
use base qw(Exporter);
use MDV::Distribconf::Build;
use MDK::Common;
use Iurt::Process qw(clean sudo);
use Iurt::Config qw(dump_cache_par);
use Iurt::Util qw(plog);
use File::Temp 'mktemp';
use File::Path 'mkpath';

our @EXPORT = qw(
    clean_chroot_tmp
    clean_unionfs
    clean_all_chroot_tmp
    clean_all_unionfs
    clean_chroot
    dump_rpmmacros
    add_local_user
    create_temp_chroot
    remove_chroot
    create_chroot
    create_buid_chroot
    check_chroot
    check_build_chroot
);
    
my $sudo = '/usr/bin/sudo';

=head2 clean_chroot($chroot, $run, $only_clean)

Create or clean a chroot
I<$chroot> chroot path
I<$run> is the running environment
I<%only_clean> only clean the chroot, do not create a new one
Return true.

=cut

sub clean_chroot {
    my ($chroot, $chroot_tar, $run, $config, $o_only_clean, $o_only_tar) = @_;

    plog('DEBUG', "clean chroot");
    if (-d $chroot && !$o_only_tar) {
	system("$sudo umount $chroot/proc &> /dev/null");
	system("$sudo umount $chroot/dev/pts &> /dev/null");
	sudo($run, $config, '--rm', '-r', $chroot);
    }

    return 1 if $o_only_clean;

    mkdir $chroot;

    # various integrity checking
    return 1 if $o_only_tar && -f "$chroot/home/builder/.rpmmacros" && -d "$chroot/home/builder" && -d "$chroot/proc";
 
    chdir $chroot;

    system($sudo, 'tar', 'xf', $chroot_tar) and create_build_chroot($chroot, $chroot_tar, $run, $config);

    create_build_chroot($chroot, $chroot_tar, $run, $config) if !-d "$chroot/proc" || !-d "$chroot/home/builder";

    dump_rpmmacros($run, $config, "$chroot/home/builder/.rpmmacros") or return;
    system("$sudo mount none -t proc $chroot/proc &>/dev/null") and return;
    system("$sudo mount none -t devpts $chroot/dev/pts &>/dev/null") and return;
    1;
}  

sub dump_rpmmacros {
    my ($run, $config, $file) = @_;
    my $f;

    #plog("adding rpmmacros to $file");

    if (!open $f, qq(| $sudo sh -c "cat > $file")) {
	plog("ERROR: could not open $file ($!)");
	return 0;
    }
    my $packager = $run->{packager} || $config->{packager};

    print $f qq(\%_topdir                \%(echo \$HOME)/rpm
\%_tmppath               \%(echo \$HOME)/rpm/tmp/
\%distribution           $config->{distribution}
\%vendor                 $config->{vendor}
\%packager               $packager);
    # need to be root for permission
}

sub add_local_user {
    my ($chroot_tmp, $run, $config, $luser, $uid) = @_;
    my $program_name = $run->{program_name};

    # change the builder user to the local user id
    # FIXME it seems that unionfs does not handle well the change of the
    #       uid of files
    # if (system(qq|sudo chroot $chroot_tmp usermod -u $run->{uid} builder|)) {
    
    # this should not be necessary as the builder user is supposed to have
    # the macros already

    foreach my $p ('RPMS', 'BUILD', 'SPECS', 'SRPMS', 'SOURCES') {
	-d "$chroot_tmp/home/builder/rpm/$p" and next;
	sudo($run, $config, "--mkdir", "$chroot_tmp/home/builder/rpm/$p");
    } 

    dump_rpmmacros($run, $config, "$chroot_tmp/home/builder/.rpmmacros") or return;

    if ($uid) {
	if (system($sudo, 'chroot', $chroot_tmp, 'useradd', '-M', '-u', $uid, $luser) ||
	    system("$sudo chroot $chroot_tmp id $luser >/dev/null 2>&1")) {
	    plog('ERR', "ERROR: setting userid $uid to $luser in " .
		"$chroot_tmp failed, checking the chroot");
	    check_build_chroot($run->{chroot_path}, $run->{chroot_tar}, $run,
		$config) or return;
	}
    } else {
	# the program has been launch as root, setting the home to /home/root for compatibility
	system($sudo, 'chroot', $chroot_tmp, 'usermod', '-d', "/home/$luser", '-u', $uid, '-o', '-l', $luser, 'root');
    }

    if (system(qq($sudo chroot $chroot_tmp cp -R /home/builder /home/$luser))) {
	plog("ERROR: could not initialized $luser directory");
	return;
    }

    if (system(qq($sudo chroot $chroot_tmp chown -R $uid /home/$luser))) {
	die "ERROR $program_name: could not initialized $luser directory\n"; 
    }

    1;
}

sub create_temp_chroot {
    my ($run, $config, $cache, $union_id, $chroot_tmp, $chroot_tar, $srpm) = @_;

    my $home = $config->{local_home};
    my $debug_tag = $run->{debug_tag};
    my $unionfs_dir = $run->{unionfs_dir};

    if ($run->{unionfs_tmp}) {
	my $mount_point = "$unionfs_dir/unionfs.$run->{run}.$union_id";
	plog(2, "cleaning temp chroot $mount_point");
	if (!clean_mnt($run, $mount_point, $run->{verbose})) {
	    dump_cache_par($run);
	    die "FATAL: can't kill remaining processes acceding $mount_point";
	}
	my $tmpfs;

	# we cannont just rm -rf $tmpfs, this create defunct processes
	# afterwards (and lock particularly hard the urpmi database)
	#
	$union_id = clean_unionfs($unionfs_dir, $run, $run->{run}, $union_id);
	$tmpfs = "$unionfs_dir/tmpfs.$run->{run}.$union_id";
	$chroot_tmp = "$unionfs_dir/unionfs.$run->{run}.$union_id";

	if (!-d $tmpfs) {
	    if (!mkpath($tmpfs)) {
		plog("ERROR: Could not create $tmpfs ($!)");
		return;
	    }
	}
	if (! -d $chroot_tmp) {
	    if (!mkpath($chroot_tmp)) {
		plog("ERROR: Could not create $chroot_tmp ($!)");
		return;
	    }
	}
	if ($cache->{no_unionfs}{$srpm}) {
	    $run->{unionfs_tmp} = 0;
	    clean_chroot($chroot_tmp, $chroot_tar, $run, $config);
	} else {
	    # if the previous package has been built without unionfs, chroot need to be cleaned
	    if (!$run->{unionfs_tmp}) {
		clean_chroot($chroot_tmp, $chroot_tar, $run, $config);
	    } else {
		# only detar the chroot if not already
		clean_chroot($chroot_tmp, $chroot_tar, $run, $config, 0, 1);
	    }
	    $run->{unionfs_tmp} = 1;
	    if (system(qq($sudo mount -t tmpfs none $tmpfs &>/dev/null))) {
		plog("ERROR: can't mount $tmpfs ($!)"); 
		return;
	    }
	    if (system(qq($sudo mount -o dirs=$tmpfs=rw:$home/chroot_$run->{distro_tag}$debug_tag=ro -t unionfs none $chroot_tmp &>/dev/null))) {
		plog("ERROR: can't mount $tmpfs and $home/chroot_$run->{distro_tag}$debug_tag with unionfs ($!)");
		return;
	    }
	    if (system("$sudo mount -t proc none $chroot_tmp/proc &>/dev/null")) {
		plog("ERROR: can't mount /proc in chroot $chroot_tmp ($!)");
		return;
	    }
	    if (!-d "$chroot_tmp/dev/pts") {
		if (sudo($run, $config, "--mkdir", "$chroot_tmp/dev/pts")) {
		    plog("ERROR: can't create /dev/pts in chroot $chroot_tmp ($!)");
		    return;
		}

		if (system($sudo, "mount", "-t", "devpts", "none", "$chroot_tmp/dev/pts &>/dev/null")) {
		    plog("ERROR: can't mount /dev/pts in the chroot $chroot_tmp ($!)");
		    return;
		}
	    }
	}
    } else {
	plog("Install new chroot");
	plog('DEBUG', "... in $chroot_tmp");
	clean_chroot($chroot_tmp, $chroot_tar, $run, $config);
    }
    $union_id, $chroot_tmp;
}

sub remove_chroot {
    my ($run, $dir, $func, $prefix) = @_;

    plog("Remove existing chroot");
    plog('DEBUG', "... dir $dir all $run->{clean_all} prefix $prefix");

    if ($run->{clean_all}) {
	opendir my $chroot_dir, $dir;
	foreach (readdir $chroot_dir) {
	    next if !-d "$dir/$_" || /\.{1,2}/;
	    plog("cleaning old chroot for $_ in $dir");
	    $func->($run, "$dir/$_", $prefix);
	}
    } else {
	foreach my $user (@{$run->{clean}}) {
	    plog("cleaning old chroot for $user in $dir");
	    $func->($run, "$dir/$user", $prefix);
	}
    }
} 

sub clean_mnt {
    my ($run, $mount_point, $verbose) = @_;
    return clean($run, $mount_point, "/sbin/fuser", "$sudo /sbin/fuser -k", $verbose);
}

sub clean_all_chroot_tmp {
    my ($run, $chroot_dir, $prefix) = @_;

    plog(1, "cleaning all old chroot remaining dir in $chroot_dir");

    my $dir;
    if (!opendir $dir, $chroot_dir) { 
	plog("ERROR: can't open $chroot_dir ($!)");
	return;
    }
    foreach (readdir($dir)) {
	/$prefix/ or next;
	clean_chroot_tmp($run, $chroot_dir, $_);
    }
    closedir $dir;
}

sub clean_unionfs {
    my ($unionfs_dir, $_run, $r, $union_id) = @_;

    -d "$unionfs_dir/unionfs.$r.$union_id" or return $union_id;
    plog(2, "cleaning unionfs $unionfs_dir/unionfs.$r.$union_id");
    my $nok = 1;
    my $path = "$unionfs_dir/unionfs.$r.$union_id";

    while ($nok) {
	$nok = 0;
	foreach my $fs ([ 'proc', 'proc' ], [ 'dev/pts', 'devpts' ]) {
	    my ($dir, $type) = @$fs;
	    if (-d "$path/$dir" && check_mounted("$path/$dir", $type)) {
		plog(1, "clean_unionfs: umounting $path/$dir\n");
		if (system("$sudo umount $path/$dir &>/dev/null")) { 
		    plog("ERROR: could not umount $path/$dir");
		}
	    }
	}
	foreach my $t ('unionfs', 'tmpfs') {
	    # unfortunately quite oftem the unionfs is busy and could not
	    # be unmounted

	    my $d = "$unionfs_dir/$t.$r.$union_id";
	    if (-d $d && check_mounted($d, $t)) {
		$nok = 1;
		system("$sudo /sbin/fuser -k $d &> /dev/null");
		plog(3, "umounting $d");
		if (system(qq($sudo umount $d &> /dev/null))) {
		    plog(2, "WARNING: could not umount $d ($!)");
		    return $union_id + 1;
		}
	    }
	}
    }

    foreach my $t ('unionfs', 'tmpfs') {
	my $d = "$unionfs_dir/$t.$r.$union_id";
	plog(2, "removing $d");
	if (system($sudo, 'rm', '-rf', $d)) {
	    plog("ERROR: removing $d failed ($!)");
	    return $union_id + 1;
	}
    }
    $union_id;
}

sub clean_chroot_tmp {
    my ($run, $chroot_dir, $dir) = @_;
    my $d = "$chroot_dir/$dir";

    foreach my $m ('proc', 'dev/pts') {
	if (system("$sudo umount $d/$m &>/dev/null") && $run->{verbose} > 1) { 
	    plog("ERROR: could not umount /$m in $d/"); 
	}
    }

    plog(1, "cleaning $d");
    system("$sudo /sbin/fuser -k $d &> /dev/null");
    plog(1, "removing $d");
    system($sudo, 'rm', '-rf', $d);
}

sub check_mounted {
    my ($mount_point, $type) = @_;

    my $mount;
    if (!open $mount, '/proc/mounts') {
	plog("ERROR: could not open /proc/mounts");
	return;
    }
    $mount_point =~ s,//+,/,g;
    local $_;
    while (<$mount>) {
	return 1 if /^\w+ $mount_point $type /;
    }
    0;
}

sub create_build_chroot {
    my ($chroot, $chroot_tar, $run, $config) = @_;
    create_chroot($chroot, $chroot_tar, $run, $config,
			{ packages => $config->{basesystem_packages} });
}

sub create_chroot {
    my ($chroot, $chroot_tar, $run, $config, $opt) = @_;
    my $tmp_tar = mktemp("$chroot_tar.tmp.XXXXXX");
    my $tmp_chroot = mktemp("$chroot.tmp.XXXXXX");
    my $rebuild;
    my $clean = sub {
	plog("Remove temporary chroot tarball");
	sudo($run, $config, '--rm', '-r', $tmp_chroot, $tmp_tar);
    };

    plog('NOTIFY', "creating chroot");
    plog('DEBUG', "... with packages " . join(', ', @{$opt->{packages}}));

    if (mkdir($tmp_chroot) && (!-f $chroot_tar || link $chroot_tar, $tmp_tar)) {
	if (!-f $chroot_tar) {
	    plog("rebuild chroot tarball");
	    $rebuild = 1;
	    if (!build_chroot($run, $config, $tmp_chroot, $chroot_tar, $opt)) {
		$clean->();
		return;
	    }
	} else {
	    plog('DEBUG', "decompressing /var/log/qa from $chroot_tar in $tmp_chroot");
	    system($sudo, 'tar', 'xf', $chroot_tar, '-C', $tmp_chroot, "./var/log/qa");

	    my $qa;
	    if (open $qa, "$tmp_chroot/var/log/qa") {
		my $ok;
		my $f;
		while (!$ok && ($f = <$qa>)) {
		    chomp $f;
		    if (!-f "$config->{basesystem_media_root}/media/$config->{basesystem_media}/$f") {
			plog('DEBUG', "$f has changed");
			plog('NOTIFY', "Rebuilding chroot tarball");

			$rebuild = 1;
			sudo($run, $config, '--rm', '-r', $tmp_chroot);
			mkdir $tmp_chroot;
			if (!build_chroot($run, $config, $tmp_chroot, $chroot_tar, $opt)) { 
			    $clean->();
			    return;
			}
			$ok = 1;
		    }
		}
	    } else {
		plog('DEBUG', "can't open $tmp_chroot/var/log/qa");
		plog('ERR', "can't check chroot, recreating");

		if (!build_chroot($run, $config, $tmp_chroot, $chroot_tar, $opt)) {
		    $clean->();       
		    return;
		}
	    }
	}
	link $tmp_tar, $chroot_tar;
    } else {
	die "FATAL: could not initialize chroot ($!)\n";
    }

    if (!-d $chroot || $rebuild) {
	plog('DEBUG', "recreate chroot $chroot");
	plog('NOTIFY', "recreate chroot");
	my $urpmi = $run->{urpmi};
	$urpmi->clean_urpmi_process($chroot);
	sudo($run, $config, '--rm', '-r', $chroot, $tmp_tar);
	mkdir_p $chroot;
	system($sudo, 'tar', 'xf', $chroot_tar, '-C', $chroot);
	plog('NOTIFY', "chroot recreated in $chroot_tar (live in $chroot)");
    }
    
    $clean->();

    1;
}

sub build_chroot {
    my ($run, $config, $tmp_chroot, $chroot_tar, $opt) = @_;

    plog('DEBUG', "building the chroot with "
			. join(', ', @{$opt->{packages}}));

    sudo($run, $config, "--mkdir", "-p", "$tmp_chroot/dev/pts",
		"$tmp_chroot/etc/sysconfig", "$tmp_chroot/proc");

    # create empty files
    foreach ('/etc/ld.so.conf', '/etc/mtab') {
	system($sudo, 'touch', "$tmp_chroot$_");
    }

    system($sudo, 'mknod', "$tmp_chroot/dev/null", 'c', 1, 3);
    system("$sudo chmod a+rw $tmp_chroot/dev/null");

    #system(qq($sudo sh -c "echo 127.0.0.1 localhost > $tmp_chroot/etc/hosts"));
    # warly some program perform a gethostbyname(hostname) and in the cluster the 
    # name are not resolved via DNS but via /etc/hosts
    sudo($run, $config, '--cp', "/etc/hosts", "$tmp_chroot/etc/");
    sudo($run, $config, '--cp', "/etc/resolv.conf", "$tmp_chroot/etc/");

    sudo($run, $config, "--initdb", $tmp_chroot);
    # install chroot
    my $urpmi = $run->{urpmi};
    $urpmi->set_command($tmp_chroot);

    # 20060826 warly urpmi --root does not work properly
    $urpmi->install_packages(
	"chroot",
	$tmp_chroot,
	$run->{local_spool},
	{},
	'initialize',
	"[ADMIN] creation of initial chroot failed on $run->{my_arch}",
	{ maintainer => $config->{admin} },
	@{$opt->{packages}}
    );

    if (-f "$tmp_chroot/bin/rpm") {
	system($sudo, 'sh', '-c', "chroot $tmp_chroot rpm -qa --qf '\%{NAME}-\%{VERSION}-\%{RELEASE}.\%{ARCH}.rpm\n' > $tmp_chroot/var/log/qa");
	#
	# CM: Choose a sub-500 uid to prevent collison with $luser
	#
	system($sudo, 'chroot', $tmp_chroot, 'adduser', '-o', '--uid', 499, 'builder');
	sudo($run, $config, "--mkdir", "-p", "$tmp_chroot/home/builder/rpm");
	foreach my $p (qw(RPMS BUILD SPECS SRPMS SOURCES tmp)) {
	    -d "$tmp_chroot/home/builder/rpm/$p" and next;
	    sudo($run, $config, "--mkdir", "$tmp_chroot/home/builder/rpm/$p");
	}
	system($sudo, 'chown', '-R', 499, "$tmp_chroot/home/builder");
	sudo($run, $config, "--rm", "$tmp_chroot/var/lib/rpm/__db*");
	return !system($sudo, 'tar', 'czf', $chroot_tar, '-C', $tmp_chroot, '.');
    }
}

sub check_build_chroot {
    my ($chroot, $chroot_tar, $run, $config) = @_;

    check_chroot($chroot, $chroot_tar, $run, $config,
		{ packages => $config->{basesystem_packages} });
}

sub check_chroot {
    my ($chroot, $chroot_tar, $run, $config, $opt) = @_;

    plog('DEBUG', "checking basesystem tar");
    
    my (@stat) = stat $chroot_tar;

    if (time -$stat[9] > 604800) {
	plog('WARN', "chroot tarball too old, force rebuild");
	sudo($run, $config, '--rm', '-r', $chroot, $chroot_tar);
    }
    create_chroot($chroot, $chroot_tar, $run, $config, $opt);
}

sub clean_all_unionfs {
    my ($run, $unionfs_dir) = @_;

    plog(2, "Cleaning old unionfs remaining dir in $unionfs_dir");

    my $dir;
    if (!opendir $dir, $unionfs_dir) {
	plog(0, "FATAL could not open $unionfs_dir ($!)");
	return;
    }

    foreach (readdir $dir) {
	/unionfs\.((?:0\.)?\d+)\.(\d*)$/ or next;
	clean_unionfs($unionfs_dir, $run, $1, $2);
    }

    closedir $dir;
}


1;