This is a pre-production deployment of Warehouse. Changes made here affect the production instance of PyPI (pypi.python.org).
Help us improve Python packaging - Donate today!

pack a set of files into a .deb file with minimal fuss.

Project Description
debify: pack a set of files into a .deb file with minimal fuss.

* usage:
$ find /usr/lib/python2.6/site-packages/foo | python debify.py pack paths py-foo_0.1 'foo for python'
py-foo_0.1.deb is created

* 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.

* examples:
* 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.
$ debify.py pack dir foo_0.1 '<desc>' /usr/lib/foo --dest=/alt/lib
* path stream
$ find /usr/lib/foo | debify.py pack paths foo_0.1 '<desc>'
* cpio
$ (cd /usr/lib; find foo | cpio -o) | debify.py pack cpio foo_1.0 '<desc>' --dest==/alt/lib

* Motivation
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 > x.post
$ comm -23 x.post x.pre > x.installed-files
# inspect the list to see if it makes sense.
$ less x.installed-files
# debify
$ cat x.installed-files | debify.py pack paths foo_0.1 '<desc>'
# 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..
Release History

Release History

This version
History Node

0.1.3

History Node

0.1.2

History Node

0.1.1

History Node

0.0.1

Download Files

Download Files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

File Name & Checksum SHA256 Checksum Help Version File Type Upload Date
debify-0.1.3.tar.gz (7.9 kB) Copy SHA256 Checksum SHA256 Source Sep 12, 2013

Supported By

WebFaction WebFaction Technical Writing Elastic Elastic Search Pingdom Pingdom Monitoring Dyn Dyn DNS Sentry Sentry Error Logging CloudAMQP CloudAMQP RabbitMQ Heroku Heroku PaaS Kabu Creative Kabu Creative UX & Design Fastly Fastly CDN DigiCert DigiCert EV Certificate Rackspace Rackspace Cloud Servers DreamHost DreamHost Log Hosting