Fix ArchLinux image build on non-ArchLinux host

Customize the packages installed on ArchLinux

Setup networkd on ArchLinux

Add the ability to create bootable ArchLinux images

Set the nocow attribute on the image file

identation: newlines proposed (#3)

Fixed a few identation patterns by adding/removing new lines here and there.

There were a lot of cases where I didn't know how to proceed in order to make indentation more consistent. I'd like to suggest
keeping to a coding standard. For python, there is pip8.

You could use a tox.ini to configure it and run it. Maybe, even, add a git-hook to run it and prevent non-compilant code from making
it into the repo.

Here's a minimal setup for a tox.ini file:

    # tox.ini
    [pep8]
    filename = mkosi, *.py
    max-line-length = 132
    # count =
    # exclude =
    # format =
    # hang-closing =
    # ignore =
    # quiet =
    # select =
    # show-pep8 =
    # show-source =
    # statistics =
    # verbose =

More info about this at: https://www.python.org/dev/peps/pep-0008/
Tool to check: https://github.com/PyCQA/pep8

mark root disk writable by default

mkosi: fill in distro version earlier, so that "mkosi summary" can show it

update TODO

Sync after creating partition table (#1)

Otherwise mkfs.* might be invoked before the kernel realizes there are partitions in the loop device.

don't crash if release is not specified (#2)

drop "ro" from the kernel command line

fix invokation without a local build script

add a minimal setuptools script

add a proper LICENSE

embedd unshare.py directly in the main source file, so that we have a single source file only

switch to the srcdir if there is one specified

This way build scripts don't have to switch to the srcdir first.

update .gitignore file

beef up README

optionally change to a specified working directory

mkosi: add support for running arbitrary build logic within the image setup

If an executable script "mkosi.build" exists in the local directory, the
build logic will now build the image twice. First, it will build an
image that the working directory and "mkosi.build" is copied into (under
the assumption the tool is called from a source tree of a project). It
then runs that script inside the image via nspawn, and collects any
output it places in a directory passed as $DESTDIR. Then, it throws the
first image away, builds a new one, this time avoiding any source tree or
script copying. However, as final step of the image preparation the tree
from $DESTDIR is copied into the image.

The first image may optionally contain additional distro packages, on
top of the packages the final image will contain. This is useful for
adding in development headers and suchlike.

The suggested usecase for this is the following: let's say you develop a
project, and want to quickly build an OS image from it, with your
current development tree as source tree for the build, and you want to
build to take place inside an image that resembles the ultimate image to
generate as closely as possible. Hence we first build an image with all
development headers for compiling your project. Then artifacts it
generates are then included in the more minimal second image, which is
the result.

fix logic when run without defaults file

fix swap size display in summary

add new summary verb for showing just the summary

allow comma separated values to be passed to --package=

fix cache management on btrfs

print a summary before starting operation

normalize a few settings before starting operation

move nspawn settings option into PACKAGES section

add an extra argument group for the commands

add "mkosi clean" as verb to remove all generated artifacts

automatically use "mkosi.extra" in the current directory as extra subdir

With this mkosi.default in the local dir may contain config data,
mkosi.nspawn may contain nspawn settings data and mkosi.extra may
contain extra drop-in files for the image.

minor message fixes

optionally copy extra file trees on top of image tree

look for "mkosi.nspawn" in the local directory, and use it if it exists

Similar to "mkosi.default" this is useful for projects that need an
easy way to define an nspawn file in the source tree.

optionally, read additional settings from "default.mkosi" in the local directory

Projects may ship such a file to make it easy to build images from their
tree.

split up main function into seperate functions

fix building ubuntu images

print a nice error when invoked as non-root

apply caller's umask to resulting files

optionally install a .nspawn fiel companion and include it in the SHA256SUM

cache packages if possible (on dnf)

clarify which option is supported when in --help

group --help text nicely

add a friendly hint to use --force

make installation of docs optional

fix unshare (i.e. run everything in an fs namespace)

This way, mounts we add won't leak onto the host, and will go away
automatically when we die.

update TODO

optionally sign the result

add README

optionally mark root subvolume read-only

optionally enable btrfs compression

fix log messages

add support for calculating SHA256SUM

Initial commit