Initial thoughts on module packaging

[Mark Reinhold]

At this point we have a basic library CLI and module-system runtime
working, and a plan for how javac will read modularized source trees
and write to modularized output directories [1].  One of the biggest
missing pieces is the packaging tool, so here are some thoughts on
how that might work.

The primary purpose of the packaging tool is to gather one or more
modules from a javac output directory and produce a native package
(e.g., rpm, deb, or ips) which, when installed in the usual manner
on a target machine, uses the library CLI together with appropriate
native tools to install the module.

In concrete terms, the workflow would be something like this (on
Debian Linux):

    $ cat src/modules/com.foo.bar/module-info.java
    module com.foo.bar @ 1.2.3-9 { ... }
    $ javac -modulesourcepath src/modules -d build/modules $FILES
    $ jpkg -m build/modules -d build/packages com.foo.bar
    $ ls build/packages
    com.foo.bar-1.2.3-9.deb
    $ sudo dpkg --install build/packages/com.foo.bar-1.2.3-9.deb

The version and dependence information in the package's control file
would be derived from that of the module-info class file.

The data files in the package would be in the on-disk module-library
format, minus configuration data.  They would install, by default,
into the system's module library at, say, /usr/lib/java/modules.

Once the files are installed then the package's post-installation
script would, essentially, do this:

    $ jmod config com.foo.bar at 1.2.3-9

This would compute a configuration for com.foo.bar, if it's a root
module (i.e., a module with a main class); it would also recompute
the configuration of any existing root module in the library that
depends on com.foo.bar.

To make this work we'll need a new method on the Library class which
can write a partial module library to an arbitrary location, and the
new jmod config subcommand.  These should be straightforward; I'll
hack them up today.

Dalibor -- To start, I suggest you work on the simple case of pure
Java modules.  We'll tackle native libraries, resource files, and
configuration files later on.

- Mark


[1] http://openjdk.java.net/projects/jigsaw/doc/ModulesAndJavac.pdf