Chapter 8. More Examples

Table of Contents

8.1. Cherry-pick templates
8.2. No Makefile (shell, CLI)
8.3. Makefile (shell, CLI)
8.4. setup.py (Python3, CLI)
8.5. Makefile (shell, GUI)
8.6. setup.py (Python3, GUI)
8.7. Makefile (single-binary package)
8.8. Makefile.in + configure (single-binary package)
8.9. Autotools (single-binary package)
8.10. CMake (single-binary package)
8.11. Autotools (multi-binary package)
8.12. CMake (multi-binary package)
8.13. Internationalization
8.14. Details

There is an old Latin saying: “fabricando fit faber” (“practice makes perfect”).

It is highly recommended to practice and experiment with all the steps of Debian packaging with simple packages. This chapter provides you with many upstream cases for your practice.

This should also serve as introductory examples for many programing topics.

Please note that Debian takes a few things seriously:

The typical packaging example presented in Chapter 4, Simple Example is the prerequisite for this chapter.

Some details are intentionally left vague in the following sections. Please try to read the pertinent documentation and practice yourself to find them out.

Tip

The best source of a packaging example is the current Debian archive itself. Please use the “Debian Code Search” service to find pertinent examples.

Here is an example of creating a simple Debian package from a zero content source on an empty directory.

This is a good platform to get all the template files without making a mess in the upstream source tree you are working on.

Let’s assume this empty directory to be debhello-0.1.

        

Let’s generate the maximum amount of template files by specifying the -x4 option.

Let’s also use the “-p debhello -t -u 0.1 -r 1” options to make the missing upstream tarball.

 ...

 ...

Let’s inspect generated template files.

 ...

Now you can copy any of these generated template files in the debhello-0.1/debian/ directory to your package as needed while renaming them as needed.

Tip

The generated template files can be made more verbose by invoking the debmake command with the -T option (tutorial mode).

Here is an example of creating a simple Debian package from a POSIX shell CLI program without its build system.

Let’s assume this upstream tarball to be debhello-0.2.tar.gz.

This type of source has no automated means and files must be installed manually.

 $ tar -xzmf debhello-0.2.tar.gz
 $ cd debhello-0.2
 $ sudo cp scripts/hello /bin/hello
 ...

Let’s get the source and make the Debian package.

Download debhello-0.2.tar.gz

        

Here, the POSIX shell script hello is a very simple one.

hello (v=0.2). 

        

Here, hello.desktop supports the Desktop Entry Specification.

hello.desktop (v=0.2). 

        

Here, hello.png is the icon graphics file.

Let’s package this with the debmake command. Here, the -b':sh' option is used to specify that the generated binary package is a shell script.

...

Let’s inspect notable template files generated.

The source tree after the basic debmake execution. (v=0.2). 

        

debian/rules (template file, v=0.2): 

        

This is essentially the standard debian/rules file with the dh command. Since this is the script package, this template debian/rules file has no build flag related contents.

debian/control (template file, v=0.2): 

        

Since this is the shell script package, the debmake command sets “Architecture: all” and “Multi-Arch: foreign”. Also, it sets required substvar parameters as “Depends: ${misc:Depends}”. These are explained in Chapter 5, Basics.

Since this upstream source lacks the upstream Makefile, that functionality needs to be provided by the maintainer. This upstream source contains only a script file and data files and no C source files; the build process can be skipped but the install process needs to be implemented. For this case, this is achieved cleanly by adding the debian/install and debian/manpages files without complicating the debian/rules file.

Let’s make this Debian package better as the maintainer.

debian/rules (maintainer version, v=0.2): 

        

debian/control (maintainer version, v=0.2): 

        

Warning

If you leave “Section: unknown” in the template debian/control file unchanged, the lintian error may cause a build failure.

debian/install (maintainer version, v=0.2): 

        

debian/manpages (maintainer version, v=0.2): 

        

There are several other template files under the debian/ directory. These also need to be updated.

Template files under debian/. (v=0.2): 

        

You can create a non-native Debian package using the debuild command (or its equivalents) in this source tree. The command output is very verbose and explains what it does as follows.

 ...

 ...

 ...

 ...

Let’s inspect the result.

The generated files of debhello version 0.2 by the debuild command: 

        

You see all the generated files.

  • The debhello_0.2.orig.tar.gz file is a symlink to the upstream tarball.
  • The debhello_0.2-1.debian.tar.xz file contains the maintainer generated contents.
  • The debhello_0.2-1.dsc file is the meta data file for the Debian source package.
  • The debhello_0.2-1_all.deb file is the Debian binary package.
  • The debhello_0.2-1_amd64.build file is the build log file.
  • The debhello_0.2-1_amd64.buildinfo file is the meta data file generated by dpkg-genbuildinfo(1).
  • The debhello_0.2-1_amd64.changes file is the meta data file for the Debian binary package.

The debhello_0.2-1.debian.tar.xz file contains the Debian changes to the upstream source as follows.

The compressed archive contents of debhello_0.2-1.debian.tar.xz

        

The debhello_0.2-1_amd64.deb file contains the files to be installed as follows.

The binary package contents of debhello_0.2-1_all.deb

        

Here is the generated dependency list of debhello_0.2-1_all.deb.

The generated dependency list of debhello_0.2-1_all.deb

        

Here is an example of creating a simple Debian package from a POSIX shell CLI program using the Makefile as its build system.

Let’s assume its upstream tarball to be debhello-1.0.tar.gz.

This type of source is meant to be installed as a non-system file as:

 $ tar -xzmf debhello-1.0.tar.gz
 $ cd debhello-1.0
 $ make install

Debian packaging requires changing this “make install” process to install files to the target system image location instead of the normal location under /usr/local.

Let’s get the source and make the Debian package.

Download debhello-1.0.tar.gz

        

Here, the Makefile uses $(DESTDIR) and $(prefix) properly. All other files are the same as in Section 8.2, “No Makefile (shell, CLI)” and most of the packaging activities are the same.

Makefile (v=1.0). 

        

Let’s package this with the debmake command. Here, the -b':sh' option is used to specify that the generated binary package is a shell script.

...

Let’s inspect the notable template files generated.

debian/rules (template file, v=1.0): 

        

Let’s make this Debian package better as the maintainer.

debian/rules (maintainer version, v=1.0): 

        

Since this upstream source has the proper upstream Makefile, there is no need to create debian/install and debian/manpages files.

The debian/control file is exactly the same as the one in Section 8.2, “No Makefile (shell, CLI)”.

There are several other template files under the debian/ directory. These also need to be updated.

Template files under debian/. (v=1.0): 

        

The rest of the packaging activities are practically the same as the ones in Section 8.2, “No Makefile (shell, CLI)”.

Here is an example of creating a simple Debian package from a Python3 CLI program using setup.py as its build system.

Let’s assume its upstream tarball to be debhello-1.1.tar.gz.

This type of source is meant to be installed as a non-system file as:

 $ tar -xzmf debhello-1.1.tar.gz
 $ cd debhello-1.1
 $ python3 setup.py install

Debian packaging requires changing the last line to “python3 setup.py install --install-layout=deb” to install files into the target system image location. This issue is automatically addressed when using the dh command for Debian packaging.

Let’s get the source and make the Debian package.

Download debhello-1.1.tar.gz

        

Here, the hello script and its associated hello_py module are as follows.

hello (v=1.1). 

        

hello_py/__init__.py (v=1.1). 

        

These are packaged using the Python distutils with the setup.py and MANIFEST.in files.

setup.py (v=1.1). 

        

MANIFEST.in (v=1.1). 

        

Tip

Many modern Python packages are distributed using setuptools. Since setuptools is an enhanced alternative to distutils, this example is useful for them.

Let’s package this with the debmake command. Here, the -b':py3' option is used to specify the generated binary package containing Python3 script and module files.

...

Let’s inspect the notable template files generated.

debian/rules (template file, v=1.1): 

        

This is essentially the standard debian/rules file with the dh command.

The use of the “--with python3” option invokes dh_python3 to calculate Python dependencies, add maintainer scripts to byte compiled files, etc. See dh_python3(1).

The use of the “--buildsystem=pybuild” option invokes various build systems for requested Python versions in order to build modules and extensions. See pybuild(1).

debian/control (template file, v=1.1): 

        

Since this is the Python3 package, the debmake command sets “Architecture: all” and “Multi-Arch: foreign”. Also, it sets required substvar parameters as “Depends: ${python3:Depends}, ${misc:Depends}”. These are explained in Chapter 5, Basics.

Let’s make this Debian package better as the maintainer.

debian/rules (maintainer version, v=1.1): 

        

debian/control (maintainer version, v=1.1): 

        

The hello command does not come with the upstream-provided manpage; let’s add it as the maintainer.

debian/manpages etc. (maintainer version, v=1.1): 

        

There are several other template files under the debian/ directory. These also need to be updated.

The rest of the packaging activities are practically the same as the ones in Section 8.3, “Makefile (shell, CLI)”.

Template files under debian/. (v=1.1): 

        

Here is the generated dependency list of debhello_1.1-1_all.deb.

The generated dependency list of debhello_1.1-1_all.deb

        

Here is an example of creating a simple Debian package from a POSIX shell GUI program using the Makefile as its build system.

This upstream is based on Section 8.3, “Makefile (shell, CLI)” with enhanced GUI support.

Let’s assume its upstream tarball to be debhello-1.2.tar.gz.

Let’s get the source and make the Debian package.

Download debhello-1.2.tar.gz

        

Here, the hello has been re-written to use the zenity command to make this a GTK+ GUI program.

hello (v=1.2). 

        

Here, the desktop file is updated to be Terminal=false as a GUI program.

hello.desktop (v=1.2). 

        

All other files are the same as in Section 8.3, “Makefile (shell, CLI)”.

Let’s package this with the debmake command. Here, the -b':sh' option is used to specify that the generated binary package is a shell script.

...

Let’s inspect the notable template files generated.

debian/control (template file, v=1.2): 

        

Let’s make this Debian package better as the maintainer.

debian/control (maintainer version, v=1.2): 

        

Please note the manually added zenity dependency.

The debian/rules file is exactly the same as the one in Section 8.3, “Makefile (shell, CLI)”.

There are several other template files under the debian/ directory. These also need to be updated.

Template files under debian/. (v=1.2): 

        

The rest of the packaging activities are practically the same as in Section 8.3, “Makefile (shell, CLI)”.

Here is the generated dependency list of debhello_1.2-1_all.deb.

The generated dependency list of debhello_1.2-1_all.deb

        

Here is an example of creating a simple Debian package from a Python3 GUI program using the setup.py as its build system.

This upstream is based on Section 8.4, “setup.py (Python3, CLI)” with enhanced GUI, desktop icon, and manpage support.

Let’s assume this upstream tarball to be debhello-1.3.tar.gz.

Let’s get the source and make the Debian package.

Download debhello-1.3.tar.gz

        

Here are the upstream sources.

hello (v=1.3). 

        

hello_py/__init__.py (v=1.3). 

        

setup.py (v=1.3). 

        

MANIFEST.in (v=1.3). 

        

Let’s package this with the debmake command. Here, the -b':py3' option is used to specify that the generated binary package contains Python3 script and module files.

...

The result is practically the same as in Section 8.4, “setup.py (Python3, CLI)”.

Let’s make this Debian package better as the maintainer.

debian/rules (maintainer version, v=1.3): 

        

debian/control (maintainer version, v=1.3): 

        

Please note the manually added python3-gi and gir1.2-gtk-3.0 dependencies.

Since this upstream source has a manpage and other files with matching entries in the setup.py file, there is no need to create them and add the debian/install and debian/manpages files that were required in Section 8.4, “setup.py (Python3, CLI)”.

The rest of the packaging activities are practically the same as in Section 8.4, “setup.py (Python3, CLI)”.

Here is the generated dependency list of debhello_1.3-1_all.deb.

The generated dependency list of debhello_1.3-1_all.deb

        

Here is an example of creating a simple Debian package from a simple C source program using the Makefile as its build system.

This is an enhanced upstream source example for Chapter 4, Simple Example. This comes with the manpage, the desktop file, and the desktop icon. This also links to an external library libm to be a more practical example.

Let’s assume this upstream tarball to be debhello-1.4.tar.gz.

This type of source is meant to be installed as a non-system file as:

 $ tar -xzmf debhello-1.4.tar.gz
 $ cd debhello-1.4
 $ make
 $ make install

Debian packaging requires changing this “make install” process to install files into the target system image location instead of the normal location under /usr/local.

Let’s get the source and make the Debian package.

Download debhello-1.4.tar.gz

        

Here, the contents of this source are as follows.

src/hello.c (v=1.4): 

        

src/config.h (v=1.4): 

        

Makefile (v=1.4): 

        

Please note that this Makefile has the proper install target for the manpage, the desktop file, and the desktop icon.

Let’s package this with the debmake command.

...

The result is practically the same as in Section 4.5, “Step 2: Generate template files with debmake”.

Let’s make this Debian package, which is practically the same as in Section 4.6, “Step 3: Modification to the template files”, better as the maintainer.

If the DEB_BUILD_MAINT_OPTIONS environment variable is not exported in debian/rules, lintian warns "W: debhello: hardening-no-relro usr/bin/hello" for the linking of libm.

The debian/control file makes it exactly the same as the one in Section 4.6, “Step 3: Modification to the template files”, since the libm library is always available as a part of libc6 (Priority: required).

There are several other template files under the debian/ directory. These also need to be updated.

Template files under debian/. (v=1.4): 

        

The rest of the packaging activities are practically the same as the one in Section 4.7, “Step 4: Building package with debuild”.

Here is the generated dependency list of all binary packages.

The generated dependency list of all binary packages (v=1.4): 

        

Here is an example of creating a simple Debian package from a simple C source program using Makefile.in and configure as its build system.

This is an enhanced upstream source example for Section 8.7, “Makefile (single-binary package)”. This also links to an external library, libm, and this source is configurable using arguments to the configure script, which generates the Makefile and src/config.h files.

Let’s assume this upstream tarball to be debhello-1.5.tar.gz.

This type of source is meant to be installed as a non-system file, for example, as:

 $ tar -xzmf debhello-1.5.tar.gz
 $ cd debhello-1.5
 $ ./configure --with-math
 $ make
 $ make install

Let’s get the source and make the Debian package.

Download debhello-1.5.tar.gz

        

Here, the contents of this source are as follows.

src/hello.c (v=1.5): 

        

Makefile.in (v=1.5): 

        

configure (v=1.5): 

        

Please note that the configure command replaces strings with @…@ in Makefile.in to produce Makefile and creates src/config.h.

Let’s package this with the debmake command.

...

The result is similar to Section 4.5, “Step 2: Generate template files with debmake” but not exactly the same.

Let’s inspect the notable template files generated.

debian/rules (template file, v=1.5): 

        

Let’s make this Debian package better as the maintainer.

debian/rules (maintainer version, v=1.5): 

        

There are several other template files under the debian/ directory. These also need to be updated.

The rest of the packaging activities are practically the same as the one in Section 4.7, “Step 4: Building package with debuild”.

Here is an example of creating a simple Debian package from a simple C source program using Autotools = Autoconf and Automake (Makefile.am and configure.ac) as its build system. See Section 5.16.1, “Autotools”.

This source usually comes with the upstream auto-generated Makefile.in and configure files, too. This source can be packaged using these files as in Section 8.8, “Makefile.in + configure (single-binary package)” with the help of the autotools-dev package.

The better alternative is to regenerate these files using the latest Autoconf and Automake packages if the upstream provided Makefile.am and configure.ac are compatible with the latest version. This is advantageous for porting to new CPU architectures, etc. This can be automated by using the “--with autoreconf” option for the dh command.

Let’s assume this upstream tarball to be debhello-1.6.tar.gz.

This type of source is meant to be installed as a non-system file, for example, as:

 $ tar -xzmf debhello-1.6.tar.gz
 $ cd debhello-1.6
 $ autoreconf -ivf # optional
 $ ./configure --with-math
 $ make
 $ make install

Let’s get the source and make the Debian package.

Download debhello-1.6.tar.gz

        

Here, the contents of this source are as follows.

src/hello.c (v=1.6): 

        

Makefile.am (v=1.6): 

        

configure.ac (v=1.6): 

        

Tip

Without “foreign” strictness level specified in AM_INIT_AUTOMAKE() as above, automake defaults to “gnu” strictness level requiring several files in the top-level directory. See “3.2 Strictness” in the automake document.

Let’s package this with the debmake command.

...

The result is similar to Section 8.8, “Makefile.in + configure (single-binary package)” but not exactly the same.

Let’s inspect the notable template files generated.

debian/rules (template file, v=1.6): 

        

Let’s make this Debian package better as the maintainer.

debian/rules (maintainer version, v=1.6): 

        

There are several other template files under the debian/ directory. These also need to be updated.

The rest of the packaging activities are practically the same as the one in Section 4.7, “Step 4: Building package with debuild”.

Here is an example of creating a simple Debian package from a simple C source program using CMake (CMakeLists.txt and some files such as config.h.in) as its build system. See Section 5.16.2, “CMake”.

The cmake command generates the Makefile file based on the CMakeLists.txt file and its -D option. It also configures the file as specified in its configure_file(…) by replacing strings with @…@ and changing the #cmakedefine … line.

Let’s assume this upstream tarball to be debhello-1.7.tar.gz.

This type of source is meant to be installed as a non-system file, for example, as:

 $ tar -xzmf debhello-1.7.tar.gz
 $ cd debhello-1.7
 $ mkdir obj-x86_64-linux-gnu # for out-of-tree build
 $ cd obj-x86_64-linux-gnu
 $ cmake ..
 $ make
 $ make install

Let’s get the source and make the Debian package.

Download debhello-1.7.tar.gz

        

Here, the contents of this source are as follows.

src/hello.c (v=1.7): 

        

src/config.h.in (v=1.7): 

        

CMakeLists.txt (v=1.7): 

        

Let’s package this with the debmake command.

...

The result is similar to Section 8.8, “Makefile.in + configure (single-binary package)” but not exactly the same.

Let’s inspect the notable template files generated.

debian/rules (template file, v=1.7): 

        

debian/control (template file, v=1.7): 

        

Let’s make this Debian package better as the maintainer.

debian/rules (maintainer version, v=1.7): 

        

debian/control (maintainer version, v=1.7): 

        

There are several other template files under the debian/ directory. These also need to be updated.

The rest of the packaging activities are practically the same as the one in Section 8.8, “Makefile.in + configure (single-binary package)”.

Here is an example of creating a set of Debian binary packages including the executable package, the shared library package, the development file package, and the debug symbol package from a simple C source program using Autotools = Autoconf and Automake (which use Makefile.am and configure.ac as their input files) as its build system. See Section 5.16.1, “Autotools”.

Let’s package this in the same way as in Section 8.9, “Autotools (single-binary package)”.

Let’s assume this upstream tarball to be debhello-2.0.tar.gz.

This type of source is meant to be installed as a non-system file, for example, as:

 $ tar -xzmf debhello-2.0.tar.gz
 $ cd debhello-2.0
 $ autoreconf -ivf # optional
 $ ./configure --with-math
 $ make
 $ make install

Let’s get the source and make the Debian package.

Download debhello-2.0.tar.gz

        

Here, the contents of this source are as follows.

src/hello.c (v=2.0): 

        

lib/sharedlib.h and lib/sharedlib.c (v=1.6): 

        

Makefile.am (v=2.0): 

        

configure.ac (v=2.0): 

        

Let’s package this with the debmake command into multiple packages:

  • debhello: type = bin
  • libsharedlib1: type = lib
  • libsharedlib-dev: type = dev

Here, the -b',libsharedlib1,libsharedlib-dev' option is used to specify the generated binary packages.

...

The result is similar to Section 8.8, “Makefile.in + configure (single-binary package)” but with more template files.

Let’s inspect the notable template files generated.

debian/rules (template file, v=2.0): 

        

Let’s make this Debian package better as the maintainer.

debian/rules (maintainer version, v=2.0): 

        

debian/control (maintainer version, v=2.0): 

        

debian/*.install (maintainer version, v=2.0): 

        

Since this upstream source creates the proper auto-generated Makefile, there is no need to create debian/install and debian/manpages files.

There are several other template files under the debian/ directory. These also need to be updated.

Template files under debian/. (v=2.0): 

        

The rest of the packaging activities are practically the same as the one in Section 8.8, “Makefile.in + configure (single-binary package)”.

Here are the generated dependency list of all binary packages.

The generated dependency list of all binary packages (v=2.0): 

        

Here is an example of creating a set of Debian binary packages including the executable package, the shared library package, the development file package, and the debug symbol package from a simple C source program using CMake (CMakeLists.txt and some files such as config.h.in) as its build system. See Section 5.16.2, “CMake”.

Let’s assume this upstream tarball to be debhello-2.1.tar.gz.

This type of source is meant to be installed as a non-system file, for example, as:

 $ tar -xzmf debhello-2.1.tar.gz
 $ cd debhello-2.1
 $ mkdir obj-x86_64-linux-gnu
 $ cd obj-x86_64-linux-gnu
 $ cmake ..
 $ make
 $ make install

Let’s get the source and make the Debian package.

Download debhello-2.1.tar.gz

        

Here, the contents of this source are as follows.

src/hello.c (v=2.1): 

        

src/config.h.in (v=2.1): 

        

lib/sharedlib.c and lib/sharedlib.h (v=2.1): 

        

CMakeLists.txt (v=2.1): 

        

Let’s package this with the debmake command.

...

The result is similar to Section 8.8, “Makefile.in + configure (single-binary package)” but not exactly the same.

Let’s inspect the notable template files generated.

debian/rules (template file, v=2.1): 

        

Let’s make this Debian package better as the maintainer.

debian/rules (maintainer version, v=2.1): 

        

debian/control (maintainer version, v=2.1): 

        

debian/*.install (maintainer version, v=2.1): 

        

This upstream CMakeList.txt needs to be patched to cope with the multiarch path.

debian/patches/* (maintainer version, v=2.1): 

        

Since this upstream source creates the proper auto-generated Makefile, there is no need to create debian/install and debian/manpages files.

There are several other template files under the debian/ directory. These also need to be updated.

Template files under debian/. (v=2.1): 

        

The rest of the packaging activities are practically the same as the one in Section 8.8, “Makefile.in + configure (single-binary package)”.

Here are the generated dependency list of all binary packages.

The generated dependency list of all binary packages (v=2.1): 

        

Here is an example of updating the simple upstream C source debhello-2.0.tar.gz presented in Section 8.11, “Autotools (multi-binary package)” for internationalization (i18n) and creating the updated upstream C source debhello-2.0.tar.gz.

In the real situation, the package should already be internationalized. So this example is educational for you to understand how this internationalization is implemented.

Tip

The routine maintainer activity for the i18n is simply to add translation po files reported to you via the Bug Tracking System (BTS) to the po/ directory and to update the language list in the po/LINGUAS file.

Let’s get the source and make the Debian package.

Download debhello-2.0.tar.gz (i18n). 

        

Internationalize this source tree with the gettextize command and remove files auto-generated by Autotools.

run gettextize (i18n): 

        

Let’s check generated files under the po/ directory.

files in po (i18n): 

        

Let’s update the configure.ac by adding “AM_GNU_GETTEXT([external])”, etc..

configure.ac (i18n): 

        

Let’s create the po/Makevars file from the po/Makevars.template file.

po/Makevars (i18n): 

        

Let’s update C sources for the i18n version by wrapping strings with _(…).

src/hello.c (i18n): 

        

lib/sharedlib.c (i18n): 

        

The new gettext (v=0.19) can handle the i18n version of the desktop file directly.

data/hello.desktop.in (i18n): 

        

Let’s list the input files to extract translatable strings in po/POTFILES.in.

po/POTFILES.in (i18n): 

        

Here is the updated root Makefile.am with po added to the SUBDIRS environment variable.

Makefile.am (i18n): 

        

Let’s make a translation template file, debhello.pot.

po/debhello.pot (i18n): 

        

Let’s add a translation for French.

po/LINGUAS and po/fr.po (i18n): 

        

The packaging activities are practically the same as the one in Section 8.11, “Autotools (multi-binary package)”.

You can find more i18n examples in Section 8.14, “Details” for

  • the POSIX shell script with Makefile (v=3.0),
  • the Python3 script with distutils (v=3.1),
  • the C source with Makefile.in + configure (v=3.2),
  • the C source with Autotools (v=3.3), and
  • the C source with CMake (v=3.4).

Actual details of the examples presented and their variants can be obtained by the following.

How to get details. 

 $ apt-get source debmake-doc
 $ sudo apt-get install devscripts build-essentials
 $ cd debmake-doc*
 $ sudo apt-get build-dep ./
 $ make

Each directory with the -pkg[0-9] suffix contains the Debian packaging example.

  • emulated console command line activity log: the .log file
  • emulated console command line activity log (short): the .slog file
  • snapshot source tree image after the debmake command: the debmake directory
  • snapshot source tree image after proper packaging: the packge directory
  • snapshot source tree image after the debuild command: the test directory