Free ipc pubsub software for linux

IPC::PubSub is Perl module for Interprocess Publish/Subscribe channels.

SYNOPSIS

# A new message bus with the DBM::Deep backend
# (Other possible backends include Memcached and PlainHash)
my $bus = IPC::PubSub->new(DBM_Deep => /tmp/pubsub.db);

# A channel is any arbitrary string
my $channel = #perl6;

# Register a new publisher (you can publish to multiple channels)
my $pub = $bus->new_publisher("#perl6", "#moose");

# Publish a message (may be a complex object) to those channels
$pub->msg("This is a message");

# Register a new subscriber (you can subscribe to multiple channels)
my $sub = $bus->new_subscriber("#moose");

# Publish an object to channels
$pub->msg("This is another message");

# Set all subsequent messages from this publisher to expire in 30 seconds
$pub->expiry(30);
$pub->msg("This message will go away in 30 seconds");

# Simple get: Returns the messages sent since the previous get,
# but only for the first channel.
my @msgs = $sub->get;

# Simple get, with an explicit channel key (must be among the ones
# it initially subscribed to)
my @moose_msgs = $sub->get("#moose");

# Complex get: Returns a hash reference from channels to array
# references of [timestamp, message].
my $hash_ref = $sub->get_all;

# Changing the list of channels we subscribe to
$sub->subscribe(some-other-channel);
$sub->unsubscribe(some-other-channel);

# Changing the list of channels we publish to
$pub->publish(some-other-channel);
$pub->unpublish(some-other-channel);

# Listing and checking if we are in a channel
my @sub_channels = $sub->channels;
my @pub_channels = $pub->channels;
print "Sub is in #moose" if $sub->channels->{#moose};
print "Pub is in #moose" if $pub->channels->{#moose};

# Raw cache manipulation APIs (not advised; use ->modify instead)
$bus->lock(channel);
$bus->unlock(channel);
my @timed_msgs = $bus->fetch(key1, key2, key3);
$bus->store(key, value, time, 30);

# Atomic updating of cache content; $_ is stored back on the
# end of the callback.
my $rv = $bus->modify(key => sub { delete $_->{foo} });

# Shorthand for $bus->modify(key => sub { $_ = val });
$bus->modify(key => val);

# Shorthand for $bus->modify(key => sub { $_ });
$bus->modify(key);

This module provides a simple API for publishing messages to channels and for subscribing to them.

When a message is published on a channel, all subscribers currently in that channel will get it on their next get or get_all call.

Currently, it offers three backends: DBM_Deep for on-disk storage, Memcached for possibly multi-host storage, and PlainHash for single-process storage.

Please see the tests in t/ for this distribution, as well as "SYNOPSIS" above, for some usage examples; detailed documentation is not yet available.

Smack PubSub Extensions is a set of extensions to smack.

The extensions mainly include support for JEP-0060 aka PubSub but there are also a few utitlity classes. Please refer to the maven-generated documentation for further information.

IPC::DirQueue is a disk-based many-to-many task queue.

SYNOPSIS

my $dq = IPC::DirQueue->new({ dir => "/path/to/queue" });
$dq->enqueue_file("filename");

my $dq = IPC::DirQueue->new({ dir => "/path/to/queue" });
my $job = $dq->pickup_queued_job();
if (!$job) { print "no jobs leftn"; exit; }
# ...do something interesting with $job->get_data_path() ...
$job->finish();

This module implements a FIFO queueing infrastructure, using a directory as the communications and storage media. No daemon process is required to manage the queue; all communication takes place via the filesystem.

A common UNIX system design pattern is to use a tool like lpr as a task queueing system; for example, http://patrick.wagstrom.net/old/weblog/archives/000128.html describes the use of lpr as an MP3 jukebox.

However, lpr isnt as efficient as it could be. When used in this way, you have to restart each task processor for every new task. If you have a lot of startup overhead, this can be very inefficient. With IPC::DirQueue, a processing server can run persistently and cache data needed across multiple tasks efficiently; it will not be restarted unless you restart it.

Multiple enqueueing and dequeueing processes on multiple hosts (NFS-safe locking is used) can run simultaneously, and safely, on the same queue.

Since multiple dequeuers can run simultaneously, this provides a good way to process a variable level of incoming tasks using a pre-defined number of worker processes.

If you need more CPU power working on a queue, you can simply start another dequeuer to help out. If you need less, kill off a few dequeuers.

If you need to take down the server to perform some maintainance or upgrades, just kill the dequeuer processes, perform the work, and start up new ones. Since theres no socket or similar point of failure aside from the directory itself, the queue will just quietly fill with waiting jobs until the new dequeuer is ready.

Arbitrary name = value string-pair metadata can be transferred alongside data files. In fact, in some cases, you may find it easier to send unused and empty data files, and just use the metadata fields to transfer the details of what will be worked on.

Requirements:

• Python

Quanta Plus is a highly stable and feature rich web development environment. Quantas vision has always been to start with the best architectural foundations, design for efficient and natural use and enable maximal user extensibility.

We recognize that we dont have the resources to do everything we would like to so our target is to make it easy for you to help make this the best community based desktop application anywhere. Pretty much everything in Quanta is designed so you can extend it.

Even the way it handles XML DTDs is based on XML files you can edit. You can even import DTDs, write scripts to manage editor contents, visually create dialogs for your scripts and assign script actions to nearly any file operation in a project. You can even look at and communicate with a wide range of what happens inside Quanta using DCOP.

Quanta is based on KDE so this means it is network transparent from any dialog or project. It can use not only FTP but other KDE KIO slaves from file dialogs or in project settings. For instance if you want secure access try the fish KIO slave that uses SSH.

Just enter fish://[user]@domain in any dialog or select fish in your project settings. Here on this site you will find information on using Kommander to visually build dialogs you can extend Quanta with. These applications talk to each other using an IPC (Inter Process Communication) called DCOP (DEsktop Communication Protocol).

Of course I realize this can sound like alphabet soup techno-babble to some web developers, but heres what it means. When you are using Quanta and realize you would like to do something and you want to ask "Can I do this?" you can expect the answer will not only be yes, but it will probably be even cooler than you hoped for.

Not included on this site are other tools you can use with Quanta for revision control and reviewing and merging changes in files. Those applications are Cervisia and Kompare, and if they are not installed and you install them Quanta will use them.

We would like to think that there are rich rewards to be found here for those willing to explore new ways of doing things, or perhaps in some cases old ways that are just new to you.

PicoTK is a C GUI toolkit that requires only a minimum of memory resources. It readily works with the RTEMS real time kernel - its minimum complexity and OS independency makes a port to any operating system easy. It is not comparable featurewise with real full blown windowing toolkits like nanoX or Qt/Embedded, but serves the needs for simple memory mapped graphic presentation.
Main features:
- Draw graphical primitives: points, lines, texts (different fonts, fixed and proportionally spaced using any X-Windows font ), filled rectangles, pixmaps
- Driver is easily adaptable to "homebrew" embedded display hardware based on memory-mapped framebuffer
- Generic drivers for 1, 4 and 8 bit per pixel color depth. Readily supporting VGA mode 0x11 (640x480x2), VGA mode 0x13 (320x200x8) and the VESA linear frame buffer modes (480x640x8 to 1280x1024x8) on graphic cards, which support VBE2.0 or higher.
- Framebuffer emulator (fbe) for Linux using shared memory IPC. This is used for the development of the toolkit and can be used for the development of your application as well. That is you can have a simulation version of your application that run under Linux - and look at its emulated screen. Than you can cross-compile the same application for the target system.
- Tool "fontripper" for converting X11 fonts into picoTK fonts. Use "ppmripper" for converting ppm portable pixmaps into picoTK pixmaps. Fonts and Pixmaps are encoded into linkable binaries, i.e. the system will be compiled into a single binary and does not require to have a filesystem.
- Together with RTEMS (www.oarcorp.com) you can have a nice embedded system graphical output solely using GNU technology.
- Use Linux as a development host for cross-compiling and as an emulation environment.
- Allows easy adaption/porting to your favorite operating system or hardware architecture.
Enhancements:
- Extensions to demo application
- Updated HOWTO (currently only the ASCII version is included in the sources)
- Added support for VESA VBE2.0 flat linear frame buffer
- picoTermPrintf(): Added support for VT100/320 Escapes: Change color and move cursor.
- toolkit: Change graphics configuration by changing toolkit/Makefile

libbsl (Basic System Library) is a powerful, easy to use and fully thread safe C++ template class library for frequently recurring (machine/OS oriented) programming problems.
All fundamental objects in libbsl are freely copyable and shareable between an arbitrary number of threads - e.g. reading from a shared io device from several concurrent threads is implicitly thread safe for the programmer without additional cost and knowledge.
An important goal in developing libbsl was to keep it simple and to enable even the inexperienced programmer to quickly write complex programs with the help of libbsl.
This goal is achieved by hiding most of the templates - and there are many - from the api by several reasonable typedefs.
On the other hand the generic template architecture of libbsl allows the more adept user to enhance (e.g. by the use of policy templates) or by combining libbsls classes to create new objects or user defined functionality.
Main features:
- crypto; cryptographic classes (AES, ElGamal etc.) mainly for secure network communication
- datetime; date, time and timer classes
- dso; dynamic loadable C++ objects which remain dynamic_castable after loading
- io; ile, directory, character devices etc. classes.
- io/net; tcp/udp ipv4 (secure) socket classes etc.
- ipc; program execution class, lightweight process class which enables you to design your own fine grained program logic by the use of freely configurable suspend an resume functions per process
- log; error handling and logging mechanisms via syslog, files etc.
- mime; mime type detection using ternary search trees
- options; command line options and environment setting classes
- thread; easy to use thread class, mutexes, barriers, transfer of program tasks to threads by the use of thread functors etc.
- types; type traits, type lists etc.
- util; memory management, factories, daemon class, functors, "switchless" intelligent state machine implementation, utf8 string class and much more
- values; parameter (pair of arbitrary values as text), tuple, variant etc.