Free available jobs software for linux

DrawPile is a collaborative drawing program, similar to OpenCanvas. It is currently under planning stages. DrawPile project will use Qt4 and will be available for Windows, Linux and MacOS.

Parallel::Queue is a Perl module to fork or thread a list of closures N-way parallel.

SYNOPSIS

# example queue:
# only squish files larger than 8KB in size. figure
# that the system can handle four copies of squish
# running at the same time without them interfering
# with one another.

my @queue = map { -s > 8192 ? sub{ squish $_ } : () } @filz;

# functional: pass in the count and list of coderefs.
#
# adding runqueue exports the subroutine into
# the current package. useful for non-OO situations.
#
# run the queue 4 way parallel.

use Parallel::Queue qw( runqueue verbose fork );

my @remaining = runqueue 4, @queue;

die "Incomplete jobs" if @remaining;

# OO: generate queue manager and use without the
# runqueue arguments, construct a queue manager,
# and use it to run the jobs

use Parallel::Queue;

my $quemgr = Parallel::Queue->construct( thread );

$quemgr->runqueue( 4, @queue );

die "Incomplete jobs" if @queue;

# call Parallel::Queue with the default configuration
# (fork quietly).

require Parallel::Queue;

Parallel::Queue->runqueue( 4, @queue );

# pre-define defaults for the objects: leave
# out runqueue, set the rest, and construct
# an object. the one here gets verbose, thread,
# and debug all set to true.

use Parallel::Queue qw( verbose thread );

my $quemgr = Parallel::Queue->construct( debug );

my @remaining = $quemgr->runqueue( 4, @queue );

Given a count and an array of coderefs (most likely closures), runqueue will run the jobs in parallel. The jobs can be run via fork or detached threads [see known issues for threading]. Jobs on the queue are executed until one of them exits non-zero, the fork/thread operation fails, or all of them are dispatched (i.e., the queue is empty).

Databrid is a browsing, retrieval and manipulation tool designed for the novice to the expert user. Databrid works on MySql and Oracle Database (versions 8 and above although not all functionality in the Browser is available for the lower versions). The core functionality of Databrid revolves around the tabbed areas within the Databrid application. The four main tabs in the main screen of Databrid are: SQL Editor, Browser, File and Jobs.

## SQL EDITOR ##
The SQL Editor tab allows you to write and run SQL and PLSQL. The tab provides the ability to use one of more sql autocompletion, word and syntax highlighting editors with automatic case adjustment for keywords. Provided with each editor is a table for displaying SQL query results and a text output area to display DBMS_Output output. Jobs can be run in the background allowing for the execution of multiple statements at any given time.

## BROWSER ##
The Browser tab allows the you to browse various parts of the database schema. The browsing is done via a particular schema user and displays information on tables, views, sequences etc. Features include the generation of database creation statements for tables, views etc, browsing table or view data, truncating tables, etc.

## FILE ##
The File tab allows you work with a CSV (comma delimited text file) and the database without having to load the CSV into the database. This tab has two areas that functionality: CSV Update and Database Update. CSV Update allows you to add additional columns to a CSV using a Select statement, including binding CSV column values to the Select statement. Database Update allows you to update the database using insert, updates, deletes or PLSql by binding the CSV column values into your statement.

## JOBS ##
This tab allows you to view which jobs are currently running or have finished. Jobs that are running can also be stopped.

AlignAid is a Perl module that easily run sequence alignments locally or on a cluster.
SYNOPSIS
use AlignAid;
# create an AlignAid object
# a single, locally run blast job is the default
my $job = AlignAid->new( db => my_blast_db, dir => $dir,
fasta => my_query.fa,
prog_args => V=20 -nonnegok );
# run the job on the current host
my $return_value = $job->submit(outfile => my_results.out);
# create an AlignAid cross_match object
# specify the alignment program and the queue to override the defaults
my $job2 = AlignAid->new( program => cross_match,
db => my_db.fa, dir => $dir,
fasta => my_query_seqs.fa, queue => LSF);
# submit the cross_match jobs to an LSF queue (of compute nodes)
my $return_value2 = $job2->submit(outfile => my_output);
# kill the queued jobs
my $return_value3 = $job2->kill_all;
AlignAid is designed to make it easy to run the sequence alignment programs Blast and cross_match. AlignAid can accept a large number of query sequences. If a compute cluster queue such as LSF or PBS is available, AlignAid can automatically split the queries into multiple queue jobs.
Likewise, if you want to run the alignments locally on a single host, a single change is all that is necessary -- AlignAid will take care of how to invoke the alignment programs and manage the output.
AlignAid also has rudimentary support for LSF queue job control; it is possible to kill jobs through AlignAids interface.
Enhancements:
- Perl

vrbroadcast project is a video on demand server.

It supports hierarchical networks of servers that will automaticaly update information on the available media.

It has a GUI that is only available in German, but the server was written with multi-language support in mind.

libwp provides a simplified facility for a common use of threads, processing tasks using a pool of threads.

libwp is implemented with POSIX threads (pthreads) for the Solaris and Linux platforms. The primary development platform is Solaris.

Usage:

Creating a Pool

Before you can do any processing with libwp you must create a pool using wp_new(). This will create and configure your pool and populate it with the required number of worker threads. If you dont specify a number of threads (i.e. size is 0), then libwp will automatically calculate a number of threads which are appropriate for the number of available processors. The function pointers you provide are the default functions used to execute and report on submitted tasks.

Using a Pool

Once youve created your pool, you can go ahead and run tasks in the pool. You queue a task for execution with wp_run() or wp_run_task(). If a worker thread is available then the task will be immediately allocated to the thread and processed. If there are no available worker threads then the task will be queued for processing when a thread becomes available.

wp_run() will use the default process and report arguments supplied when the pool was created (see wp_new()). wp_run_task() uses the supplied process and report arguments.

Destroying a Pool

Once you are finished with a pool, then you should destroy it with wp_free(). Destroying the pool will reclaim all resources associated with the pool. This is a blocking call and the invoking thread will wait until all currently active threads terminate before returning. The wait flag controls the behaviour of the function. If WP_WAIT is specified, then the pool will not be destroyed until there are no active threads. Whilst it is waiting for this to occur additional task requests may be queued. If WP_IMMEDIATE is specified, then the pool will not accept more task requests and will be destroyed as soon as all active task are finished.

Utility Functions

The two message logging functions (wp_log() and wp_die()) are synchronized so that all messages are displayed atomically.

wp_close() can be used to close a pool. This has the same effect as calling wp_free() but does not reclaim the pool resources.
wp_open() can be used to re-open a previously closed (wp_close()) pool.
wp_resize() can be used to resize a currently open and active pool.
wp_wait() can be used to cause a thread to wait for a worker pool to quiesce, i.e. no outstanding jobs in the pool. Be careful using this function as external co-ordination is required to prevent race conditions from developing.
wp_active() can be used to determine how many worker threads are currently busy and wp_state() is used to determine if the worker pool is still accepting new tasks. Once a pool is closed, state of WP_INACTIVE, it will no longer accept further task requests.
wp_enable_stats() can be used to cause the pool to start collecting performance statistics. These statistics can be retrieved and examined using wp_get_stats(). Statistics collection is disabled using wp_disable_stats().

Multiplication Puzzle project is a simple GTK+ 2 game that emulates the multiplication game found in Emacs.

Basically, a multiplication problem is shown with all digits replaced by letters. Your job is to guess which letter represents which number.

Translations are available for Afrikaans, Basque, Brazilian Portuguese, Chinese (simplified), French, German, Italian, Japanese, Kinyarwanda, Rhaeto-Romance, Romanian, Serbian, Turkish, and Vietnamese. If you are interested in helping to translate Multiplication Puzzle, please see the Translation Project, under the textual domain gmult.

phpaga is a fully templatable Web-based project, task, invoice, and quotation management system, providing a centralized way to keep on top of your day-to-day jobs and activities.

Its features include printing invoices, quotations, and task lists to PDF, productivity statistics on a per project or per person basis, financial overview, billing method plugins, and multiple interface languages.