Free transactional software for linux

ReleaseAction - call actions upon release.

SYNOPSIS

use ReleaseAction on_release;
{
# OO style
my $handle = ReleaseAction->new(
sub {print "Exiting scopen"}
);
print "In scopen";
}
{
# Functional style
my $handle = on_release {print "Exiting scopen"};
print "In scopen";
}
{
my $rollback = on_release {rollback_trans()};
if (do_stuff()) {
$rollback->cancel();
}
}

This provides an easy way to create opaque handles which will do something when they are destroyed. There are two ways of creating a new handle. Both take one or more arguments, with the first being the action to take when the handle is released and the (optional) rest being the arguments that the handle will get.

new is the method oriented constructor.
my $handle = ReleaseAction->new(
sub {print shift}, "Goodbye cruel worldn"
);

And an optional function on_release that you can import. For those who like that sort of thing, I have provided the prototype &@ for syntactic sugar.

my $handle = on_release {print "Goodbye cruel worldn"};

And should you decide that you dont want to do the action on release after all, you can call the cancel() method. As suggested in the SYNOPSIS, this is useful if you wish to set up transactional mechanics. Make the release action do your cleanup. And then when you commit your changes, cancel the cleanup.

EXAMPLE

use ReleaseAction on_release;

# This does the same thing as the module SelectSaver.
sub tmp_select {
on_release {select shift} select shift;
}

print "This print goes to STDOUTn";
{
my $hold_select = tmp_select(*STDERR);
print "This print goes to STDERRn";
}
print "Printing to STDOUT againn";

A LONGER EXAMPLE

use Carp;
use Cwd;
use ReleaseAction;

sub cd_to {
chdir($_[0]) or confess("Cannot chdir to $_[0]: $!");
}

sub tmp_cd {
my $cwd = cwd();
cd_to(shift);
ReleaseAction->new(&cd_to, $cwd);
}

sub something_interesting {
my $in_dir = tmp_cd("some_dir");
# Do something interesting in the new dir

# I will automagically return to the old dir
# when I exit the subroutine and $in_dir goes
# out of scope.
}

TARIFA, which stands for Transactions by AssembleR Instrumentation FrAmework, aims to provide the "atomic" keyword to C/C++ for better support of concurrency programming.
Instead of using lock-based designs with all their problems (deadlocks, difficult design, lack of reusability), the "atomic" keyword provides transparent access to an underlying Software Transactional Memory which is responsible for all synchronization work.
Enhancements:
- This release contains a fixed and somewhat faster STM backend, several bugfixes in the instrumentation, improved tests, a general code clean-up, and a dummy STM backend for testing purposes.

Marauroa is ariannes content server.
Marauroa project is completely written in Java using a multithreaded server architecture with a UDP oriented network protocol, a MySQL based persistence engine and a flexible game system.
The game system is totally expandable and modifiable by game developers and is able to run Python scripts defining the games rules.
Marauroa is based on a design philosophy we called Action/Perception. Each turn a perception is send to the clients explaining what they currently perceive. Clients can ask the server to perform any action in their name using actions.
Marauroa is totally game agnostic and makes very little assumptions about what are you trying to do, allowing a great freedom to create any game type.
Main features:
- Java 1.4 compatible
- Persistent objects
- Transactional relational database support
- Delta and Delta-Delta Perceptions to reduce bandwidth usage
- Fully test case covered using Junit
- Turn based gameplay
- Nicely documented: Design and specifications available
- Based on a XP development model
- Follows KISS principle: Keep it simply stupid
- True Open Source Software: GNU/GPL
Marauroa is based on very simple principles:
- Clients communicate with the server, and vice-versa, using an UDP portable network protocol with reliability in mind to allow a stabler experience when online game lag occurs.
- You can develop an arianne client, using the arianne client framework, on any system that is able to compile C code.
- To play a game every player needs an account on the server that is identified by an username and a password.
- Players use their account to login into the server and then choose a player stored under their account to play with. The server then checks the login information using the mySQL backend and loads the player into the game using the persistence engine.
- Players send actions to the server. The action system is totally open and has nothing hard-coded so you can edit it totally to your game style. The server sends at regular intervals, called turns, a perception to each player to inform them about the state of the game and any relevant state modifications. Marauroas perception system is based on the Delta^2 ideology: simply send what has changed.
- The server executes some code each turn in order to move the game status on. Using this hook it is simple to code triggers, timeouts, conditions and whatever kind of behavior you need.
- The server transparently and automatically stores players and game status modifications on the persistence engine, and also information decided by the game developer using their game definition scripts.
- The server side game rules can be written in Python to allow simple and rapid development without needing to recompile the rules engine and without having to know anything about Marauroas internals. Games rules can also be coded in Java.
- The server generates statistics of usage which are stored in a mySQL database (so you can later generate fancy statistics from them). Or in case you dont require them, they can be disabled to save CPU cycles and disk space. Marauroa features a modular structure that means modules can be changed and disabled without affecting the operation of other modules.
- Both the server and clients are fully and wisely documented, with documentation about specification and design and not just API documentation.
Enhancements:
- A MySQL 4.0 incompatibility was fixed, namely a bug regarding IRPZone.ID and RPObject.hashCode that caused problems with HashMap.
- A memory leak because of a Sun bug was fixed.
- The servers speed was improved with several fixes.

StreamCruncher is an Event Processor. The project supports a language based on SQL which allows you to define Event Processing constructs like Sliding Windows, Time Based Windows, Partitions and Aggregates.
Queries can be written using this language, which are used to monitor streams of incoming Events. StreamCruncher is a multi-threaded Kernel that runs on Java.
Ever since RFID became commercially viable and companies started packaging their entire product line as Business Activity Monitoring Stacks, an old idea that has been around for almost a decade is now seeing the light of day. A handful of Startups have begun turning this Idea of Complex Event Processing (CEP) and Event Stream Processing (ESP) into Commercial grade software. Several people have contributed ideas to this field. The most frequently mentioned name would be Prof. Luckhams. Prof. Widoms contribution to the field is also noteworthy.
Those in a hurry can skip to this section.
Now, back to CEP and ESP. An over-simplified definition would probably look like this - Assume that a System produces "Events" that describe the state of that System at those instants. Slicing and Dicing the "live" Stream of Events (in near real-time) can reveal vital information. Since this information is available on the live data and not stale data, it can be used to look for Warning signs, implement JIT materials sourcing, Automated Trading and other highly nimble systems.
Events from multiple sources can be co-related to reveal information about their interactions and dependencies. CEP and ESP are not exactly the same, but well leave that to the Scholarly Papers to disambiguate. All this does not seem new at all to people whove been working on Control Systems. Data Warehouse specialists and Rule Engine experts might start mumbling something about "Old Wine..".
However, only lately are we seeing generic, off-the-shelf Software focusing on CEP and ESP. Each one of those Products or Projects distinguish themselves in Performance (Real-time, Soft Real-time), Ease of Integration (Features, Mild to Steep Learning Curves, Manageability), Speciality (Automated Trading Platforms) or General purpose stacks etc. Or, perhaps all of them, to varying degrees.
For a Program to continually Slice and Dice an Event Stream and thereby, discern/infer something useful about the state of the System before it goes stale, requires a variety of Technologies to converge. Weve been using SQL to handle Transactional Data stored in Databases, Data Warehouses to analyse Terrabytes of Offline data, Rule Engines to infer from a large collection of constantly changing Facts.
ESP and CEP Systems provide building blocks using which Users can build an intelligent System, with active feedback. All CEP and ESP Systems provide a mechanism by which Queries/Conditions/Criteria can be provided that are constantly evaluated against the Event Stream. Some systems provide drag-n-drop GUIs to specify such "Queries", while some have their own proprietary Query syntax. In essence, they provide a Domain Specific Language to encode such Queries/Rules, a facility to pump Events into the System and a way to channel the Output Stream to do something useful.
Enhancements:
- The pre-filter for input event streams now supports , !=, =, *, /, +, -, "in (..)", "not in (..)", "and", and "or".
- The "in" clause can refer to an SQL sub-query.
- Such sub-queries are cached by the kernel to improve performance.
- An additional property, cacherefresh.threads.num, can be configured to specify the number of sub-query cache processing threads to use.
- Two new test cases have been added to test the new features: H2StartupShutdown3Test and ThreeEventOrderTest.

SAPRFC is a extension module for PHP 4 and PHP 5. SAPRFC can call ABAP function modules in SAP R/3 from PHP scripts.
You can use the powerful PHP language to create a web applications or interface programs with a connectivity to the SAP R/3.
You can also write RFC server program in PHP and call PHP functions from SAP R/3.
Main features:
- Non-Unicode SAP R/3 release above 4.0B supported (it may be work for earlier versions but it hasnt been tested)
- use RFC (Remote Function Call) API to make call
- discover interface of a function module
- map RFC types to PHP strings
- server API for calling PHP functions from ABAP
- support for transactional RFC (client and server)
- portability: except ZEND API and RFC API use only a few standard C functions
- delivered with the test script saprfc_test.php that has the similar function as "Single Test" option in SE37 transaction (Function Builder).

Sequoia is a transparent middleware solution for offering clustering, load balancing and failover services for any database. Sequoia is the continuation of the C-JDBC project.
Sequoia database is distributed and replicated among several nodes and C-JDBC balances the queries among these nodes. Sequoia handles node failures and provides support for checkpointing and hot recovery.
C-JDBC is a database cluster middleware that allows any Java application (standalone application, servlet or EJB container, ...) to transparently access a cluster of databases through JDBC.
C-JDBC handles node failures and provides support for checkpointing and hot recovery.
Main features:
- No modification of existing applications or databases,
- High availability provided by advanced RAIDb technology,
- Performance scalability with unique load balancing and query result caching features,
- Integrated JMX-based administration and monitoring,
- 100% Java implementation allowing portability across platforms,
- Open source licensed under LGPL,
- Professional support, training and consulting available from C-JDBC professional services.
Whats New in 2.10.9 Stable Release:
- This release fixes a compatibility problem between Appia and Hedera that was introduced by the previous release.
- The 2.10.8 release was delivered with an incorrect appia.jar (3.2.3).
Whats New in 3.0 Beta 2 Development Release:
- This release includes a long list of feature improvements and bugfixes.
- A new embedded recovery log has been implemented for a transactional log without configuration.
- New demos are based on these new features.
- Other usability improvements and performance enhancements are also part of this release.

PrimeBase XT (PBXT) is a transactional storage engine for MySQL. The project has been designed for modern, web-based, high concurrency environments and heavy update loads. PBXT uses a number of new techniques to achieve its goals.
Enhancements:
- This release makes changes to enable PBXT to handle databases containing thousands of tables.
- It also fixes a number of concurrency problems with operations like TRUNCATE TABLE, ALTER and REPAIR table when used in conjunction with other DML.