handling extensions in a canonical (no pun intended)

[Patrick Goetz]

One problem for which I still haven't seen a good solution is how to
handle package extensions in a multi-user environment.  Perhaps an
example would explain what I mean:

We use Thunderbird (locale=en-us) as our default email client.  There
are lots of .xpi extensions which might be useful, but one thing that
lots of people including myself want/use are spell-checking dictionaries
for other languages.  When I'm sending a message to someone in, say
German, having the English language spell-checker turned on is not
fun(tm), and because my German is even worse than my English, I would
like the benefit of my German spelling actually being checked.

On my home (basically) single-user system, this is not a problem; I
download the xpi file and install it from Thunderbird.  The situation is
much more complicated on a multi-user network where we want these
dictionaries (German, French, Spanish, etc.) to be available for all
users ubiquitously and without having thousands of duplicate copies
clogging up the storage system.  Similar concerns apply to firefox and
any other program featuring on-demand feature extensions and add-ons, a
ever growing list of applications/toolkits/frameworks/etc..

We currently solve these problems by using bcfg2 to add specific files
to every installation (possibly restricted by machine group), but a
package-oriented solution would be best, since not everyone uses bcfg2
and since the system is already based on a package paradigm.  Also,
surgically dropping files into a linux installation requires precise
knowledge of where the files must go, permissions, group ownership,
etc., so I/someone has to research this for every single file that gets
added outside the framework of a pre-built binary package.  This adds up
to a lot of work in environments like ours where we have >2500 packages
installed on every workstation.

What has typically been done to address this so far is for package
maintainers to bundle up groups of extensions into "recommended"
packages which can be optionally installed.  This works well for
programs where there are only a handful of well defined extensions, but
is not a good solution for things such as Thunderbird/firefox where
there an exponentially increasing set of potential extensions which one
might want to install.

So, I'm throwing this out there as a Gedanken experiment RFP:  The ideal
would be a package building system which would allow administrators to
assemble a custom-selected group of extensions which would then
automatically be converted to an installable package with dependencies
based on the specific program which is being extended.  For example, I
might decide that I want everyone on my network to automatically have
the German, French, and Spanish dictionaries, enigmail, ReminderFox, and
Nostalgy available when they use Thunderbird.  I would indicate this
somehow (perhaps by downloading the .xpi files) and the system would
automatically build a package for me with these Thunderbird extensions
that I could then add to the list of packages installed on all machines.
  If I want to add/remove extensions, I just rebuild the package and
apt-get install again.  The Thunderbird extensions package would
automatically depend on, at least, some version of the Thunderbird
package and possibly other stuff, depending on the program.  Did I
mention easy to use?  Yes, I/we know how to build debian packages, but
this shouldn't be a prerequisite for administering an ubuntu system.
For example, I don't want to have to know where language dictionaries
get installed; the package builder should have this information built in.