Free caching software for linux

RtspProxy is a proxy server for multimedia streaming services based on the RTSP protocol.
The current version is a complete rewrite from scratch in Java of previous versions based on C++. The goal is to build a robust and scalable system usable in production environment.
The proxy is based on an asynchronous network framework, Apache MINA , which is built on Java NIO. This framework does permit to RtspProxy to handle high loads and concurrent users.
RTSP Caching Proxy is a proxy server that works with the RTSP protocol in multimedia streaming reproduction. RTSP (Real Time Streaming Protocol) is an emerging protocol for "session initiation" scopes, its purpose is to establish the conditions of an audio-video streaming session. The streaming data is then sent over other channels using other protocol such as RTP (Real Time Protocol).
Using a RTSP proxy does permits to access multimedia content without the need of being directly connected to the internet, for example being behind a corporate firewall.
Enhancements:
- A preliminary implementation of the IP address and host name filter was added.
- The Windows startup script was fixed.
- Session data is properly cleared when a session is closed.
- Only a UDP port pair is used for all RTP/RTCP packet handling and sending for all the connected clients.

CacheFu is a project which speeds up Plone dramatically.
CacheFu speeds up plone sites transparently using a combination of memory, proxy, and browser caching. CacheFu can be used by itself or with squid and/or apache.
CacheFu generates configuration files for squid or squid behind apache (if you are using apache by itself, no special configuration is needed).
Once you have installed CacheFu, your site should run much faster (~10x faster by itself, ~50x faster with squid).
Enhancements:
- This release aims to address some minor issues with generated configuration, documentation, and version compatibility with Plone and Squid.

Cacheout! is a Firefox extension especially for Digg.com and Slashdot.com users, how many times are you unable to access a particular article because the remote server has been slammed by the Digg/Slashdot Effect?

Cacheout! lets you try to access articles through Googles caching service and CoralCDN.org. More being added all the time!

Load up webpages using Googles caching service and CoralCDN.org.

Memcache Engine for MySQL project allows memcache to work as a storage engine to MySQL.
This means that you can SELECT/UPDATE/ INSERTE/DELETE from it as though it is a table in MySQL. This is very experimental.
This is still very experimental.
Memcached is a high-performance, distributed memory object caching system, generic in nature, but intended for use in speeding up dynamic web applications by alleviating database load.
Enhancements:
- Support for discovery of tables was added.
- Row level locks were implemented.
- A major bug in duplicate keys was fixed, along with phantom rows for updates.
- The server status has been updated.

foocache provides a simple PHP4 caching system with tidy support.
foocache is a simple caching system for PHP4 which optionally uses HTML-tidy to clean up the generated HTML Code.
Instead of processing the whole page, a cachefile is loaded, assuming that it exists and is younger than a defined age.
The name of the cache file is generated with the MD5 sum of the Request URI and the HTML post variables. foocache also can highlight (search)strings in the output.
Enhancements:
- Fixed small bug with regexp quoting on searchstring highlight

OSCache is a high performance J2EE caching solution that can cache portions of JSP pages, entire HTTP responses (including dynamically generated images), and arbitrary Java objects.
OpenSymphony Cache can provide your J2EE application with huge performance gains and graceful error tolerance (e.g., in the event of a DB failure, cached content is served).
Fast in-memory caching
OSCache allows you to execute dynamic content periodically (eg every 30 minutes) rather than every request and store the result in memory. Each further request is served directly from the memory cache, resulting in dramatic speed increases.
The cache is keyed programmatically. This means you can calculate a cache key that works for your situation. For example an ecommerce site might use product ID as keys, or content site might use an article date and article ID combination.
The cache is stored in standard scopes that any JSP programmer is familiar with (application or session). The session scope allows you to have different cached content per user. This is one unlike any other caching system weve ever seen.
Persistent on-disk caching
OSCache can also write the cache to disk. This provides caching across server restarts, and caching of datasets that do not fit into memory. Caching can be configured to use memory or file caching, or a combination of both.
If you want to persist the cache to somewhere other than disk, you can plug in a custom PersistenceListener. This allows you to persist the cache to anywhere (for example to a database via JDBC or to LDAP via JNDI).
When using both disk caching and memory caching. It is possible to limit the cache size to avoid using too much memory but let disk cache unlimited, resulting in browser style complementary disk cache. When cached objects are removed from memory, they are still on disk. If the item is needed again and it is not expired the cache file will be used. This also gives fault tolerance if the server crashes.
Persistence can also be switched to overflow mode using the property oscache.persistence.overflow.only. This changes the default behavior (of persisting every cache entry when there is a listener) to only persist when the memory cache capacity has been reached.
Excellent Performance
Written with performance in mind.
Mulitple cache requests can be handled concurrently.
Only one requesting thread needs to update an expired cache entry even if multiple threads are requesting it simultaneously. Other threads can be configured to either receive the recently-expired object, or block until the cached object is updated. Similarly, when a new entry is being added to the cache, other threads requesting that entry will block until it is ready rather than run off and race to build the same object. In a high load environment this can provide enormous performance benefits.
Automatically takes advantage of JRE 1.4 or higher if available.
Clustering support
OSCache can easily be configured to cluster across multiple boxes. This provides both scalability and failover support without any changes required in your caching code.
Flexible Caching System
OSCache allows you to cache portions of JSP pages, arbitrary Java objects, and even entire servlet responses.
Cache capacity can be set allowing you to limit the number of cached objects.
Multiple caching algorithms are supported such as LRU (Least Recently Used), FIFO (First In First Out), or unlimited. It is also possible to plug in your own custom algorithm.
You are given a huge amount of control over the way cached objects expire. Objects can be cached indefinitely, expired once they reach a certain age, or expired based on a cron expression. Programmatic flushing is also possible, and if that is still not enough pluggable RefreshPolicies allow custom refresh strategies.
Cached objects can be grouped together however you like, allowing for powerful management of cached data. This is an extremely useful feature that is far more powerful than what other caching solutions typically offer (such as the flushing of cache keys that match a particular pattern).
Fully event driven! OSCache fires events for various happenings under the hood such as cache entry events (adding, updating, flushing and removing) and cache accesses (hit, stale hit and miss). It is easy to add your own event handlers.
Multiple caches can be created, each with their own unique configuration.
Simple JSP Tag Library
The tag library to perform and control the caching is very simple. See the Tag Reference for more information.
Caching Filter
A Servlet 2.3 Filter allows for caching of entire pages and generated binary files (like dynamically created images or PDF files).
Comprehensive API
For the ultimate control, OSCache can be used through its straightforward API. You can instantiate, configure and control multiple caches programmatically. It would be possible for example to create one small in-memory cache that held currency conversion rates and was updated daily at 2am, while another cache could be purely disk based and used for holding dynamically created images.
Exception Handling
OSCache provides a way for your site to gracefully tolerate errors. This is not error prevention, rather if an error occurs it should not stop your site from functioning. For example if your database goes down, normally your product descriptions will not be browsable. Using OSCache you can cache those descriptions so you can still browse them.
Cache Flushing
Flushing of caches can be controlled via JSP Tags, so these functions can easily be built into your administration interface.
There is programmatic control over what caches are flushed (eg all caches or just a particular scope).
Cached objects can be expired in a number of ways. Objects can be told to expire once they reach a certain age, or, through the use of cron expressions, on particular dates and/or times (eg it is trivial to make an object expire every weekday at 3am). If this is not enough, you can expire objects programmatically as required, or plug in your own custom RefreshPolicy class that can dynamically decide when an object should be flushed.
Entire groups of objects can be easily flushed from the cache. For example suppose you were caching product data as well as entire pages of your website. When a product was updated, you could flush not just the product object but also all the pages that contain information about that product. No more waiting for the cached objects to expire before the updated content shows up on your site!
Portable caching
Pure Java, this means it is platform independent.
OSCache is compliant with Servlet 2.3 and JSP 1.2 standards, which means it should work in the latest generation of servlet containers and application servers.
i18n Aware
The caching is i18n aware and supports all encodings.
Solid Reputation
Thousands of downloads, hundreds of users on the mailing list.
Comprehensive JUnit test suite that covers every aspect of OSCache, including a web stress test and various concurrent cache access scenarios. To back this up, the kind folks at Cortex have supplied us with a Clover license to provide detailed code coverage analysis of our unit tests.
We have solid issue tracking using JIRA to keep track of any feature requests, bug reports and development progress. JIRA is provided courtesy of Atlassian.
Enhancements:
- CRON expressions to expire content at specific dates and/or times.
- Pluggable EntryRefreshPolicy.
- Reduced memory consumption.
- Faster disk persistence.
- DiskPersistenceListener deadlocks are avoided if a process has no rights to delete the cache file.
- There is a new JSP tag _addgroups_, and an interface to get a list of the cache event listeners.
- The commons collection dependency has been removed.
- Java 1.3 support has been dropped.

YACY is a distributed Web crawler and also a caching HTTP/HTTPS proxy. Pages that pass through the proxy are indexed and can be searched using a built-in HTTP server.
YACY peers connect each other and form a P2P-based index exchange network based on distributed hash tables. Explicit web crawls can be done locally or collaboratively, forming a global search and distributed indexing engine for the Web.
YACY also provides URL filtering with blacklist sharing among other proxy peers, individual Web and servlet page hosting, a file sharing zone, and a database engine.
Main features:
- Search your own or the global index
- Crawl your own pages or start distributed crawling
- Run your peer to support other YaCy crawlers
- Provide Information on your peer using the built-in http-server, file-sharing zone and wiki
- Built-in caching http proxy
- Indexing benefits from the proxy cache; private information is not stored or indexed
- Usage of the proxy is not a requisite for web indexing, but it enables you to access the new top-level-domains .yacy
- Filter unwanted content like ad- or spyware; share your web-blacklist with other peers
- Easy installation! No additional database required!
- No central server!
- GPLed, freeware
Enhancements:
- An auto-updater and support for multiple search networks have been added, and the option to index intranet sites in separated networks has been enabled.
- Some interface functions have also been enhanced.

HPUX::Ioscan is a Perl function to handle HPUX ioscan command.

SYNOPSIS

use HPUX::Ioscan ;
my $result = ioscan ();

print "All hardware paths: ", join(" ", keys %$result),"n";

print "One device file of disk :n",
$result->{2/1.6.0}{device_files}[0],
"n";

This module works on top of the HP-UX command ioscan. It forks a process to run the ioscan command and parses its STDOUT. The result is returned in a hash.

This module is quite basic but it may be interesting if you need to write administration program on HP-UX.

You may call ioscan several time in your program without any problem sicne the result is cached. Only the first call to ioscan will actually run the ioscan command. (But you may override the caching of the result)