Free state machines software for linux

State Machine Compiler takes a state machine stored in an .sm file and generates the state pattern classes in nine programming languages.
Its features include default transitions, transition arguments, transition guards, push/pop transitions, and Entry/Exit actions. State Machine Compiler requires Java SE 1.4.1 or better.
Enhancements:
- This release cleans up C# and VB.net debug output using System.Diagnostics.Trace.
- It fixes a number of minor bugs.

Ragel State Machine Compiler compiles finite state machines from regular languages into executable C/C++/Objective-C code. Ragel state machines can not only recognize byte sequences as regular expression machines do, but can also execute code at arbitrary points in the recognition of a regular language.
Ragel can also be thought of as a finite state transducer compiler where output symbols represent blocks of code that get executed instead of written to the output stream.
When you wish to write down a regular language you start with some simple regular language and build a bigger one using the regular language operators union, concatenation, kleene star, intersection and subtraction.
This is precisely the way you describe to Ragel how to compile your finite state machines. Ragel also understands operators that embed actions into machines and operators that control any non-determinism in machines.
Ragel FSMs are closed under all of Ragels regular language, action specification and priority assignment operators. This property allows arbitrary regular languages to be described. Complexity is limited only by available processing resources.
For example, you can make one machine that picks out specially formatted comments in C code, another machine that builds a list all function declarations and a third that identifies string constants then "or" them all together to make a single machine that performs all of these tasks concurrently and independently on one pass of the input.
Main features:
- Describe arbitrary state machines using regular language operators and/or state tables.
- NFA to DFA conversion.
- Hopcrofts state minimization.
- Embed any number of actions into machines at arbitrary places.
- Control non-determinism using priorities on transitions.
- Visualize output with Graphviz.
- Use byte, double byte or word sized alphabets.
- Generate C/C++/Objective-C code with no dependencies.
- Choose from table or control flow driven output.
Enhancements:
- The documentation and the Ruby code generator were improved.

XML::SAX::Machine is a Perl module that can manage a collection of SAX processors.

SYNOPSIS

## Note: See XML::SAX::Pipeline and XML::SAX::Machines first,
## this is the gory, detailed interface.

use My::SAX::Machines qw( Machine );
use My::SAX::Filter2;
use My::SAX::Filter3;

my $filter3 = My::SAX::Filter3->new;

## A simple pipeline. My::SAX::Filter1 will be autoloaded.
my $m = Machine(
#
# Name => Class/object => handler(s)
#
[ Intake => "My::SAX::Filter1" => "B" ],
[ B => My::SAX::Filter2->new() => "C" ],
[ C => $filter3 => "D" ],
[ D => *STDOUT ],
);

## A parser will be created unless My::SAX::Filter1 can parse_file
$m->parse_file( "foo.revml" );

my $m = Machine(
[ Intake => "My::SAX::Filter1" => qw( Tee ) ],
[ Tee => "XML::Filter::SAXT" => qw( Foo Bar ) ],
[ Foo => "My::SAX::Filter2" => qw( Out1 ) ],
[ Out1 => $log ],
[ Bar => "My::SAX::Filter3" => qw( Exhaust ) ],
);

WARNING: This API is alpha!!! It will be changing.

A generic SAX machine (an instance of XML::SAX::Machine) is a container of SAX processors (referred to as "parts") connected in arbitrary ways.

Each parameter to Machine() (or XML::SAX::Machine-new()>) represents one top level part of the machine. Each part has a name, a processor, and one or more handlers (usually specified by name, as shown in the SYNOPSIS).

Since SAX machines may be passed in as single top level parts, you can also create nested, complex machines ($filter3 in the SYNOPSIS could be a Pipeline, for example).

A SAX machines can act as a normal SAX processors by connecting them to other SAX processors:

my $w = My::Writer->new();
my $m = Machine( ...., { Handler => $w } );
my $g = My::Parser->new( Handler => $w );

Virtual Machine Manager software (virt-manager for short package name) is a desktop user interface for managing virtual machines. The project presents a summary view of running domains and their live performance & resource utilization statistics. A detailed view presents graphs showing performance & utilization over time. Ultimately it will allow creation of new domains, and configuration & adjustment of a domains resource allocation & virtual hardware. Finally an embedded VNC client viewer presents a full graphical console to the guest domain.

The application logic is written in Python, while the UI is constructed with Glade and GTK+, based on mockups provided by UI interaction designers. The libvirt Python bindings are used to interacting with the underlying hypervisor. This enables the application to be written independant of any particular hypervisor technology. Initially Xen was the primary platform supported, however, since libvirt 0.2.0 and virt-manager 0.3.1 it is possible to manage QEMU and KVM guests too. It is expected that support for additional hypervisors / virtualization products will expand even further over time as additional libvirt drivers are written.
The "Virt Install" tool (virtinst for short package name) is a command line tool which provides an easy way to provision operating systems into virtual machines. It also provides an API to the virt-manager application for its graphical VM creation wizard.

The "Virt Clone" tool (virtinst for short package name) is a command line tool for cloning existing inactive guests. It copies the disk images, and defines a config with new name, UUID and MAC address pointing to the copied disks.
The "Virtual Machine Viewer" application (virt-viewer for short package name) is a lightweight interface for interacting with the graphical display of virtualized guest OS. It uses GTK-VNC as its display capability, and libvirt to lookup the VNC server details associated with the guest. It is intended as a replacement for the traditional vncviewer client, since the latter does not support SSL/TLS encryption of x509 certificate authentication.

Virtual Machine Manager (virt-manager for short package name) is a desktop application for managing virtual machines. It presents a summary view of running domains and their live performance & resource utilization statistics.

A detailed view presents graphs showing performance & utilization over time. Ultimately it will allow creation of new domains, and configuration & adjustment of a domains resource allocation & virtual hardware. Finally an embedded VNC client viewer presents a full graphical console to the guest domain.

The application logic is written in Python, while the UI is constructed with Glade and GTK+, based on mockups provided by UI interaction designers. The libvirt Python bindings are used to interacting with the underlying hypervisor.

This enables the application to be written independant of any particular hypervisor technology, although Xen is the current primary platform. When libvirt is ported to additional hypervisors minimal effort will be required to update the management UI.

High Level Virtual Machine is a toolkit for developing virtual machines for dynamic languages.
The High Level Virtual Machine is:
- Based on LLVM (Low Level Virtual Machine). LLVM is HLVMs sister project. HLVM gains tremendous capability from LLVM in the areas of code generation, bytecode storage, runtime execution, etc.
- Aimed at supporting dynamic languages such as Ruby, Python, Perl, Jython, Haskell, Prolog, etc.
- A complete compiler developers toolkit for creating new languages easily. To write a new compiler, language designers simply write a plugin that describes the language to HLVM and how to translate the grammar productions into HLVMs comprehensive Abstract Syntax Tree (AST). After that, HLVM handles all aspects of code generation, bytecode storage, XML translation, JIT execution or interpretation, and native compilation.
- A language interoperability framework. Because all front end compilers generate code in the same AST, they can interoperate. Use of the runtime library for common constructs (e.g. "string") allow even complex data types to be shared between languages. Users of HLVM can write complex programs in multiple languages and be assured the result can be executed efficiently.
- A code management system including code revisioning, interface versioning, automated recompilation, separation of workspaces, etc.
- Currently under development. Project started April 20th, 2006. Stay tuned to this web site for future developments.

multistat is a generic program to display the up/down status of all kinds of things (some examples: VPN, particular machines, whether filesystems are mounted).

You will need to edit the multistat.py file to configure the things whose status you want to check.

Status for each "property" (i.e., VPN, computer, filesystem mount) is either red or green.

For each property, you enter values into several arrays, as defined below

Taken from multistat.py:

# commands that set properties to the green state
green_cmds = []

# commands that set properties to the red state
red_cmds = []

# commands whose output can be used to determine whether the state is green or red
check_colour_cmds = []

# strings that, if present in check_colour_cmds, mean that we are in the green state
is_green = []

# display this when in the green state
green_display_strings = []

# display this when in the red state
red_display_strings = []

So what happens is:

For each property:

1. In the green state the green_display_strings value for the property is displayed in green.

2. In the red state the red_display_strings value for the property is displayed in red.

3. To determine whether the property is in the gren or red state, the command in the check_colour_cmds array is run, and if the string in the is_green array is found in the output, then the property is in the green state. Otherwise, it is in the red state.

4. If green_cmds and red_cmds are not null (they MUST be defined, but they MAY be empty strings), then clicking the displayed string for the property on the widget will cause the relevant command to be executed to cause the property to change state. In other words, you can force a property to toggle between green and red by clicking the property on the widget. So, for example, you can mount/umount filesystems with a click. For some properties it makes no sense to provide a toggle (for example, if you are simply monitoring whether a particular computer is on the network): for such properties, define red_cmds and green_cmds to be empty strings.

This may not make much sense (sorry!) but if you read it again with the multistat.py script open in front of you, you should be able to see what I mean.

You can change the actual displayed colours easily (see screenshot 2 for an example where "red" has been redefined).

By default, properties are scanned and updated once per miute.