Free response time software for linux

Firewall-1 Response is a Perl script for performing simple active responses based on a Checkpoint Firewall-1. It is good for closing off your network against people who do port scans or network sweeps.

fw sam provides a command line interface to a limited feature-set of the firewall security policy. The purpose of this is to allow scripts such as this a way to dynamically change the security policy of one or more firewalls without administrator intervention. This should scare you, because of the potential of these changes allowing bad guys to run a DoS attack against you.

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.

Yahoo::Search::Response is a container object for the result set of one query to the Yahoo! Search API. (This package is included in, and automatically loaded by, the Yahoo::Search package.)

Package Use

You never need to use this package directly -- it is loaded automatically by Yahoo::Search.

Object Creation

Response objects are created by the Fetch() method of a Request (Yahoo::Search::Request) object, e.g. by

my $Response = Yahoo::Search->new(...)->Request()->Fetch();

or by shortcuts to the same, such as:

my $Response = Yahoo::Search->Query(...);

WWW::Patent::Page::Response is an object holding a patent page or document (e.g. htm, pdf, tif) from selected source (e.g. from United States Patent and Trademark Office (USPTO) website or the European Patent Office (ESPACE_EP), as constructed by WWW::Patent::Page, in passing analogy to LWP::UserAgent and HTTP::Response.

SYNOPSIS

Please see the test suite for working examples. The following is not guaranteed to be working or up-to-date.

$ perl -I. -MWWW::Patent::Page -e print $WWW::Patent::Page::VERSION,"n"
0.02

use WWW::Patent::Page;

print $WWW::Patent::Page::VERSION,"n";

my $patent_browser = WWW::Patent::Page->new(); # new object

my $document1 = $patent_document->get(6,123,456);
# defaults:
# office => ESPACE_EP,
# country => US,
# format => pdf,
# page => all,
# and usual defaults of LWP::UserAgent (subclassed)

my $document2 = $patent_document->provide_doc(US6123456,
office => ESPACE_EP ,
format => pdf,
page => 2 ,
);

my $pages_known = $patent_document->pages_available( # e.g. TIFF
document=> 6123456,
);

Intent: Use public sources to retrieve patent documents such as TIFF images of patent pages, html of patents, pdf, etc. Expandable for your office of interest by writing new submodules..

PagePoker is a Perl package that defines a browser agent with many powerful features for monitoring and testing Web sites, including elaborate failure handling that can send email and trigger SNMP traps. The application comes with three scripts that implement it for different uses: poke.pl, for single agents; pokes.pl, for many parallel agents, and pokehard.pl, for loadtesting and benchmarking.

HOW-TO:

Run "poke.pl --help" for detailed help on using the package. Briefly, poke.pl creates a PagePoker object, accepting all sorts of options. It is designed for monitoring web pages to verify they are returning desired information or to dump the contents of web pages to a file (like fetch). It can loop on a variety of conditions and crawl a series of pages, posting and passing cookies. The other component, pokes.pl, is simply a forking variation that accepts as its parameters an agent id and the options for that agent. It can be used for monitoring many sites simultaneously or for load testing single sites. On a dual 400 mhz machine I was able to run about 120 concurrent agents.

Examples:

> poke.pl --url http://node.to

returns (first element is date):
20000225170507 SUCCESS: Page loaded by agent

> poke.pl --url http://node.to --no-status --print-response

returns the plain html

> pokes.pl agent1 "--url http://node.to --no-status --email-failures
--email-address who@node.to --iterations 1000 --interval 10"
agent2 "--urls http://node.to>>http://tiny.node.to
--no-status --email-failures --email-address "1@1.com 2@2.com""

will launch two agents, first agent will poll node.to for connection failures every 10 seconds 1000 times, emailing if a failure is encountered, second agent will hit node.to then tiny.node.to and exit, emailing two people if either one doesnt respond.

There is a lot of logic to control how often and under what conditions email is sent. You can search for desired in text the headers or the html response, and send email or snmp traps on certain failure conditions. To loadtest, you could launch looping batches of ten agents, adding ten more a minute later in a another process, etc.

More advanced load testing can be done with pokehard.pl. It gets its own README (README.pokehard).

Here is the output of poke.pl --help, minus the USAGE statement:

How to use it:

--url "http://host/page"

--urls "http://host/page1>>http://host/page2>>etc"

--urls-from-file "file_path"

--urls-delay "n"
Seconds between each request

--method {GET|POST}

--post-query "query string"

--basic-auth-name "agent login" (one per agent)

--basic-auth-pass "agent password"

--interval "n"
Loop with n seconds between pokes

--iterations "n"
Cycles to run loop (requires --interval)

--look-for "pattern to find in response text"

--resend-cookie "cookiename"

--resend-cookie-between-iterations
Allow cookie to be resent through all iterations

--use-verbose-response
Includes headers in response text

--print-response
Dump agent retrieved text to STDOUT

--disable-on-failure
Allow server disabling on failure

--disable-snmp-trap "snmp trap"
To disable in loadbalancer

--enable-on-recovery
Allow server re-enabling on recovery

--enable-snmp-trap "snmp trap"
To enable server after successful run

--email-failures
Turn on alarm emails

--email-addresses "address1 address2 etc"

--email-subject "override default with arbitrary text"

--failures-until-email "n"
Consecutive errors triggers email

--min-time-between-emails "seconds"

--die-after-date "yyyymmddhhmmss" (requires interval and iterations)

--benchmark
Store numbers used for performance measurement (by pokehard.pl)

--quiet
Output nothing (except email, if set)

--no-status
Do not output status info (ie SUCCESS, etc)

--print-to-file "file"
Write output to file

--help
Print this text and exit

PicoXine is a (very small) XINE implementation for playing audio events as a replacement for ARTS. Picoxines extremely small (the source code is only 3.0KiB long!)
It offers great response time, its faster than MPlayer upon start-up, and it has no stdout output if no errors are found. Its, therefore, completely transparent.
It requires Xine-Lib (any version). If your distro uses development packages, you need xine-devel and libc6-devel
Enhancements:
- Added a patch given to me by Diego Flameeyes Petteno
- Further optimisation

AsItHappens is a real-time network performance monitor. AsItHappens project collects data from devices over a network and displays them on a graph, optionally storing collected data in a database for later retrieval.
Current collection types include network response, bandwidth, Cisco NBAR, and Cisco NetFlow. AsItHappens polls data in regular intervals, which can be as low as every second, to give immediate feedback on network performance.
Main features:
- Granular collection of data to the point of collecting every second
- Real-time graphing of collected data
- Response data collection via ICMP or TCP/UDP echo
- Inbound and outbound bandwidth data collection via SNMP
- Cisco NBAR (Network-based Application Recognition) Top-N collection via SNMP
- Cisco NetFlow Top-N collection via SNMP with flow grouping and match criteria options
- Optional database storage of collection sessions
- Retrieval of user-defined time intervals within a stored collection session
- Resizable graphing window with automatic scaling of graph data to fit
- Options to define how to aggregate or interpolate data when graphing e.g. to show maximums instead of averages
- The ability to add text labels to the graphing panel to explain desired areas of the graph