Free automated packaging software for linux

Aargh is a code generator, written in C++ and licensed under the terms of the GNU General Public License (GPL). It generates C++ code to parse a command line, using the getopt() facility available in UNIX and UNIX-like environments.
Automated Argument Helper project supports command-line options with integer arguments, string arguments, and no arguments. The generated code is commented and carefully indented for readability.
Its nice to have lots of command line options, but its a real pain to code for them.
Not that its difficult. Its just tedious, time-consuming, error prone, and no fun. I used to wince at the thought of adding command line options.
Not any more. All I have to do is define the options I want in a small XML file, and run it through aargh. Instantly I have C++ source code that I can compile and link into my program.
If I need to add another option, or otherwise change the rules, I can edit the XML and regenerate the code. No muss, no fuss. Now I can spend more time on the interesting parts of the project.
To use aargh, write an XML file to describe the options you want. When aargh reads the file, it generates two C++ files.
One file is a header that declares a class to represent the options. By default this class is named "Opts," but you can specify a different name. The other file is the implementation of Opts, or whatever you decide to call it. The Opts class provides member functions to parse the command line and return the results.
In your own code, declare an instance of Opts and call Opts::get() to parse the command line, passing it the argc and argv arguments from main(). Opts::get() returns zero if the command line follows the rules that you have outlined in the XML file, or non-zero otherwise. If the parsing is successful, the Opts object stores the results and makes them available to your program by a series of accessor functions.
Main features:
- You can enforce upper and/or lower limits on the number of non-option arguments.
- You can distinguish between options that take arguments and those that dont.
- You can specify that an option is required.
- You can require that the argument to an option be a non-negative integer.
- For an integer argument you can enforce upper and/or lower limits.
- For a string argument you can enforce upper and/or lower limits on the string length.
- For a string argument you can call a function of your own to validate the argument.
- You can allow multiple occurrences of the same option. In that case the generated code builds an STL vector to hold the arguments. By default the generated software allows only one occurrence of any given option.
Enhancements:
- You can now specify the location of the generated header file independently of its name.
- This feature may make it easier to incorporate aargh into complex build environments.

NACE is a generic query engine used to automatically create host and service definitions for hosts on the network.

It is intended to be used in a shell script at regular intervals by an experienced Nagios administrator to perform a query against the supplied host list. It then creates host and service definitions using the parameters supplied in the query.

Automated Linux From Scratch (ALFS) is a project that creates the generic framework for an extendable system builder and package installer.

Why would I want to use ALFS?

After having gone through the LFS and BLFS books more than 2 or 3 times, you will quickly appreciate the ability to automate the task of compiling the software you want for your systems.

What can I do with ALFS?

The goal of ALFS is to automate the process of creating an LFS system. It seeks to make the process of building LFS easier and more efficient while still providing flexibility by granting the user total control and insight into the compilation and management of his LFS build.

How is ALFS implemented?

nALFS

The first ALFS implementation was nALFS by Neven Has. nALFS is a small program written in C. It first parses an XML profile that contains information concerning the LFS build process into a series of internal commands. It can then execute these at your discretion, thus automating the compilation of LFS.

jhalfs

Currently, the official implementation is jhalfs. Originally created by Jeremy Huntwork, but since developed and maintained by Manuel Canales Esparcia and George Boudreau, jhalfs has become a light-weight, practical method of automating an LFS build. jhalfs is a Bash shell script that makes use of Subversion and xsltproc to first download the XML sources of the Linux From Scratch book and then extract any necessary commands, placing them into executable shell scripts. If you do not already have the necessary source packages in place on your system jhalfs can fetch them. Finally, jhalfs generates a Makefile which will control the execution of the shell scripts, allowing for recovery if the build should encounter an error. Since jhalfs extracts its commands to run directly from the LFS book, there are no profiles to edit or maintain.

Note: The 2.2 version of jhalfs has been released. A tarball can been downloaded from http://www.linuxfromscratch.org/alfs/downloads/jhalfs/stable/.

alfs

There are many in-depth features that have been requested for future ALFS implementations. Because of this, development has been slated for an entirely new build tool which will be called alfs. To see a list of features that will appear in alfs, please read our Software Requirements Specification. If you wish to help develop this new tool, please subscribe to the alfs-discuss mailing list and leave a note there explaining your desire to help.

Software::Packager is a common software packaging interface.

SYNOPSIS

use Software::Packager;
my $packager = new Software::Packager();
$packager->version(1.2.3.4.5.6);
$packager->package_name("Somename");
$packager->program_name(Software Packager);
$packager->description("This is the description.");
$packager->short_description("This is a short description.");
$packager->output_dir("/home/software/packages");
$packager->category("Applications");
$packager->architecture("sparc");

my %object_data = (
SOURCE => /source/file1,
TYPE => file,
DESTINATION => /usr/local/file1,
USER => joe,
GROUP => staff,
MODE => 0750,
);
$packager->add_item(%object_data);

my $version = $packager->version();
my $name = $packager->package_name();
my $program_name = $packager->program_name();
my $description = $packager->description();
my $description = $packager->short_description();
my $output_directory = $packager->output_dir();
my $category = $packager->category();
my $arch = $packager->architecture();

The Software Packager module is designed to provide a common interface for packaging software on any platform. This module does not do the packaging of the software but is merely a wraper around the various software packaging tools already provided with various operating systems.

This module provides the base API and sets default values common to the various software packaging methods.

phpautotest is a tool for conducting automated regression tests on PHP-driven Web sites. Variable values as well as HTTP output can be tested.

HTTP output is tested using regular expressions.

Wx::Perl::Packager provides a module to assist packaging Wx based applications with PAR, ActiveState PerlApp / PDK and Perl

A module to assist packaging Wx based applications with PAR, ActiveState PerlApp / PDK and Perl2Exe. All that is needed is that you include a use statement as the first item in your BEGIN blocks. For Perl2Exe, an additional use statement outside any BEGIN block ensures correct object cleanup.

Also provided are:

wxpdk
wxpar

which assist in packaging the wxWidgets DLLs.

SILC Autodist is a program which is used to manage and create source distributions.

The Autodist is a source distribution management system that allows powerful mechanisms to define what is included in and excluded from a distribution, and what license the distribution is released under. It is also used to create the actual distribution source packages. Autodist allows distribution management in file, directory and file content level. Different distributions may include different portions of files, for example, excluding certain features from certain distributions. It is always guaranteed that anything not defined for the distribution, is removed automatically (files, file content, directories), thus ensuring that nothing is accidentally included in the distribution.

The Autodist creates Makefile.am files from Makefile.ad files and configure.ac file from one or more configure.ad files. Any other file ending with .ad suffix will also be processed. The processed file will have the .ad suffix removed (see Preparing source tree). Autodist also creates and packages the distribution using common GNU distribution creation process, specificly `make dist. Autodist, however, controls this process and during packaging phase the Autodist processes all files in the distribution (other than *.ad files, which has already been processed earlier by Autodist). The resulted package is a processed source distribution package, processed according to the rules specified in the distribution file(s) (see Creating distribution).

Any file in the source tree may use distdefs (distribution defines (see Distdefines)) which are defined in the distributions. When distribution is packaged only the files, directories and file content that is either outside of any distdef, or inside the defined distdefs will be included in the distribution. Any other file, directory or content in the file will be removed. It is guaranteed, if a file, a directory or a piece of file content is not inside a defined distdef it will not be delivered to the distribution.

Any file, Makefile.am, configure.ac, or source file processed with Autodist is always compliant with the tools needed to process them. All files can also be processed with the corresponding tools even before processing them with Autodist. This makes it possible, for example, to compile sources before they have been processed, and undefined lines are removed. The distdefs are respected in source files by the preprocessor.

Autodist is not a binary packaging system. It is specificly used to create source distributions. A binary packaging system, however can be hooked to the distribution creation process, if needed.

Apt-get Install / Remove Packet is a tool to install/remove packets with debian apt-get.

About Apt-Get:

Advanced Packaging Tool, or APT, is a package management system used by Debian and its derivatives. APT was originally designed to work with .deb packages on Debian systems, but it has since been modified to work with RPM packages via apt-rpm, and to run on other operating systems such as Mac OS X (see fink). On systems with package management based on .deb, such as Debian, APT is a front-end for dpkg.

APT simplifies the process of installing and removing software on Unix systems, by automating the retrieval, (from the Internet, local network, or CD) the configuration, the compiling (sometimes) and the installation of software from APT sources.

There is no apt program per se; APT is a C++ library of functions that are used by several command line programs for dealing with packages, most notably apt-get and apt-cache.

APT front-ends can upgrade the system or specific packages. Packages can be installed or removed. When installing one or several packages, APT front-ends can list the dependencies of these packages, ask the administrator if packages recommended or suggested by newly installed packages should be installed too, automatically install dependencies and perform other operations on the systems packages to allow the installation of the packages. Similarly, to update one or several packages, front-ends can install, remove or update other packages.

APT is often hailed as one of Debians best features, giving Debian the reputation of being a "pain to install, but a joy to maintain", although with Debian 3.1 and its Debian-Installer, Debians installation might be too easy nowadays to keep this true.