Free external commands software for linux

external IP shows your current external IP in the browsers statusbar.

External IP is set to check your IP address once every hour.

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.

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.

KMetronome project is a MIDI based metronome using the ALSA sequencer.
The intended audience are musicians and music students. Like the solid, real metronomes it is a tool to keep the rithm while playing musical instruments.
It uses MIDI for sound generation instead of digital audio, allowing low CPU usage and very accurate timing thanks to the ALSA sequencer.
Main features:
- Easy to use KDE graphic user interface.
- MIDI only. Can be used with software- or external MIDI synthesizers.
- Based on ALSA sequencer. Provides input and output ports. Very accurate timing.
- Highly customizable parameters.
- Built-in connection manager, can be used with external connection managers.
- External control: play/stop/continue commands, can be controlled using DCOP or MIDI Realtime System messages.
- GPL licensed

POE::Component::ControlPort::Command is a Perl module with register control port commands.

SYNOPSIS

use POE::Component::ControlPort::Command;

POE::Component::ControlPort::Command->register(
name => test,
topic => sample_commands,
usage => test [ text to echo ]
help_text => test command. will echo back all parameters,
command => sub { my %args = @_; return join(" ", @{$args{args}}); }
);

This module has one command for public consumption. register() is the way that one registers commands for use in the control port. The arguments listed in the synopsis are all the available arguments and are all mandatory.

Nagios Config project is a Web-based front end for configuring Nagios 1.x.
Nagios is a host and service monitor designed to inform you of network problems before your clients, end-users or managers do. It has been designed to run under the Linux operating system, but works fine under most *NIX variants as well.
The monitoring daemon runs intermittent checks on hosts and services you specify using external "plugins" which return status information to Nagios. When problems are encountered, the daemon can send notifications out to administrative contacts in a variety of different ways (email, instant message, SMS, etc.). Current status information, historical logs, and reports can all be accessed via a web browser.
Main features:
- Monitoring of network services (SMTP, POP3, HTTP, NNTP, PING, etc.)
- Monitoring of host resources (processor load, disk and memory usage, running processes, log files, etc.)
- Monitoring of environmental factors such as temperature
- Simple plugin design that allows users to easily develop their own host and service checks
- Ability to define network host hierarchy, allowing detection of and distinction between hosts that are down and those that are unreachable
- Contact notifications when service or host problems occur and get resolved (via email, pager, or other user-defined method)
- Optional escalation of host and service notifications to different contact groups
- Ability to define event handlers to be run during service or host events for proactive problem resolution
- Support for implementing redundant and distributed monitoring servers
- External command interface that allows on-the-fly modifications to be made to the monitoring and notification behavior through the use of event handlers, the web interface, and third-party applications
- Retention of host and service status across program restarts
- Scheduled downtime for suppressing host and service notifications during periods of planned outages
- Ability to acknowledge problems via the web interface
- Web interface for viewing current network status, notification and problem history, log file, etc.
- Simple authorization scheme that allows you restrict what users can see and do from the web interface
Enhancements:
- A require_once() statement in cleardb_import.php was fixed.
- The main page was redesigned to be more efficient.
- A problem in services_A1.php was fixed.

etPan is a console mail user agent based on libEtPan! libEtPan ! is a mail purpose library. Its a library that handles mail at low-level: MAP/NNTP/POP3/SMTP over TCP/IP and SSL/TCP/IP, mbox/MH/maildir, message / MIME parser.
Main features:
- IMAP4rev1 / POP3 / NNTP / mbox / mh / maildir
- virtual folder tree
- multiple folder views and message views
- smart multi-threading
- PGP signing and encryption (using GnuPG as external command)
- S/MIME signing and encryption (using OpenSSL as external command)
- SPAM process (using bogofilter as external command)
- user interface for configuration edition

Shake tracker is a MIDI sequencer aimed to all the tracker lovers who allways wanted to go midi, while keeping all sort of cool tracker features.

Shake tracker has a tracker-like interface which supports patterns, orders and IT-like effects.

Each track (midi channel) is subdivided in columns of its on, so this adds an extra layer to pattern editing. Note on, Noteoff and velocity are also implemented the usual way, while the effect column understands most of IT commands with similar parameter ranges. Finally, theres also a controller/effects column and plans for adding "paintable controllers" support.

Shake tracker has been programmed with MIDI bandwith issues in mind, so its perfectly usable on external synths, softsynths and soundcard synths. There is actually a Windows version of this program, but its not native and it needs you to install an Xserver.

Many features of modern sequencers are still missing, such as sysex and midi in, but the program is perfectly usable and many people wrote songs with it (check downloads section).