org.apache.axiom.attachments.AttachmentCacheMonitor Maven / Gradle / Ivy
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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 org.apache.axiom.attachments;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Timer;
import java.util.TimerTask;
import java.io.File;
import java.security.AccessController;
import java.security.PrivilegedAction;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
/**
* The CacheMonitor is responsible for deleting temporary attachment files
* after a timeout period has expired.
*
* The register method is invoked when the attachment file is created.
* The access method is invoked whenever the attachment file is accessed.
* The checkForAgedFiles method is invoked whenever the monitor should look for
* files to cleanup (delete).
*
*/
public final class AttachmentCacheMonitor {
static Log log =
LogFactory.getLog(AttachmentCacheMonitor.class.getName());
// Setting this property puts a limit on the lifetime of a cache file
// The default is "0", which is interpreted as forever
// The suggested value is 300 seconds
private int attachmentTimeoutSeconds = 0; // Default is 0 (forever)
private int refreshSeconds = 0;
public static final String ATTACHMENT_TIMEOUT_PROPERTY = "org.apache.axiom.attachments.tempfile.expiration";
// HashMap
// Key String = Absolute file name
// Value Long = Last Access Time
private HashMap files = new HashMap();
// Delete detection is batched
private Long priorDeleteMillis = getTime();
private Timer timer = null;
private static AttachmentCacheMonitor _singleton = null;
/**
* Get or Create an AttachmentCacheMonitor singleton
* @return the singleton instance
*/
public static synchronized AttachmentCacheMonitor getAttachmentCacheMonitor() {
if (_singleton == null) {
_singleton = new AttachmentCacheMonitor();
}
return _singleton;
}
/**
* Constructor
* Intentionally private. Callers should use getAttachmentCacheMonitor
* @see getAttachmentCacheMonitor
*/
private AttachmentCacheMonitor() {
String value = "";
try {
value = System.getProperty(ATTACHMENT_TIMEOUT_PROPERTY, "0");
attachmentTimeoutSeconds = Integer.valueOf(value).intValue();
} catch (Throwable t) {
// Swallow exception and use default, but log a warning message
if (log.isDebugEnabled()) {
log.debug("The value of " + value + " was not valid. The default " +
attachmentTimeoutSeconds + " will be used instead.");
}
}
refreshSeconds = attachmentTimeoutSeconds / 2;
if (log.isDebugEnabled()) {
log.debug("Custom Property Key = " + ATTACHMENT_TIMEOUT_PROPERTY);
log.debug(" Value = " + attachmentTimeoutSeconds);
}
if (refreshSeconds > 0) {
timer = new Timer( true );
timer.schedule( new CleanupFilesTask(),
refreshSeconds * 1000,
refreshSeconds * 1000 );
}
}
/**
* @return timeout value in seconds
*/
public synchronized int getTimeout() {
return attachmentTimeoutSeconds;
}
/**
* This method should
* Set a new timeout value
* @param timeout new timeout value in seconds
*/
public synchronized void setTimeout(int timeout) {
// If the setting to the same value, simply return
if (timeout == attachmentTimeoutSeconds) {
return;
}
attachmentTimeoutSeconds = timeout;
// Reset the refresh
refreshSeconds = attachmentTimeoutSeconds / 2;
// Make sure to cancel the prior timer
if (timer != null) {
timer.cancel(); // Remove scheduled tasks from the prior timer
timer = null;
}
// Make a new timer if necessary
if (refreshSeconds > 0) {
timer = new Timer( true );
timer.schedule( new CleanupFilesTask(),
refreshSeconds * 1000,
refreshSeconds * 1000 );
}
if (log.isDebugEnabled()) {
log.debug("New timeout = " + attachmentTimeoutSeconds);
log.debug("New refresh = " + refreshSeconds);
}
}
/**
* Register a file name with the monitor.
* This will allow the Monitor to remove the file after
* the timeout period.
* @param fileName
*/
public void register(String fileName) {
if (attachmentTimeoutSeconds > 0) {
_register(fileName);
_checkForAgedFiles();
}
}
/**
* Indicates that the file was accessed.
* @param fileName
*/
public void access(String fileName) {
if (attachmentTimeoutSeconds > 0) {
_access(fileName);
_checkForAgedFiles();
}
}
/**
* Check for aged files and remove the aged ones.
*/
public void checkForAgedFiles() {
if (attachmentTimeoutSeconds > 0) {
_checkForAgedFiles();
}
}
private synchronized void _register(String fileName) {
Long currentTime = getTime();
if (log.isDebugEnabled()) {
log.debug("Register file " + fileName);
log.debug("Time = " + currentTime);
}
files.put(fileName, currentTime);
}
private synchronized void _access(String fileName) {
Long currentTime = getTime();
Long priorTime = (Long) files.get(fileName);
if (priorTime != null) {
files.put(fileName, currentTime);
if (log.isDebugEnabled()) {
log.debug("Access file " + fileName);
log.debug("Old Time = " + priorTime);
log.debug("New Time = " + currentTime);
}
} else {
if (log.isDebugEnabled()) {
log.debug("The following file was already deleted and is no longer available: " +
fileName);
log.debug("The value of " + ATTACHMENT_TIMEOUT_PROPERTY +
" is " + attachmentTimeoutSeconds);
}
}
}
private synchronized void _checkForAgedFiles() {
Long currentTime = getTime();
// Don't keep checking the map, only trigger
// the checking if it is plausible that
// files will need to be deleted.
// I chose a value of ATTACHMENTT_TIMEOUT_SECONDS/4
if (isExpired(priorDeleteMillis,
currentTime,
refreshSeconds)) {
Iterator it = files.keySet().iterator();
while (it.hasNext()) {
String fileName = (String) it.next();
Long lastAccess = (Long) files.get(fileName);
if (isExpired(lastAccess,
currentTime,
attachmentTimeoutSeconds)) {
if (log.isDebugEnabled()) {
log.debug("Expired file " + fileName);
log.debug("Old Time = " + lastAccess);
log.debug("New Time = " + currentTime);
log.debug("Elapsed Time (ms) = " +
(currentTime.longValue() - lastAccess.longValue()));
}
deleteFile(fileName);
// Use the iterator to remove this
// file from the map (this avoids
// the dreaded ConcurrentModificationException
it.remove();
}
}
// Reset the prior delete time
priorDeleteMillis = currentTime;
}
}
private boolean deleteFile(final String fileName ) {
Boolean privRet = (Boolean) AccessController.doPrivileged(new PrivilegedAction() {
public Object run() {
return _deleteFile(fileName);
}
});
return privRet.booleanValue();
}
private Boolean _deleteFile(String fileName) {
boolean ret = false;
File file = new File(fileName);
if (file.exists()) {
ret = file.delete();
if (log.isDebugEnabled()) {
log.debug("Deletion Successful ? " + ret);
}
} else {
if (log.isDebugEnabled()) {
log.debug("This file no longer exists = " + fileName);
}
}
return new Boolean(ret);
}
private Long getTime() {
return new Long(System.currentTimeMillis());
}
private boolean isExpired (Long oldTimeMillis,
Long newTimeMillis,
int thresholdSecs) {
long elapse = newTimeMillis.longValue() -
oldTimeMillis.longValue();
return (elapse > (thresholdSecs*1000));
}
private class CleanupFilesTask extends TimerTask {
/**
* Trigger a checkForAgedFiles event
*/
public void run() {
checkForAgedFiles();
}
}
}