All Classes and Interfaces
Class
Description
This holds convenience methods used by most auxiliary caches.
This has common attributes used by all auxiliaries.
All ICacheEvents are defined as final.
Base class for auxiliary cache factories.
Used to monitor and repair any failed connection for the lateral cache service.
This class provides the common methods for all types of access to the cache.
An abstract base class to the different implementations
Abstract class providing a base implementation of a disk cache, which can be easily extended to
implement a disk cache for a specific persistence mechanism.
This has common attributes that any conceivable disk cache would need.
This class contains methods that are common to memory caches using the double linked list, such
as the LRU, MRU, FIFO, and LIFO caches.
This class simply configures the http multithreaded connection manager.
This is an abstract template for JCSWorkerHelper implementations. it simple has a convenience
method for setting the finished flag.
This is a simple LRUMap.
This base includes some common code for memory caches.
Abstract base for remote caches.
Shared listener base.
An abstract base for the No Wait Facade.
This class contains common methods for remote cache services.
Tag interface for auxiliary caches.
This is a nominal interface that auxiliary cache attributes should implement.
Configuration util for auxiliary caches.
All auxiliary caches must have a factory that the cache configurator can use to create instances.
This class manages reading an writing data to disk.
There is one BlockDiskCache per region.
This holds attributes for Block Disk Cache configuration.
Creates disk cache instances.
This represents an element on disk.
This is responsible for storing the keys.
This class provides an interface for all types of access to the cache.
Used for Cache-to-Cache messaging purposes.
Generic element wrapper.
Stores info on a cache element for the template
Either serialized value or the value should be null;
It's returned from create and passed into log.
This implementation simple logs to a logger at debug level, for all events.
An event queue is used to propagate ordered cache events to one and only one target listener.
This class hands out event Queues.
This is the most general exception the cache throws.
Deprecated.
The grouping functionality is on the way out.
This is a static variable holder for the distribution auxiliaries that need something like a vmid.
Used to associates a set of [cache listener to cache event queue] for a
cache.
Stores info on a cache region for the template
This class stores cache historical and statistics data for a region.
Cache statuses
Intercepts the requests to the underlying ICacheObserver object so that the listeners can be
recorded locally for remote connection recovery purposes.
Attributes common to remote cache client and server.
This is the primary hub for a single cache/region.
The CompositeCacheAttributes defines the general cache region settings.
This class configures JCS based on a properties object.
Manages a composite cache.
Performs default serialization and de-serialization.
Compress / Decompress.
Thrown if there is some severe configuration problem that makes the cache nonfunctional.
Keeps track of the number of bytes written to it, but doesn't write them anywhere.
Allows us to set the daemon status on the threads.
A factory that returns a DataSource.
This contains info about a discovered service.
This is a generic thread safe double linked list.
This serves as a placeholder in a double linked list.
This is a simple timer utility.
This it the element attribute descriptor class.
Element events will trigger the creation of Element Event objects.
An event queue is used to propagate ordered cache events to one and only one target listener.
This describes the events that an item can encounter.
Performs serialization and de-serialization.
The items are spooled in the order they are added.
Description of the Class
Access for groups.
Used to avoid name conflict when group cache items are mixed with non-group cache items in the
same cache.
Simple utility for getting the local host name.
This factory should create hsql disk caches.
This is the top level interface for all cache like structures.
ICacheAccess defines the behavior for client access.
ICacheAccessManagement defines the methods for cache management, cleanup and shutdown.
Every item is the cache is wrapped in an ICacheElement.
This interface defines the behavior of the serialized element wrapper.
Defines the common fields required by a cache event.
This defines the behavior for event logging.
Interface for a cache event queue.
Used to receive a cache event notification.
Used to register interest in receiving cache changes.
Used to retrieve and update the cache.
Description of the Interface
Used to retrieve and update non local caches, such as the remote and lateral caches.
This holds stat information on a region.
Interface implemented by a specific cache.
This specifies what a remote cache configuration object should look like.
This defines the minimal behavior for the Cache Configuration settings.
I need the interface so I can plug in mock managers for testing.
Interface for things that want to listen to discovery events.
Common disk cache attributes.
Interface for cache element attributes classes.
Defines how an element event object should behave.
This interface defines the behavior for event handler.
Interface for an element event queue.
Defines the behavior for cache element serializers.
IGroupCacheAccess defines group specific behavior for the client access
classes.
Key matchers need to implement this interface.
This interface defines configuration options common to lateral cache plugins.
Listens for lateral cache event notification.
For the framework.
Provides thread safe access to the underlying random access file.
Disk cache that uses a RandomAccessFile with keys stored in memory.
Deprecated.
Use lambda instead
Configuration class for the Indexed Disk Cache
Creates disk cache instances.
Used to dump out a Disk cache from disk for debugging.
Disk objects are located by descriptor entries.
InvalidArgumentException is thrown if an argument is passed to the cache that is invalid.
InvalidGroupException
InvalidHandleException is not used.
Marker interface for providers of the central ScheduledExecutorService
This specifies what a remote cache configuration object should look like.
This defines the behavior expected of a remote cache client.
This holds constants that are used by the remote cache.
In the future, this can be used as a generic dispatcher abstraction.
Listens for remote cache event notification ( rmi callback ).
Interface for managing Remote objects
This defines the minimal behavior for the objects that are used to configure
the remote cache server.
It's not entirely clear that this interface is needed.
Constants used throughout the HTTP remote cache.
Marker interface to allow the injection of a central ScheduledExecutorService
for all modules requiring scheduled background operations.
ShutdownObservers can observe ShutdownObservable objects.
This interface is required of all shutdown observers.
IAuxiliaryCacheStats will hold these IStatElements.
This interface defines the common behavior for a stats holder.
This interface defines functions that are particular to the TCP Lateral Cache
plugin.
Interface to mark an object as zombie for error recovery purposes.
Simple class for using JCS.
A servlet which provides HTTP access to JCS.
A MXBean to expose the JCS statistics to JMX
If you add this to the context listeners section of your web.xml file, this will shutdown JCS
gracefully.
Utility class to encapsulate doing a piece of work, and caching the results
in JCS.
Interface for doing a piece of work which is expected to be cached.
This is the jdbc disk cache plugin.
The configurator will set these values based on what is in the cache.ccf file.
This factory should create JDBC auxiliary caches.
A factory that looks up the DataSource from JNDI.
This is a wrapper around the
java.util.logging.Logger implementing our own
Log interface.This is a SPI factory implementation for java.util.logging
This implementation of the KeyMatcher uses standard Java Pattern matching.
Lateral distributor.
This class stores attributes for all of the available lateral cache auxiliaries.
Used to monitor and repair any failed connection for the lateral cache service.
Used to queue up update requests to the underlying cache.
Used to provide access to multiple services under nowait protection.
Enumeration of the available lateral commands
This class wraps command to other laterals.
Constructs a LateralCacheNoWaitFacade for the given configuration.
This knows how to add and remove discovered services.
Listens for connections from other TCP lateral caches and handles them.
This class is based on the log4j SocketAppender class.
A lateral cache service implementation.
This is a test memory manager using the jdk1.4 LinkedHashMap.
This is a borrowed and stripped-down version of the log4j2 Logger interface.
This is a SPI factory implementation for log4j2
This is a wrapper around the
org.apache.logging.log4j.Logger implementing our own
Log interface.This is a SPI factory interface for specialized Log objects
This is a borrowed and stripped-down version of the log4j2 LogManager class.
This is a node in the double linked list.
Simple LRUMap implementation that keeps the number of the objects below or equal maxObjects
A fast reference management system.
This wrapper is needed for double linked lists.
Handles messages that consist of a format string conforming to
java.text.MessageFormat.
The most recently used items move to the front of the list and get spooled to disk if the cache
hub is configured to use a disk cache.
The MySQLDiskCache extends the core JDBCDiskCache.
This has additional attributes that are particular to the MySQL disk cache.
This factory should create mysql disk caches.
The MySQL Table Optimizer can optimize MySQL tables.
The putSafe method on the JCS convenience class throws this exception if the object is already
present in the cache.
ObjectNotFoundException
This class is based on the log4j class org.apache.log4j.helpers.OptionConverter that was made by
Ceki Gülcü Simon Kitching; Avy Sharell (sharell@online.fr) Anders Kristensen Matthieu
Verbert (mve@zurich.ibm.com) A convenience class to convert property values to specific types.
This object holds configuration data for a thread pool.
An event queue is used to propagate ordered cache events to one and only one target listener.
This class is based on the log4j class org.apache.log4j.config.PropertySetter that was made by
Anders Kristensen
This class is based on the log4j class org.apache.log4j.config.PropertySetter that was made by
Anders Kristensen
Implementation of cache elements in purgatory.
Deprecated.
Functionality moved to RemoteCacheServerFactory
Client proxy for an RMI remote cache.
These objects are used to configure the remote cache client.
The RemoteCacheFactory creates remote caches for the cache hub.
Deprecated.
Functionality moved to RemoteCacheNoWaitFacade
Registered with RemoteCache server.
An instance of RemoteCacheManager corresponds to one remote connection of a specific host and
port.
Used to monitor and repair any failed connection for the remote cache service.
The RemoteCacheNoWait wraps the RemoteCacheClient.
Used to provide access to multiple services under nowait protection.
The basic request wrapper.
This creates request objects.
This is the response wrapper.
This class provides remote cache services.
These attributes are used to configure the remote cache server.
Provides remote cache services.
This servlet can be used to startup the JCS remote cache.
This uses an http client as the service.
Http client specific settings.
This is the service used by the remote http auxiliary cache.
Calls the service.
The RemoteCacheFactory creates remote caches for the cache hub.
Upon the notification of a connection error, the monitor changes to operate in a time driven
mode.
Configuration for the RemoteHttpCacheServer.
This does the work.
This servlet simply reads and writes objects.
Does nothing
Location of the RMI registry.
The different types of requests
Enum to describe the mode of the remote cache
This class provides some basic utilities for doing things such as starting
the registry properly.
Parses the very simple schedule format.
This uses a supplied Serializer to convert to and from cache elements.
A factory that looks up the DataSource using the JDBC2 pool methods.
Calls delete expired on the disk caches.
A background memory shrinker.
This wrapper is needed for double linked lists.
A JCS IMemoryCache that has
SoftReference to all its values.Performs default serialization and de-serialization.
This is a stat data holder.
This is used by various elements of the JDBC disk cache to indicate the
status of a table.
This interface defines functions that are particular to the TCP Lateral Cache plugin.
This manages threadpools for an application
This can be injected into the remote cache server as follows:
Deprecated.
Functionality moved to UDPDiscoveryService
Configuration properties for UDP discover service.
This manages UDPDiscovery Services.
The message sent by the discovery mechanism.
Receives UDP Discovery messages.
This is a generic sender for the UDPDiscovery process.
Deprecated.
Functionality moved to UDPDiscoveryService
This service creates a listener that can create lateral caches and add them to the no wait list.
Zombie adapter for any cache service.
Zombie adapter for the non local cache services.
Base of the other events.
Zombie Observer.