0.0.1 LGPL (GNU Lesser General Public License)    
  not rated
Pack a set of files into a .deb file with minimal fuss




debify is a quick packing of files into Debian package (.deb) file.

Why would I want to use this?

Because you just want to package these files, with one command invocation, without having to go through a tutorial first.


* round up everything under a directory package everything under /user/lib/foo to be installed to /alt/lib/foo and save it as foo_0.1.deb.
    $ pack_dir foo_0.1 '< desc >' /usr/lib/foo --dest=/alt/lib
* path stream
    $ find /usr/lib/foo | pack_paths foo_0.1 '< desc >'
* cpio
    $ (cd /usr/lib; find foo | cpio -o) | pack_cpio foo_1.0 '< desc >' --dest==/alt/lib


Keeping track of a set of related files as a package in a single namespace gets you 80% of the benefit of packaging with minimal efforts.  This is true even if you leave out facilities such as dependency management. Consider the alternative: without a convenient way to package files, one often ends up resorting to unmanaged installation options. 

The goal:

is to reduce packing friction so that it is practical to manage the apps and dependencies with the OS-native package management system.

This gives
  - a single name space to manage applications and dependencies
  - ability to deinstall them
  - archive of dependencies as .deb files for efficient and reproducible of a configuration

These goals are not achieved by installation and deployment methods such as:
  - rsync
  - ./configure; make install
  - language-specific installers: cpan, setuptools
  - fabric

These methods install, copy, automate but they do not manage packages.

The approach:

is to work with application-specific installation methods to pack the bits into .deb packages. Right now, the user has to build the list of files installed. The plan is to support automated capture and packaging of common installation methods such as:
  - make install
  - easy_install
  - cpan

How do I capture installed files?

To capture installed files, you can do something like:
    # take a snapshot. most things install somehere under /usr/..
  $ find /usr/ | sort > x.pre
  $ sudo make install          # or easy_install or cpan...
  $ find /usr/ | sort >
  $ comm -23 x.pre > x.installed-files
    # inspect the list to see if it makes sense.
  $ less x.installed-files
    # debify
  $ cat x.installed-files | pack_paths foo_0.1 ''
    # Install the package over the current image (installed files).
    # This has the effect of taking the unmanaged app under the control of debian package system.
  $ sudo dpkg -i foo_0.1.deb
    # You can clean it up like this. The .deb file can be stashed away for later deployment.
  $ sudo dpkg -r foo_0.1

Having a jail/chroot sandbox environment would make this much faster and more flexible. But that would be another project..
Last updated on February 26th, 2011

0 User reviews so far.