net.sf.ehcache.management.sampled.CacheManagerSampler Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of ehcache Show documentation
Show all versions of ehcache Show documentation
Ehcache is an open source, standards-based cache used to boost performance,
offload the database and simplify scalability. Ehcache is robust, proven and full-featured and
this has made it the most widely-used Java-based cache.
/**
* Copyright Terracotta, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.sf.ehcache.management.sampled;
import java.util.Map;
import net.sf.ehcache.util.ManagementAttribute;
/**
* An abstraction for sampled cache manager usage statistics.
*
* @author Abhishek Sanoujam
* @author byoukste
*/
public interface CacheManagerSampler {
/**
* Gets the actual name of the cache manager.
*/
@ManagementAttribute
String getName();
/**
* Gets the cluster uuid if applicable.
*
* @return the cluster uuid
*/
@ManagementAttribute
String getClusterUUID();
/**
* Gets the status attribute of the Ehcache
*
* @return The status value, as a String from the Status enum class
*/
@ManagementAttribute
String getStatus();
/**
* Enables/disables each cache contained by this CacheManager
*
* @param enabled
*/
void setEnabled(boolean enabled);
/**
* Returns if each cache is enabled.
*
* @return boolean indicating that each cache is enabled
*/
@ManagementAttribute
boolean isEnabled();
/**
* Shuts down the CacheManager.
*
* If the shutdown occurs on the singleton, then the singleton is removed, so that if a singleton access method is called, a new
* singleton will be created.
*/
void shutdown();
/**
* Clears the contents of all caches in the CacheManager, but without
* removing any caches.
*
* This method is not synchronized. It only guarantees to clear those elements in a cache at the time that the
* {@link net.sf.ehcache.Ehcache#removeAll()} mehod on each cache is called.
*/
void clearAll();
/**
* Gets the cache names managed by the CacheManager
*/
@ManagementAttribute
String[] getCacheNames() throws IllegalStateException;
/**
* Get a map of cache name to performance metrics (hits, misses).
*
* @return a map of cache metrics
*/
Map getCacheMetrics();
/**
* @return aggregate hit rate
*/
long getCacheHitRate();
/**
* @return aggregate in-memory hit rate
*/
long getCacheInMemoryHitRate();
/**
* @return aggregate off-heap hit rate
*/
long getCacheOffHeapHitRate();
/**
* @return aggregate on-disk hit rate
*/
long getCacheOnDiskHitRate();
/**
* @return aggregate miss rate
*/
long getCacheMissRate();
/**
* @return aggregate in-memory miss rate
*/
long getCacheInMemoryMissRate();
/**
* @return aggregate off-heap miss rate
*/
long getCacheOffHeapMissRate();
/**
* @return aggregate on-disk miss rate
*/
long getCacheOnDiskMissRate();
/**
* @return aggregate put rate
*/
long getCachePutRate();
/**
* @return aggregate update rate
*/
long getCacheUpdateRate();
/**
* @return aggregate remove rate
*/
long getCacheRemoveRate();
/**
* @return aggregate eviction rate
*/
long getCacheEvictionRate();
/**
* @return aggregate expiration rate
*/
long getCacheExpirationRate();
/**
* @return aggregate average get time (ms.)
*/
float getCacheAverageGetTime();
/**
* @return if any contained caches are configured for search
*/
@ManagementAttribute
boolean getSearchable();
/**
* @return aggregate search rate
*/
long getCacheSearchRate();
/**
* @return aggregate search time
*/
long getCacheAverageSearchTime();
/**
* generateActiveConfigDeclaration
*
* @return CacheManager configuration as String
*/
String generateActiveConfigDeclaration();
/**
* generateActiveConfigDeclaration
*
* @param cacheName
* @return Cache configuration as String
*/
String generateActiveConfigDeclaration(String cacheName);
/**
* Are any of the caches transactional
*
* @see net.sf.ehcache.config.CacheConfiguration.TransactionalMode
*/
@ManagementAttribute
boolean getTransactional();
/**
* Get the committed transactions count
*
* @return the committed transactions count
*/
long getTransactionCommittedCount();
/**
* @return aggregate Xa commit rate
*/
long getTransactionCommitRate();
/**
* Get the rolled back transactions count
*
* @return the rolled back transactions count
*/
long getTransactionRolledBackCount();
/**
* @return aggregate Xa rollback rate
*/
long getTransactionRollbackRate();
/**
* Get the timed out transactions count. Note that only transactions which failed to
* commit due to a timeout are taken into account
*
* @return the timed out transactions count
*/
long getTransactionTimedOutCount();
/**
* Returns whether any caches are configured for write-behind
*/
@ManagementAttribute
boolean getHasWriteBehindWriter();
/**
* Returns the total length of all write-behind queues across all caches
*
* @return aggregate writer-behind queue length
*/
long getWriterQueueLength();
/**
* Maximum elements that can be queued for processing by the write-behind writer
*
* @return aggregate of the maximum elements that can be waiting to be processed
* by the write-behind writer across all caches
*/
@ManagementAttribute
int getWriterMaxQueueSize();
/**
* Maximum number of bytes of entries in the disk stores of all caches that
* did not declare their own max size.
*
* @return maximum number of bytes in the disk stores of all caches that
* did not declare their own max size.
*/
@ManagementAttribute
long getMaxBytesLocalDisk();
/**
* @param maxBytes
*/
void setMaxBytesLocalDisk(long maxBytes);
/**
* @param maxBytes
*/
void setMaxBytesLocalDiskAsString(String maxBytes);
/**
* @return Original input for maxBytesLocalDisk
*/
@ManagementAttribute
String getMaxBytesLocalDiskAsString();
/**
* Maximum number of bytes of entries in the heap memory stores of all caches that
* did not declare their own max size.
*
* @return maximum number of bytes in the heap memory stores of all caches that
* did not declare their own max size.
*/
@ManagementAttribute
long getMaxBytesLocalHeap();
/**
* @return Original input for maxBytesLocalHeap
*/
@ManagementAttribute
String getMaxBytesLocalHeapAsString();
/**
* @param maxBytes
*/
void setMaxBytesLocalHeap(long maxBytes);
/**
* @param maxBytes
*/
void setMaxBytesLocalHeapAsString(String maxBytes);
/**
* Maximum number of bytes of entries in the off-heap stores of all caches that
* did not declare their own max size.
*
* @return maximum number of bytes in the off-heap stores of all caches that
* did not declare their own max size.
*/
@ManagementAttribute
long getMaxBytesLocalOffHeap();
/**
* @return Original input for maxBytesLocalOffHeap
*/
@ManagementAttribute
String getMaxBytesLocalOffHeapAsString();
/**
* Execute a BMSQL query against the CacheManager and return result grid.
*
* @param queryString
* @return query result grid
*/
Object[][] executeQuery(String queryString);
}