root/morphix/trunk/morph-scripts/minimod-gen.pl

#!/usr/bin/perl -w
#
# Licenced under the GNU GPL v2 (www.gnu.org)
#
# The MiniModule generator
#
# This script's purpose is to easily build a mini-module,
# in an interactive way. We'll start with only a few options,
# but this can gradually get more complex. It's only a test,
# but should ease the creation of building your own minimodule...
#
# This script has been made by Alex de Landgraaf, and it's 
# built up in about the same way the morphix CD ISO creator
# was built (by Laurens Buhler). You can be sure i've 'borrowed'
# about 3/4 of his code, as i'm not a perl fanatic. Open Source is good :o)
#

use strict;
use Net::FTP;
use File::Spec;

our $moddir;

# option 1: copy
our %filelist;
# option 2: cmd
our @cmdlist;
# option 3: deb
our @deblist;
# option 4: deblist
our @deblist_list;
our @debfiles_list;
our @repolist;
our @rellist;
our @loclist;
our @localfilelist;
# option 5: homedir
our $homedir = "";

if ($> != 0) {
    print "Sorry, you must be root to start the generator!\n";
    exit 1;
}

main();

sub main {
    our $type;
    our $ret;
    
    print ("\n\tWelcome to the interactive Morphix minimodule generator\n\n");

# Check necessary programs (create_compressed_fs, mkisofs)

    my $ccfs = qx|which create_compressed_fs 2>&1|;
    my $mkisofs = qx|which mkisofs 2>&1|;

    if (($ccfs =~ /no create_compressed_fs in/) || ($mkisofs =~ /no mkisofs in/)) {
        die("Can't find create_compressed_fs and / or mkisofs, install these to run the minimodule generator\n");
    }    

    do {
        $ret = setup_new_module();
    } while $ret != 1;

    do {
        print("Please add an action to the minimodule:\n");
        print("1) Copy a file/dir to the mainmod at boot, or overwrite one if it exists\n");
        print("2) Enter a command to be executed at boot\n");
        print("3) Enter one or more debian packages to be added (experimental, needs dpkg-deb)\n");
        print("4) Enter a filename containing a list of debian packages to download and add\n");
        print("5) Enter a directories name, all files in it will be available in morph's homedir\n");
        print("9) Build the module and exit\n");
        print("0) Abort without building the module\n\n");
        print("> ");
        chomp($type = <STDIN>);
        print("\n");
        
        if ($type == 1) {
            add_copy();
        }
        if ($type == 2) {
            add_cmd();
        }
        if ($type == 3) {
            add_deb();
        }
        if ($type == 4) {
            add_deblist();
        }
        if ($type == 5) {
            add_homedir();
        }
        if ($type == 9) {
            generate_module();
            print("The generator will now exit\n");
            exit 1;
        }
        if ($type == 0) {
            print "Aborted...";
            exit 1;
        }
    }
    while (1); 
    exit 0;
}

# done before the GUI is shown, used as work directory

sub setup_new_module {
    our $i; 
    our $dir;
    our $input;

    print("Enter a directory to place the unpacked module\n");
    for ($i = 0; $i <= 100; $i++) {
        if (!(-e "minimod-$i")) {
            last;
        }
    }
    print("[minimod-$i] > ");
    chomp($dir = <STDIN>);
    if ($dir eq "") {
        $dir = "minimod-$i";
    }
    if (-e "$dir") {
        print "$dir exists, are you sure you want to overwrite it? ";
        print "y/N > ";
        chomp($input = <STDIN>);
        print "\n";
        if (!($input eq "y" || $input eq "Y")) {
            return 0;
        }
        system("rm -r $dir");
    }
    mkdir ($dir,0755) || die "cannot mkdir $dir: $!";
    $moddir = $dir;
    return 1;
}   

### start option section ###

# first option: copy a directory over at boottime

sub add_copy {
    our $src;
    our $dest;
    our $input;

    while(1) {
        print "Enter a filename to be included (the new file), newline to stop\n";
        print "> ";
        chomp($src = <STDIN>);
        print "\n";
        if ($src eq "") {
            last;
        }
        if (!(-e $src)) {
            print "Can't find $src, lets try again\n";
            redo;
        }
        
        print "Enter in which dir it will be placed, or what file it will replace (with path!)\n";
        print "> ";
        chomp($dest = <STDIN>);
        print "\n\n";
        
        $filelist{"$src"} = "$dest";

        our $break = "";
        while ($break eq "") {
            print "Do you want to add another file? (or l for list)\n";
            print "y/N/l > ";
            chomp($input = <STDIN>);
            if ($input eq "y" || $input eq "Y") {
                $break = "false";
            }
            if ($input eq "n" || $input eq "N" || $input eq "") {
                $break = "true";
            }
            if ($input eq "l" || $input eq "L") {
                while (($src,$dest) = each(%filelist)) {
                    print("Source: $src Destination: $dest\n");
                }
                print "\n";
            }
        };
        if ($break eq "true") {
            last;
        }
    }

    if (keys %filelist == 0) {
        print "No files were entered...";
    }
}

# second option: execute a command at boottime

sub add_cmd {
    our $cmd;
    our $input;

    while(1) {
        print "Enter a command to be executed on loading of the module, newline to stop\n";
        print "> ";
        chomp($cmd = <STDIN>);
        print "\n";
        if ($cmd eq "") {
            last;
        }
        
        @cmdlist = (@cmdlist,$cmd);
        our $break = "";
        while ($break eq "") {
            print "Do you want to add another command? (or l for list)\n";
            print "y/N/l > ";
            chomp($input = <STDIN>);
            if ($input eq "y" || $input eq "Y") {
                $break = "false";
            }
            if ($input eq "n" || $input eq "N" || $input eq "") {
                $break = "true";
            }
            if ($input eq "l" || $input eq "L") {
                foreach $cmd (@cmdlist) {
                    print "Command: $cmd\n";
                }
                print "\n";
            }
        };
        if ($break eq "true") {
            last;
        }
    }

    if (scalar @cmdlist == 0) {
        print "No commands were entered...";
    }  
}

# third option: extract a debian package and overlay it at boottime

sub add_deb {
    our $src;
    our $input;

    while(1) {
        print "Enter a package to be included, newline to stop\n";
        print "Note that this won't change the debian package database,\n";
        print "and this is still experimental and might not work...\n";
        print "> ";
        chomp($src = <STDIN>);
        print "\n";
        if ($src eq "") {
            last;
        }
        if (!(-e $src)) {
            print "Can't find $src, lets try again\n";
            redo;
        }

        print "\n\n";
        @deblist = (@deblist,$src);

        our $break = "";
        while ($break eq "") {
            print "Do you want to add another package? (or l for list)\n";
            print "y/N/l > ";
            chomp($input = <STDIN>);
            if ($input eq "y" || $input eq "Y") {
                $break = "false";
            }
            if ($input eq "n" || $input eq "N" || $input eq "") {
                $break = "true";
            }
            if ($input eq "l" || $input eq "L") {
                foreach $src (@deblist) {
                    print "Package: $src\n";
                }
                print "\n";
            }
        };
        if ($break eq "true") {
            last;
        }
    }

    if (scalar @deblist == 0) {
        print "No files were entered...";
    }
}

# forth option: overlay a set of debian packages, which are found & downloaded 
# using the hosts source.list

sub add_deblist {
    our $src;
    our $input;
    our $line;

    while(1) {
        print "Enter a filename containing a list of debian packages\n";
        print "All packages in this list will be downloaded from your apt\n";
        print "mirror in /etc/apt/sources.list and unpacked into a minimod\n";
        print "Make sure you updated using dselect beforehand, please note only ftp repositories are used atm\n";
        print "> ";
        chomp($src = <STDIN>);
        print "\n";
        if ($src eq "") {
            last;
        }       
        if (!(-e $src)) {
            print "Can't find $src, lets try again\n";
            redo;
        }
        else {
            last;
        }
    }
    open(SOURCE, "< $src")
    or die "Couldn't open $src for reading: $!\n";

    while(defined ($line = <SOURCE>)) {
        chomp $line;
        @deblist_list = (@deblist_list,$line);
    }
    close(SOURCE);
}    

# fifth option: use a directory as homedir

sub add_homedir {
    our $src;
    our $input;

    while(1) {
        print "Enter a dir to use as homedirectory, newline to stop\n";
        print "> ";
        chomp($src = <STDIN>);
        print "\n";
        if ($src eq "") {
            last;
        }
        if (!(-e $src)) {
            print "Can't find $src, lets try again\n";
            redo;
        }
        
        $homedir = $src;
        last;
    }
}

### end option section ###

# gets the list of repositories in /etc/apt/sources.list

sub get_repos {
    our @stuff;
    our $line;
    open(SOURCE, "< /etc/apt/sources.list")
    or die "Couldn't open /etc/apt/sources.list for reading: $!\n";
    print("in repos\n");
    while(defined ($line = <SOURCE>)) {
        print("line: $line");
        chomp $line;
        if ($line =~ /^\#/ || $line =~ /^deb-src/) {
            next;
        }
        if ($line eq "") {
            next;
        }
        @stuff = $line =~ /^deb ftp:\/\/(\S+) (\S+)/g;
        if (@stuff ne "") {
            print @stuff;
            print ("\nin stuff\n"); 
            if (($stuff[0] ne "") && ($stuff[1] ne "")) {
                @repolist = (@repolist,$stuff[0]);
                @rellist = (@rellist,$stuff[1]);
            }
        }
    }
    close(SOURCE);
}

# gets the list of packages to be downloaded

sub download_list {
    our $package = $_[0];
    our @filename;
    our $fileloc = "";
    our $line;
    open(SOURCE, "< /var/lib/dpkg/available")
        or die "Couldn't open /var/lib/dpkg/available for reading: $!\n";

    while(defined ($line = <SOURCE>)) {
        chomp $line;
        $filename[0] = "";
        if ($line eq "Package: $package") {
            while(defined ($line = <SOURCE>)) {
        #       print("line is $line\n");
                if (@filename = $line =~ /Filename: (\S+)/) {
                    print("Found $package at $filename[0]!\n");
                    last;
                }
            }
        }
        if ($filename[0] ne "") {
            last;
        }    
    }
    if ($filename[0] eq "") {
        print("Couldn't find $package in /var/lib/dpkg/available,\n");
        print("Make sure you have entered the correct packagename\n");
        print("in your list file!\n");
    }
    return $filename[0];
}

# actually download the debs necessary

sub download_debs {
    our $item;
    our @hostname;
    our $ftp;
    our @path;
    our $foo;
    our $bar;
    our $file;
    our $i;

    foreach $item (@repolist) {
        print("$item\n");
        $hostname[0] = "";
        @hostname = $item =~ /([A-Za-z0-9.]+)/;
        @path = $item =~ /\/(\S+)/;
        if ($hostname[0] ne "") {
            print("Found hostname $hostname[0]");
            last;
        }
    }
    if ($hostname[0] eq "") {
        print("Hostname not found!\n");
        return;
    }
    $ftp = Net::FTP->new($hostname[0]) or die "Can't connect: $@\n";
    $ftp->login("anonymous","anonymous\@abc.com") or die "Couldn't login\n";
 
    print("Logged in to $hostname[0]\n");
    for ($i = 0; $i < scalar(@loclist); $i++) {
        $ftp->cwd("/$path[0]") or die "Couldn't change directory to /$path[0]\n";
        print("In /$path[0]\n");
        print("Downloading $loclist[$i]\n");
        ($foo,$bar,$file) = File::Spec->splitpath($loclist[$i]);
        $ftp->binary();
        $ftp->get($loclist[$i],"$file") or die "Couldn't get $loclist[$i]\n";
        print("adding $file\n");
        @localfilelist = (@localfilelist,$file);
    }
}

sub add_overlay_output {
    our $overlaytype = $_[0];

        if ($overlaytype == 1) {
            # symlink/overlay files 
            print OUT "cp -as \"\$1\"/morphix/deb/* /\n";
        }
        elsif ($overlaytype == 2) {
            print OUT "CURR_TRANS=\"\$(cat /proc/sys/translucency/used)\"\n";
            print OUT "echo \"/ -> \$1/morphix/deb/\" >> /proc/sys/translucency/\$CURR_TRANS\n";
        }
        elsif ($overlaytype == 3) {
            print OUT "OVERLAY=`date +%s`\n";
            print OUT "OVERLAY=\"/tmp/overlay/\$OVERLAY\"\n";
            print OUT "mount -t mini_fo -o \"dir=/,dir2=\$OVERLAY\" / \$1/morphix/deb\n";
        }
}
        
sub generate_module {
    our $minitag = "";
    our $maintag = "";
    our $overlaytype = "";
    our $desc = "";
    our $basename;
    our $text;
    our $input;
    our $src;
    our $dest;
    our $cmd;
    our $count;

    print "\n";
    while ($minitag eq "") {
        print "Enter the /morphix/mini_module tag:\n";
        print "> ";
        chomp($minitag = <STDIN>);
    };
    $minitag = "$minitag\n";
    print "\n";
    print "Enter a description, end with an enter on a blank line:\n";
    do {
        $text = <STDIN>;
        $desc = "$desc$text";
    } while ($text ne "\n");

    while ($maintag eq ""){
        local $input;

        print "Select the main module for which this mini module will be generated:\n";
        print "1) LightGUI\n";
        print "2) Gnome\n";
        print "3) KDE\n";
        print "4) Gamer\n";
        print "5) Bare\n";
        print "6) ALL (generic minimodule, works on everything :)\n";
        print "7) Enter your own\n";
        print "[1-5] > ";
        chomp($input = <STDIN>);
        if ($input == 1) {
            $maintag = "LightGUI\n";
        }
        if ($input == 2) {
            $maintag = "HeavyGUI\n";
        }
        if ($input == 3) {
            $maintag = "KDE\n";
        }
        if ($input == 4) {
            $maintag = "Gamer\n";
        }
        if ($input == 5) {
            $maintag = "Bare\n";
        }
        if ($input == 6) {
            $maintag = "ALL\n";
        }
        if ($input == 7) {
            while ($maintag eq "") {
                print "Enter the /morphix/main_module tag, or ALL for all main modules\nMake sure the tag is exactly correct, otherwise the module won't load! ";
                print "> ";
                chomp($maintag = <STDIN>);
            }
            $maintag = "$maintag\n";
        }
    }

    $maintag = "$maintag\n";

   while ($overlaytype eq ""){
        local $input;

        print "Select the way to overlay files:\n";
        print "1) Symlink (default, messy but more tested)\n";
        print "2) Direct-overlay with translucency (for 0.4-versions)\n";
        print "3) Direct-overlay with mini-fo (for 0.5-versions)\n";
        print "[1-3] > ";
        chomp($input = <STDIN>);
        if ($input == 1) {
            $overlaytype = 1;
        }
        if ($input == 2) {
            $overlaytype = 2;
        }
        if ($input == 3) {
            $overlaytype = 3;
        }
    }

    # generate module

    mkdir ("$moddir/morphix",0755);
    mkdir ("$moddir/morphix/files",0755);
    system ("dd if=/dev/urandom of=$moddir/morphix/files/minimum_minimod_size.junk bs=1k count=2");
    while (($src,$dest) = each(%filelist)) {
        $basename = (split/\//,$src)[-1];       
        system("cp -a $src $moddir/morphix/files/$basename");
    }
    print "\n";
    open (OUT, ">$moddir/morphix/loadmod.sh");
    
    print OUT "#!/bin/sh\n\#\n# This file has been generated by minimod-gen.pl\n\n";
    ### the copy option

    while (($src,$dest) = each(%filelist)) {
        $basename = (split/\//,$src)[-1];
        print OUT "cp -a \"\$1\"/morphix/files/$basename $dest\n";
    }
    
    ### the cmd/execute option

    foreach $cmd (@cmdlist) {
        print OUT "$cmd\n";
    }

    ### the debianpackage list option