Free astaroth critical finish software for linux

This tutorial assumes no previous knowledge of scripting or programming, but progresses rapidly toward an intermediate/advanced level of instruction . . . all the while sneaking in little snippets of UNIX wisdom and lore.
Advanced Bash Scripting Guide serves as a textbook, a manual for self-study, and a reference and source of knowledge on shell scripting techniques.
The exercises and heavily-commented examples invite active reader participation, under the premise that the only way to really learn scripting is to write scripts.
Enhancements:
- This release adds a cross-linked index (the final missing critical feature in this project), other new material (including a new appendix and a couple of new example scripts), and bugfixes.
- This is an important update.

The Finishing Scripts for Cluster Installations handle specific post-installation configuration that might not be convienent nor possible using existing cluster installation methods.

The usual installation process is used to build a reasonably configured node, and the system then reboots into normal mode, achieves network visibility, and executes the finishing script.

The finishing script handles all of the finer details of installing packaged or non-packaged software, tweaking installation, setting host/net specific parameters/files, etc. It is controlled via a single, easily modified script.

Sort::External is a Perl module that can sort huge lists.

SYNOPSIS

my $sortex = Sort::External->new( -mem_threshold => 2**24 );
while ( ) {
$sortex->feed($_);
}
$sortex->finish;
while ( defined( $_ = $sortex->fetch ) ) {
&do_stuff_with($_);
}

Problem: You have a list which is too big to sort in-memory.
Solution: "feed, finish, and fetch" with Sort::External, the closest thing to a drop-in replacement for Perls sort() function when dealing with unmanageably large lists.

How it works:

Cache sortable items in memory. Periodically sort the cache and empty it into a temporary sortfile. As sortfiles accumulate, interleave them into larger sortfiles. Complete the sort by sorting the input cache and any existing sortfiles into an output stream.

Note that if Sort::External hasnt yet flushed the cache to disk when finish() is called, the whole operation completes in-memory.

In the CompSci world, "internal sorting" refers to sorting data in RAM, while "external sorting" refers to sorting data which is stored on disk, tape, punchcards, or any storage medium except RAM -- hence, this modules name.

Stringification

Items fed to Sort::External will be returned in stringified form (assuming that the cache gets flushed at least once): $foo = "$foo". Since this is unlikely to be desirable when objects or deep data structures are involved, Sort::External throws an error if you feed it anything other than simple scalars.

Taint and UTF-8 flags

Expert: Sort::External does a little extra bookkeeping to sustain each items taint and UTF-8 flags through the journey to disk and back.

METHODS

new()
my $sortscheme = sub { $Sort::External::b $Sort::External::a };
my $sortex = Sort::External->new(
-mem_threshold => 2**24, # default: 2**20 (1Mb)
-cache_size => 100_000, # default: undef (disabled)
-sortsub => $sortscheme, # default sort: standard lexical
-working_dir => $temp_directory, # default: see below
);

Construct a Sort::External object.

-mem_threshold -- Allow the input cache to consume approximately -mem_threshold bytes before sorting it and flushing to disk. Experience suggests that the optimum setting is somewhere between 2**20 and 2**24: 1-16Mb.
-cache_size -- Specify a hard limit for the input cache in terms of sortable items. If set, overrides -mem_threshold.
-sortsub -- A sorting subroutine. Be advised that you MUST use $Sort::External::a and $Sort::External::b instead of $a and $b in your sub. Before deploying a sortsub, consider using a GRT instead, as described in the Sort::External::Cookbook. Its probably a lot faster.
-working_dir -- The directory where the temporary sortfiles will reside. By default, this directory is created using File::Temps tempdir() command.
feed()

$sortex->feed( @items );

Feed one or more sortable items to your Sort::External object. It is normal for occasional pauses to occur during feeding as caches are flushed and sortfiles are merged.

finish()
# if you intend to call fetch...
$sortex->finish;

# otherwise....
use Fcntl;
$sortex->finish(
-outfile => sorted.txt,
-flags => (O_CREAT | O_WRONLY),
);

Prepare to output items in sorted order.

If you specify the parameter -outfile, Sort::External will attempt to write your sorted list to that location. By default, Sort::External will refuse to overwrite an existing file; if you want to override that behavior, you can pass Fcntl flags to finish() using the optional -flags parameter.

Note that you can either finish() to an -outfile, or finish() then fetch()... but not both.

fetch()
while ( defined( $_ = $sortex->fetch ) ) {
&do_stuff_with($_);
}

Fetch the next sorted item.

Test-AutoBuild is a framework for performing continuous, unattended, automated software builds.
Test-AutoBuild pulls code from source control repositories (CVS, Perforce, and GNU Arch are currently supported), calculates inter-module dependencies, builds each module, and then generates HTML status pages, copies binary packages to Web/FTP server roots, and sends email status alerts. It is written with flexibility and extensibility in mind to make it easy to integrate with a wide range of development tools and languages.
Enhancements:
- The backend build engine has been refactored into a modular workflow engine.
- Support for Mercurial SCM repos has been added, and existing SCM implementations extended to allow extraction of changelogs.
- Performance and scalability are improved by hard linking files instead of copying.
- Error reporting and logging has been enhanced to make debugging of crashes/problems simpler.
- Major work has been done on documentating the tools, configuration file format, and developer APIs.
- The coverage of the test suite has been increased to cover a large portion of the critical code sub-systems.

Reliable Response Notification provides guaranteed delivery of critical messages to a wide range of devices. The project guarantees that every emergency will have one, and only one, person responding and taking charge of the recovery.
For integrated services, like some network monitors, help-desk packages, and security suites, Reliable Response Notification allows the user to update records via their mobile devices. It is available as either a standalone server or as a hosted service.
Enhancements:
- The product supports three types of groups: broadcast, escalation and on-call.
- Many devices are supported, including email, SMS, text-to-speech, Jabber, GTalk, SameTime IM, and alphanumeric pagers.
- Integrations for a number of packages are available.
- There is an easy system to add new integrations as needed.

Ruby Crypt library is a pure-ruby implementation of a number of popular encryption algorithms. Block cyphers currently available include Blowfish, GOST, IDEA, and Rijndael (AES). Cypher Block Chaining (CBC) has been implemented. Twofish, Serpent, and CAST256 are planned for release soon.
Crypt is written entirely in ruby so deployment is simple - no platform concerns, no library dependencies, nothing to compile.
Performance is what you would expect from a pure-ruby implementation: it is adequate for shorter messages but I wouldnt try to encrypt my whole disk with it. If performance is critical then you might want to try ezcryptos interface to OpenSSL.
Enhancements:
- This release is available as a Ruby gem for easy installation.
- A defect in Blowfish was fixed.

Jwapmail is opensource wap based email client written using PHP. Jwapmail has been tested at SonyEriccson T28, and Siemens SL45. Any volutenter of testers are welcome.
Main features:
- 1. Email client standard functions
- Jwapmail support the email client standard functions:
- Compose, Reply, Forward, and Folder.
-
- 2. Message Filter (Not finish yet)
- Message Filter is allow user to manage messages in the folder.
-
- 3. User Profile (Not finish yet)
- Allow user to set user profiles standard such as, Name and email address.
-
- 4. Paging (to overcome content size limitaion)
- Due to the vary limitation of content size in WAP GATEWAY, Jwapmail
- deliver content with size not exceded the maximum size (kbytes) where maximum size
- is a variable set in file configuration.
- If the content of message have the size exceed the maximum bytes
- Jwapmail split into several page and deliver each page with paging navigation link