file cache management

IE Cache Files FlashGet description
IE Cache Files FlashGet 2006 - Recover temporary Internet Files from IEcache IE Cache Files FlashGet 2007 will help you recover temporary Internet Files from IEcache. its can recover Graphics (bmp, ico, gif, jpeg, png), Audio (mp3, mid, wav), video (wmv, asf, rm, swf), Documents (html, pdf, txt) from temporary Internet Files.

Requirements:

· Least 64 MB RAM. Least 100 MB free hard-disk space.VGA 800x600 minimum.


Limitations:

· 5 days trial

Cache::Cache Perl module contains the Cache interface.

The Cache modules are designed to assist a developer in persisting data for a specified period of time. Often these modules are used in web applications to store data locally to save repeated and redundant expensive calls to remote machines or databases. People have also been known to use Cache::Cache for its straightforward interface in sharing data between runs of an application or invocations of a CGI-style script or simply as an easy to use abstraction of the filesystem or shared memory.

The Cache::Cache interface is implemented by classes that support the get, set, remove, size, purge, and clear instance methods and their corresponding static methods for persisting data across method calls.

USAGE

First, choose the best type of cache implementation for your needs. The simplest cache is the MemoryCache, which is suitable for applications that are serving multiple sequential requests, and wish to avoid making redundant expensive queries, such as an Apache/mod_perl application talking to a database. If you wish to share that data between processes, then perhaps the SharedMemoryCache is appropriate, although its behavior is tightly bound to the underlying IPC mechanism, which varies from system to system, and is unsuitable for large objects or large numbers of objects.

When the SharedMemoryCache is not acceptable, then FileCache offers all of the same functionality with similar performance metrics, and it is not limited in terms of the number of objects or their size. If you wish to maintain a strict limit on the size of a file system based cache, then the SizeAwareFileCache is the way to go. Similarly, the SizeAwareMemoryCache and the SizeAwareSharedMemoryCache add size management functionality to the MemoryCache and SharedMemoryCache classes respectively.

Using a cache is simple. Here is some sample code for instantiating and using a file system based cache.

use Cache::FileCache;

my $cache = new Cache::FileCache( );

my $customer = $cache->get( $name );

if ( not defined $customer )
{
$customer = get_customer_from_db( $name );
$cache->set( $name, $customer, "10 minutes" );
}

return $customer;

Innovation File Management
* Clean all junk files from your hard disk.
* Clean all trace your visit(Surfing history, Cookies, Visited document, etc.)
* Delete your confidential document without resuming.


Is your PC becoming increasingly slow and unstable? If so, you need a professional File Management and a repair tool. Installing and uninstalling software may make your hard disk a mess, leading to decreased PC performance and causing computer crashes. Innovation File Management uses a highly intelligent engine to scan your hard disk & improve PC performance! And it can protect your privacy!

File Management System description
If your download files or copy text, you can use File Management System to save and track your information If your download files or copy text, you can use File Management System to save and track your information. Search for files by filename, description, and website address. Use the applications file manager to rename or delete files from your computer and it will update the database for you.

Add code snippets to the database by using the copy and paste feature. Search your snippets by title, filter all searches by group type and website address. There are several reports to help you track and manage your files and snippets. Activate the login feature to protect your database. Can be used on PC or Server.

Requirements:

· 20 records per files and snippets

Webx ASP File Management description
A web-based file management system for sharing files. Webx ASP File Management was designed to be a web-based file management system for sharing files with user permissions.

It features easy user interface and online administration which will allow you to manage users. This includes downloadable items such as: software, eBooks, music, movies, digital art, manuals, articles, certificates, forms, files, and anything else that can be downloaded.

Here are some key features of "Webx ASP File Management":

· Password protected security system.
· Detailed listing of files and folders with "Name", "Size", "Type", "Last Modified" columns . Two colored highlighting for readability and ability to refresh the listing.
· Status messages with reasons after every successful or failed action.
· Details of the current folder.
· Icons for different items. Folders, editable files, viewable files and normal files have different icons. Clicking these icons, you can edit text files, view image files and get file/folder details.
· Create, delete and rename a files and folders.
· Easy download by just double clicking items in the list.
· Ability to upload a file to current remote folder. Uploading does not require any 3rd party components so it works on every web server with a recent MDAC version installed (see requirements below).
· File Transfer Plugin system which enables you to write your own upload/download plugin which utilizes your favorite 3rd party component and to use it instead of the generic file transfer plugin provided.
· Customizable root folder. Navigating upper levels from the root folder is prevented.
· Internal text editor which can edit files.
· Internal image viewer which can load images.
· Download files (brings up save as dialog) or open them in a new browser window.
· A user has a username and a password. Users have to log into Webx in order to access files. Users are restricted by their access permissions defined in their account. Each user may have a home folder (/username) on which full permissions apply.
· Administrator can remove the ability for the user to rename and/or delete files/folders.
· There is a default user named "admin" who is the "Administrator". The user "admin" is titled Super Administrator and can manage the complete application. The user "admin" cannot be removed from the system. Members can be added as an "Administrator" and can access the administration section where they can manage users, files, and folders, some function are disabled.


Requirements:

· MS Access 2000 database support
· Active Server Pages (ASP)
· CDONTS or CDOSYS email component

Cache::Mmap Perl module helps you to share data cache using memory mapped files.

SYNOPSIS

use Cache::Mmap;

$cache=Cache::Mmap->new($filename,%options);

$val1=$cache->read($key1);
$cache->write($key2,$val2);
$cache->delete($key3);

This module implements a shared data cache, using memory mapped files. If routines are provided which interact with the underlying data, access to the cache is completely transparent, and the module handles all the details of refreshing cache contents, and updating underlying data, if necessary.
Cache entries are assigned to "buckets" within the cache file, depending on the key. Within each bucket, entries are stored approximately in order of last access, so that frequently accessed entries will move to the head of the bucket, thus decreasing access time. Concurrent accesses to the same bucket are prevented by file locking of the relevant section of the cache file.

CONFIGURATION METHODS

These methods are used to examine/update the configuration of a cache. Most of these methods are read-only, and the value returned may be different to that passed to the constructor, since the cache may have been created by an earlier process which specified different parameters.

buckets()

Returns the number of buckets in the cache file.

bucketsize()

Returns the size of buckets (in bytes) in the cache file.

cachenegative()

Returns true if items not found in the underlying data are cached anyway.

context()

Returns the context data for reads and writes to the underlying data.

context($context)

Provides new context data for reads and writes to the underlying data.

expiry()

Returns the time in seconds cache entries are considered valid for, or zero for indefinite validity.

pagesize()

Returns the page size (in bytes) of the cache file.

strings()

Returns true if the cache stores strings rather than references.

writethrough()

Returns true if items written to the cache are immediately written to the underlying data.

Cache Status is a Firefox extension that provides easy cache status & management from the status bar

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.

Whats New in This Release:

· 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.

Netscape::Cache is a Perl object class for accessing Netscape cache files.

SYNOPSIS

The object oriented interface:

use Netscape::Cache;

$cache = new Netscape::Cache;
while (defined($url = $cache->next_url)) {
print $url, "n";
}

while (defined($o = $cache->next_object)) {
print
$o->{URL}, "n",
$o->{CACHEFILE}, "n",
$o->{LAST_MODIFIED}, "n",
$o->{MIME_TYPE}, "n";
}

The TIEHASH interface:

use Netscape::Cache;

tie %cache, Netscape::Cache;
foreach (sort keys %cache) {
print $cache{$_}->{URL}, "n";
}

The Netscape::Cache module implements an object class for accessing the filenames and URLs of the cache files used by the Netscape web browser.

Note: You can also use the undocumented pseudo-URLs about:cache, about:memory-cache and about:global-history to access your disk cache, memory cache and global history.
There is also an interface for using tied hashes.

Netscape uses the old Berkeley DB format (version 1.85) for its cache index index.db. Version 2.x.x is incompatible with the old format (db_intro(3)), so you have either to downgrade or to convert the database using db_dump185 and db_load. See convert_185_2xx for a (experimental) converter function.

Cache Status description
Cache status & management from the status bar Cache Status will provide easy cache status and management from the status bar

Requirements:

· Firefox 1.5 - 2.0.0.*

IE Cache Trasher deletes a file called "download cache" which can get quite big if you do not watch it. This file stores incomplete and complete downloads (the latter only if you set IE to remember your last completed downloads). It can grow to enormous proportions; mine was 119 MB the first time I checked!

When IE Cache Trasher is run, if the download cache exists, a dialog will display the size of the cache in kilobytes and give you the option to delete it. Depending on your choice, IE Cache Trasher will inform you of the success of your choice, then quit.

Completly freeware.

Cache::BerkeleyDB Perl module implements the Cache::Cache interface.

This module implements the Cache interface provided by the Cache::Cache family of modules written by DeWitt Clinton. It provides a practically drop-in replacement for Cache::FileCache.

As should be obvious from the name, the backend is based on BerkeleyDB.

SYNOPSIS

use Cache::BerkeleyDB;

my $cache = new Cache::BerkeleyDB( { namespace => MyNamespace,
default_expires_in => 600 } );

See Cache::Cache for the usage synopsis.

METHODS

See Cache::Cache for the API documentation. Only changes relative to the standard methods are mentioned below.

Clear( [$cache_root] )

See Cache::Cache, with the optional $cache_root parameter.

Purge( [$cache_root] )

See Cache::Cache, with the optional $cache_root parameter.

Size( [$cache_root] )

See Cache::Cache, with the optional $cache_root parameter.

OPTIONS

See Cache::Cache for standard options. Additionally, options are set by passing in a reference to a hash containing any of the following keys:

cache_root

The location in the filesystem that will hold the BDB files representing the cache namespaces. Defaults to /tmp unless explicitly set.
umask
The umask which will be active when any cache files are created. Defaults to 002. Note that this will have no effect on existing files.

Mod-Cache is a cache(reverse-proxy) accelerator plugin for lighttpd, which works like Squid with similar configuration. However mod_cache is faster and more effective than Squid because of powerful Lighttpd.

Mod-Cache has following advantages over Squid:

· Simpler. Mod-Cache just sets proper flags between lighttpd request handling stages. Request is handled by mod_staticfile or mod_compress or other modules.
· More Robust. Mod-Cache uses disk file instead of memory as cache. Without use of memory, mod_cache is far away from memory leaks and memory exhaustion.
· Faster. Lighttpd uses Sendfile syscall to service disk file. Sendfile syscall, which writes file to network interface directly, has the same effecience as Writev syscall which writes memory buffers to network interface.
· More Powerful. Mod-Cache can works with other lighttpd plugins(except mod_deflate). For examples, you can use mod_compress to compress cached files on-fly; or you can use mod_access/mod_trigger_b4_dl to do anti-hot-link; or you can use mod_flv_streaming to do native flv file streaming.

Whats New in This Release:

· lighttpd 1.5 was upgraded to r1811.
· The status page for mod_status was added.
· cache.ignore-hostname was added.
· A bug for checking the cachehd file was fixed.