Linuxtag CD

[Roland Bauerschmidt <rb@debian.org>]

Hi!

Here is some information I got from Joey. Joey, if something isn't
excatly right, please correct me! Linuxtag seems to be interested (or it
is most likely that they do) in participating in our bootable-system CD.
Klaus Knopper (who made the "famous" Knoppix :) will be porting his
Knoppix from Mandrake to Debian. There should be a list setup by now,
Joey probably knows where it is. There would probably be two flavors of
the CD, 1st, the Linuxtag (or non-free) flavor with StarOffice and
Netscape, and, 2nd, the Debian (or free) flavor where we probably don't
want StarOffice and stuff. Otherwise the CDs would probably be pretty
similar. Those CDs would be paid for by Linuxtag e.V., then.

In addition, we would be able to make a "conventional" installation CD
as we did last year. I would image, at we'd probably want at least the
following on our CD:

 - everything from Section: base
 - everything with Priority <= standard
 - task-x-window-system; xserver-*; and lots more X stuff
 - task-gnome-*
 - task-kde; task-koffice
 - isdn, pppoe, ppp, etc.
 - mozilla (and maybe skipstone ?)
 - latex, xfig, etc.
 - apache, exim (although I'd prefer postfix... :), some ftp daemon,
   nfs stuff, samba, netatalk, php4, bind, and more stuff you might
   want when running a server

I rewrote my small perl script from last year to process a list of
packages and all packages that are needed through dependencies. It'd
attached to this mail and by far not perfect yet. Specifically, the
following things are missing:

 - intelligent handling of virtual packages; currently just the first
   package providing something is added unless there is already a
   package in the list provided the package; of course, we want to chose
   the package with the highest priority. /me need to catch bod on IRC
   for that sometime.
 - output of size of packages, and all that stuff

To use it you need to install perl-apt first:
cvs -d:pserver:anonymous@cvs.debian.org:/cvs/deity login
cvs -d:pserver:anonymous@cvs.debian.org:/cvs/deity co perl-apt
cd perl-apt/libapt-pkg-perl/
perl Makefile.PL
make install

Then, you can use apt-mkpkglist like this:
% apt-mkpkglist --verbose --recommends --suggests inputfile outputfile
where input file a list of packages seperated by newlines contains and
the list with resolved dependencies is written to outputfile. For the
CD, we probably don't want to use --suggests since it makes the list
"quite a big" larger (from 3 packages you can make 980...)

Roland

-- 
Roland Bauerschmidt

#!/usr/bin/perl -w
# vim: nowrap ts=4
# apt-mkpkglist -- create consistent package list with resolved dependencies
# Copyright 2001 Roland Bauerschmidt <rb@debian.org>, GPL
# with lots of help from Brenden O'Dea over mail and IRC...

use strict;
use AptPkg::Config '$_config';
use AptPkg::System '$_system';
use AptPkg::Cache;

(my $self = $0) =~ s#.*/##;
$_config->init();
$_system = $_config->system or die 'system';
$_config->{quiet} = 2;

my @ARGV = $_config->parse_cmdline([
		[ 'v', 'verbose', 'verbose' ],
		[ 'R', 'recommends', 'recommends' ],
		[ 'S', 'suggests', 'suggests' ],
	], @ARGV);

my $input = shift(@ARGV) or die "$self: no input file given\n";
my $output = shift(@ARGV) or die "$self: no output file given\n";
open(IN, "<$input");
open(OUT, ">$output");

my @packages;
my @virtual;
my $cache = AptPkg::Cache->new(0);

foreach(<IN>)
{
	chomp();
	$_ =~ s/ *\#.*//;
	next if($_ eq "");
	push_package($_);
}

foreach(@packages) {
	print OUT $_."\n";
}

sub push_package {
	my $pkg = shift;
	dprintf("processing package %s\n", $pkg);
	if(in_array($pkg, @packages)) {
		dprintf("  already satisfied\n");
		return;
	}
	my @depends;
	
	# for real package we get all the dependencies for later recursion.
	if(defined($cache->{$pkg}{VersionList})) {
		# add all the packages this package depends on into an array, since
		# those dependencies will also have to be satisfied. This is
		# recursive.
		if($cache->{$pkg}{VersionList}[0]{DependsList}) {
			foreach(@{$cache->{$pkg}{VersionList}[0]{DependsList}}) {
				if($_->{DepType} eq "Depends" || $_->{DepType} eq "PreDepends" ||
					$_->{DepType} eq "Recommends" && $_config->get_bool('recommends') ||
					$_->{DepType} eq "Suggests" && $_config->get_bool('suggests')) {
						dprintf("  %s %s\n", lc($_->{DepType}),
							$_->{TargetPkg}->{Name});
						push(@depends, $_->{TargetPkg}{Name});
				}
			}
		}
		# push all the packages this package provides into an array, so we
		# don't need to add any other packages later if dependencies on
		# virtual packages are already satisfied through this package
		if($cache->{$pkg}{ProvidesList}) {
			foreach(@{$cache->{$pkg}{ProvidesList}}) {
				push(@virtual, $_->{Name});
			}
		}
		push(@packages, $pkg);
	# for virtual packages check if dependency is already satisfied,
	# otherwise add a package to satisfy the dependency
	} elsif(!in_array($pkg, @virtual) && defined($cache->{$pkg}{ProvidesList})) {
		dprintf("  virtual package provided by %s\n",
			$cache->{$pkg}->{ProvidesList}[0]{OwnerPkg}{Name});
		# since the code for selecting package with highest priority
		# is not there yet, just take the first one
		push(@depends, $cache->{$pkg}->{ProvidesList}[0]{OwnerPkg}{Name});
		# choose package with highest priority should be done here later
		# it'd be nice if it could be done like this, but it can't
		# need to do this with VerFile
		#my $highest;
		#foreach(@{$cache->{$_}{ProvidesList}}) {
			#print "reverse provides: ".$_->{OwnerPkg}{Name}."\n";
			#push(@depends, $_->{OwnerPkg}{Name});
			#if($highest->{Priority} < $_->{OwnerPkg}{Priority}) {
			#	$highest = $_->{OwnerPkg};
			#}
		#}
		#push(@depends, $highest->{Name});
	}
	
	foreach(@depends) {
		push_package($_) if(!in_array($_, @packages));
	}
}

sub in_array
{
	my $key = shift;
	foreach(@_) {
		return(1) if($key eq $_);
	}
	return(0);
}

sub dprintf
{
	printf(@_) if $_config->get_bool("verbose");
}