Free backend software for linux

PowerDNS Oracle Backend provides a backend which allows PowerDNS to use Oracle as its data store.

PowerDNS Oracle Backend is a backend driver for the PowerDNS nameserver which allows DNS data to be stored in an Oracle database. PowerDNS can load backend modules at runtime. This backend is fully configurable, and SQL statements can be specified in the configuration file.

system-tools-backends is a package for GNOME.

to extract the configuracion

backend --get

to restore the configuration from XML

backend --set < file.xml

AcuLaser C900 CUPS backend provides a LINUX CUPS package (incl. PPD-file) for the EPSON AcuLaser C900.
It is built around the avasys pipsplus driver. The project supports i386 and 32-bit compatible x86_64 LINUX systems (deb/rpm/tgz/gentoo/slack)
There are positive feedbacks for:
- SuSE
- Mandriva
- Slackware
- Red Hat
- Fedora Core
- Debian, Ubuntu
- Gentoo
The included installer will:
- Check for missing packages
- download and install the mandatory epkowa packages automatically
- provide a dummy lpr-package to resolve dependencies
- account for the different Ditros (BSD - System V - Gentoo) and configure the run-levels accordingly
- give suggestions for appropriate URIs for the printer installation
- call the distribution specific CUPS tools (YaST2, printerdrake, kprinter, gnome-cups-config)
Main features:
- Bundling of pages (large documents sometimes "hang")
- generic multiple local printer support
- URI handling for proper interface (usblp) allocation
- installation of XML files for plain foomatic support
- better hotplugging behavior
- networking (IPP, SMB) support through a local pseudo-interface
Enhancements:
- The regular print mode will be selected with every reboot or runlevel change.

HP ScanJet 3900 series backend is an application and backend for linux that allows to use HP scanjet series 3900 scanners and, basically, all those controlled by Realtek RTS8822L chipset.
HP ScanJet 3900 series backend application is in early phase of development. Four files are included, two (binary and sources) for the application and two more for SANE backend.
Enhancements:
- Added support for scanner: HP ScanJet G3010 (similar to hp4370)
- Added initial support for scanner: BenQ 5550T (New chipset: RTS8823L-01E).
- Fixed bug related to stepper motor, programming smearing curves for backtracking.
- Implemented algorithm to detect installed RAM type.
- Implemented a better code to read/write in DMA.
- Added some scripts for users, to update, compile and install sources.

Bigtop::Backend::Control::Gantry is a controller generator for the Gantry framework.

SYNOPSIS

Build a file like this called my.bigtop:
config {
base_dir `/home/username`;
Control Gantry {}
}
app App::Name {
controller SomeController {}
}

Then run this command:

bigtop my.bigtop Control

When your bigtop config includes Control Gantry, this module will be loaded by Bigtop::Parser when bigtop is run with all or Control in its build list.

This module builds files in the lib subdirectory of base_dir/App-Name. (But you can change name by supplying app_dir, as explained in Bigtop::Parsers pod.)

There will generally be two files for each controller you define. One will have the name you give it with the app name in front. For the SYNOPSIS example, that file will be called

/home/username/App-Name/lib/App/Name/SomeController.pm

I call this file the stub. It wont have much useful code in it, though it might have method stubs depending on whats in its controller block.

The other file will have generated code in it. As such it will go in the GEN subdirectory of the directory where the stub lives. In the example, the name will be:

/home/username/App-Name/lib/App/Name/GEN/SomeController.pm

During the intial build, both of these files will be made. Subsequently, the stub will not be regenerated (unless you delete it), but the GEN file will be. To prevent regeneration you may either put no_gen in the Control Gantry block of the config, like this:

config {
...
Control Gantry { no_gen 1; }
}
or you may mark the controller itself:
controller SomeController {
no_gen 1;
}

BerkeleyDB Backend Storage Engine for DURUS project provides a storage engine for DURUS, a persistence system for the Python programming language.
Some advantages compared to Durus standard FileStorage:
- Startup time is negligible.
- You dont need an in-memory index, so your repository size is only limited by storage space, not RAM.
- If you change existing objects, your storage size doesnt increase.
- If you delete objects, those objects are garbage collected in background, slowly, without performance degradation.
- You can still do a full fast collection, if you need it. While this collection is in progress, Durus still serves objects. From time to time, nevertheless, it can be unresponsible for 2 or 3 seconds, while is doing a checkpointing to be able to free database logging diskspace.
- Garbage collection doesnt increase storage size. Neither RAM usage.
- Garbage collection deletes objects using nondurable transactions, very efficiently. If the collection is aborted abruptly (program or machine crashes), the collection will start again from the beginning. If the GC finishes without problems, that state is durable.
- Any object store in the storage will commit a durable transaction, including all objects released in the background garbage collector, along the way.
- Garbage collection time is proportional to garbage, not repository size.
There are some disadvantages, nevertheless:
- IMPORTANT: This backend uses reference counting to decide when an object is garbage and can be collected. So, if you have cycles in your data structures, you **MUST*BREAK** them before releasing the objects.
- Failing to do that will leak diskspace. It is possible that in a future release we can collect cycles, but try to avoid that pattern.
- Leaking objects will grow the diskspace, but **NO** corruption or malfunction will happen. No other secondary effect.
- Although this code could work on Windows, I havent checked it. Absolutely no garantee!.
- Sometimes this backend can become irresponsible for a couple of seconds. It is busy doing a checkpoint to recycle database logging space. The pause should be sort, nevertheless.
- Dont use this storage backend over NFS, at least you know what is going on.
- Since we are using BerkeleyDB as the backend:
- You should be experienced with BerkeleyDB deployments.
- Beware when updating Python or BerkeleyDB. In particular, BerkeleyDB is known by breaking (but they DOCUMENT!) binary compatibility between versions. In this case, they ALWAYS document the procedure to do a controlled upgrade, so dont worry. But take note of the risk.
- To do a trustable backup, you should follow instructions in BerkeleyDB documentation:
- http://www.sleepycat.com/docs/ref/transapp/reclimit.html
- http://www.sleepycat.com/docs/ref/transapp/archival.html
- http://www.sleepycat.com/docs/utility/db_hotbackup.html
- In Python you can use the standard "bsddb" or the up-to-date "bsddb3" bindings (which will be included in new python versions). This product will try to use always the more recent BerkeleyDB bindings. Be careful about BerkeleyDB version changes when you update the bindings.
- Since BerkeleyDB files are binary structures, a corrupt database can be unrecoverable. Be diligent and careful with your backups.
You can use this product both as a normal (local) filestorage, or a server (remote) storage system, just like the usual Durus FileStorage.
Enhancements:
- Compatibility with Durus 3.7 was added.

Rubygame is a combination extension and library for the Ruby language, with the goal of making it easy and fun to create games in Ruby.

Rubygame has SDL as a backend, and is styled after the very nice pygame library for the Python language.

Rubygame is free softwarereleased under the GNU Lesser General Public License.

Nixs Web-based SSH client has a backend written in C/glib and a frontend written in PHP. The project talks to the backend via a Unix socket.
The backend maintains a number of SSH processes in TTYs, reads their TTYs, and sends the contents to PHP for formatting. PHP accepts input and passes it to the correct TTY for processing.
Enhancements:
- CR/LF interpretation was improved.
- Escape sequences were added.
- GOption command line parsing was added.