Free conditioning software for linux

CSS::SAC::ConditionFactory Perl module contains the default ConditionFactory.

SYNOPSIS

my $cf = CSS::SAC::ConditionFactory->new;
my $cond1 = $cf->create_foo_condition;
my $cond2 = $cf->create_bar_condition;

This is the default ConditionFactory for CSS::SAC. It creates conditions of all types defined in SAC. You may wish to subclass or replace the default ConditionFactory in order to get your own condition objects.

I plan on adding more flexibility to this factory so that one could tell it the classes to use for various conditions, that would avoid enforcing subclassing/recoding for people that only want to replace a family of factory methods.

I know that some of the method names are quite lengthy, but given the great number of possible conditions it helps to have descriptive names.

METHODS

These define the interface that must be adhered to by ConditionFactories. The Java names (given in parens) work too, though the Perl ones are recommended.

CSS::SAC::ConditionFactory->new or $cf->new
Creates a new condition factory object.
$cf->create_and_condition($first,$second) (createAndCondition)
creates a combinator condition of type and
$cf->create_attribute_condition($lname,$ns,$specified,$value) (createAttributeCondition)
creates an attr condition
$cf->create_begin_hyphen_attribute_condition($lname,$ns,$specified,$value) (createBeginHyphenAttributeCondition)
creates a attr condition of type bh
$cf->create_class_condition($ns,$value) (createClassCondition)
creates a attr condition of type class
$cf->create_content_condition($data) (createContentCondition)
creates a content condition
$cf->create_id_condition($value) (createIdCondition)
creates a attr condition of type id
$cf->create_lang_condition($lang) (createLangCondition)
creates a lang condition
$cf->create_negative_condition($cond) (createNegativeCondition)
creates a negative condition
$cf->create_one_of_attribute_condition($lname,$ns,$specified,$value) (createOneOfAttributeCondition)
creates a attr condition of type id
$cf->create_only_child_condition() (createOnlyChildCondition)
creates a only-child condition
$cf->create_only_type_condition() (createOnlyTypeCondition)
creates a only-type condition
$cf->create_or_condition($first,$second) (createOrCondition)
creates a combinator condition of type or
$cf->create_positional_condition($position,$type_node,$same_type) (createPositionalCondition)
creates a positional condition
$cf->create_pseudo_class_condition($ns,$value) (createPseudoClassCondition)
creates a attr condition of type pseudo class

Arguvision project is an enterprise class video surveillance system.
Arguvision is based on a distributed Linux or Unix cluster architecture, with up to 1000 cameras per single cluster with aggregation capability and instant access to recorded or live video.
Main features:
- Up to 1000 video channels per cluster - unlimited clusters
- 6 channels at 720x480 at 30 frames/sec per video grabber unit
- NTSC or PAL video input
- M-JPEG compression 1:15
- 1TB of storage for 10 days per camera at full resolution in high motion area
- Export video using AVI format , or single images using JPEG format
- Real-time view from any camera using client software
- Secure authenticated user access (SSL) based on user role
- Instant browse and archive search by date/time or alarm condition
- Alarm event notification by e-mail or pager
- Record on pre-programmed schedule, or on alarming condition
- Alarm events generated on motion, on video loss, or by activation of an external sensor
- NTP synchronization with time standards (like US Governments NIST)
- Data storage on internal/external network devices managed by SQL RDBMS
- RDBMS capacity monitoring
- Purge obsolete video data automatically

con:cern project is a workflow engine based on an extended case handling approach.
A process is described as a set of activities with pre- and postconditions. An activity is executed when its preconditions are met. It manipulates the process item, thereby creating postconditions. The process flow is determined at runtime. This approach is superior to the conventional process flow approach, especially if high flexibility and modularity are required.
Main features:
- complex process with exceptions and special cases
- execution sequence is dependent on multiple factors
- possibility of manual intervention of process flow
- content-based dependence amongst activities
- strong requirements to modularity
- strong requirements to flexibility
- loose process coupling
Interestingly, processes often turn out to be more complex than initially anticipated. con:cerns flexibility allows to restrict yourself to implementing the normal process flow. Special cases and exceptions can be manually dealt with at run-time, or can be gradually retrofitted.
When you can break systems down to pre conditions, post conditions, transfer functions, and the algorithms that implement them you can go a long way towards reliable systems and specs.
Enhancements:
- bugfix escalation timeout
- bugfix reenlistment after escalation

Commands::Guarded Perl package provides better scripts through guarded commands.

SYNOPSIS

use Commands::Guarded;

my $var = 0;

step something =>
ensure { $var == 1 }
using { $var = 1 }
; # $var is now 1

step nothing =>
ensure { $var == 1 }
using { $var = 2 } # bug!
; # $var is still 1 (good thing too)

my $brokeUnless5 =
step brokenUnless5 =>
ensure { $var == 5 }
using { $var = shift }
; # nothing happens yet

print "var: $varn"; # prints 1

$brokeUnless5->do(5);

print "now var: $varn"; # prints 5

step fail =>
ensure { $var == 3 }
using { $var = 2 }
; # Exception thrown here

This module implements a deterministic, rectifying variant on Dijkstras guarded commands. Each named step is passed two blocks: an ensure block that defines a test for a necessary and sufficient condition of the step, and a using block that will cause that condition to obtain.

If step is called in void context (i.e., is not assigned to anything or used as a value), the step is run immediately, as in this pseudocode:

unless (ENSURE) {
USING;
die unless ENSURE;
}

If step is called in scalar or array context, execution is deferred and instead a Commands::Guarded object is returned, which can be executed as above using the do method. If do is given arguments, they will be passed to the ensure block and (if necessary) the using block.

The interface to Commands::Guarded is thus a hybrid of exported subroutines (see SUBROUTINES below) and non-exported methods (see METHODS).
For a detailed discussion of the reason for this modules existence, see RATIONALE below.

monit is a utility for managing and monitoring, processes, files, directories and devices on a UNIX system.
monit project conducts automatic maintenance and repair and can execute meaningful causal actions in error situations.
monit has monitored and mended computers around the world for over 4 years and is used on thousands of servers. Join the comunity today, download and install monit!
Monit can start a process if it does not run, restart a process if it does not respond and stop a process if it uses to much resources.
You can use monit to monitor files, directories and devices for changes, such as timestamp changes, checksum changes or size changes. You can also monitor remote hosts; monit can ping a remote host and can check TCP/IP port connections and server protocols.
Monit is controlled via an easy to use control file based on a free-format, token-oriented syntax. Monit logs to syslog or to its own log file and notifies you about error conditions and recovery status via customizable alert.
Enhancements:
- This is a feature and bugfix release.

Snow Path Formation Simulator is a program that models the process of people forming very distinct, and yet not always altogether logical looking, paths in the snow as they walk across open spaces.

The evolving condition of the snow is displayed graphically. This project may eventually mature into a screensaver.

Class::Contract - Design-by-Contract OO in Perl.

SYNOPSIS

package ClassName
use Class::Contract;

contract {
inherits BaseClass;

invar { ... };

attr data1;
attr data2 => HASH;

class attr shared => SCALAR;

ctor new;

method methodname;
pre { ... };
failmsg Error message;

post { ... };
failmsg Error message;

impl { ... };

method nextmethod;
impl { ... };

class method sharedmeth;
impl { ... };

# etc.
};

Background

Design-by-contract is a software engineering technique in which each module of a software system specifies explicitly what input (or data or arguments) it requires, and what output (or information or results) it guarantees to produce in response.

These specifications form the "clauses" of a contract between a module and the client software that uses it. If the client software abides by the input requirements, the module guarantees to produce the correct output. Hence by verifying these clauses at each interaction with a module, the overall behaviour of the system can be confidently predicted.
Design-by-contract reinforces the benefits of modular design techniques by inserting explicit compile-time or run-time checks on a contract. These checks are most often found in object-oriented languages and are typically implemented as pre-conditions and post-conditions on methods, and invariants on classes.

Note that these features differ from simple verification statements such as the C assert statement. Conditions and invariants are properties of a class, and are inherited by derived classes.

An additional capacity that is often provided in design-by-contract systems is the ability to selectively disable checking in production code. This allows the contractual testing to be carried out during implementation, without impinging on the performance of the final system.

Adding design-by-contract to Perl

The Class::Contract module provides a framework for specifying methods and attributes for a class (much like the existing class definition modules Class::Struct, Class::MethodMaker, and Class::Generate). Class::Contract allows both per-object and per-class methods and attributes to be defined. Attributes may be scalar-, array-, hash-, or object-based.

Class::Contract differs from other class-specification modules (except Class::Generate) in that it also provides the ability to specify invariant conditions on classes, and pre- and post-conditions on methods and attributes. All of these clauses are fully inheritable, and may be selectively disabled. It differs from all other modules in that it has a cleaner, simpler specification syntax, and -- more importantly -- it enforces encapsulation of object attributes, thereby ensuring that the class contract cannot be subverted.

Defining classes

Class::Contract provides an explicit syntax for defining the attributes, methods, and constructors of a class. The class itself is defined using the contract subroutine. contract takes a single argument -- a subroutine reference or a block. That block is executed once and the results used to construct and install the various components of the class in the current package:

package Queue;
contract {
# specification of class Queue attributes and methods here
};

Apache Portable Runtime (APR) project mission is to create and maintain software libraries that provide a predictable and consistent interface to underlying platform-specific implementations.
The primary goal is to provide an API to which software developers may code and be assured of predictable if not identical behaviour regardless of the platform on which their software is built, relieving them of the need to code special-case conditions to work around or take advantage of platform-specific deficiencies or features.
Main features:
- Atomic operations
- Dynamic Shared Object loading
- File I/O
- Locks (mutexes, condition variables, etc)
- Memory management (high performance allocators)
- Memory-mapped files
- Multicast Sockets
- Network I/O
- Shared memory
- Thread and Process management
- Various data structures (tables, hashes, priority queues, etc)
Enhancements:
- Various bugs were fixed.
- The API compatible with version 1.2.7.