X-Git-Url: https://gerrit.onap.org/r/gitweb?a=blobdiff_plain;f=auth%2Fauth-core%2Fsrc%2Fmain%2Fjava%2Forg%2Fonap%2Faaf%2Fauth%2Fcache%2FCache.java;h=ca387dc51da0965e69e310f2c37b818f722ce830;hb=1296352d8eafee57f982a4342ad79ada4aa56d28;hp=9d48ecbec186f2f86c3ce0419470e9eb17dcfeea;hpb=3609e1a0f524988c0158b8065f805976f88ae989;p=aaf%2Fauthz.git diff --git a/auth/auth-core/src/main/java/org/onap/aaf/auth/cache/Cache.java b/auth/auth-core/src/main/java/org/onap/aaf/auth/cache/Cache.java index 9d48ecbe..ca387dc5 100644 --- a/auth/auth-core/src/main/java/org/onap/aaf/auth/cache/Cache.java +++ b/auth/auth-core/src/main/java/org/onap/aaf/auth/cache/Cache.java @@ -7,9 +7,9 @@ * 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. @@ -31,170 +31,169 @@ import java.util.Set; import java.util.Timer; import java.util.TimerTask; import java.util.concurrent.ConcurrentHashMap; -import java.util.logging.Level; import org.onap.aaf.misc.env.Env; import org.onap.aaf.misc.env.Trans; /** * Create and maintain a Map of Maps used for Caching - * + * * @author Jonathan * * @param * @param */ public class Cache { - private static Clean clean; - private static Timer cleanseTimer; - - public static final String CACHE_HIGH_COUNT = "CACHE_HIGH_COUNT"; - public static final String CACHE_CLEAN_INTERVAL = "CACHE_CLEAN_INTERVAL"; - - private static final Map> cacheMap; - - static { - cacheMap = new HashMap<>(); - } - - /** - * Dated Class - store any Data with timestamp - * - * @author Jonathan - * - */ - public static final class Dated { - public Date timestamp; - public List data; - private long expireIn; - - public Dated(List data, long expireIn) { - timestamp = new Date(System.currentTimeMillis()+expireIn); - this.data = data; - this.expireIn = expireIn; - } - - public Dated(T t, long expireIn) { - timestamp = new Date(System.currentTimeMillis()+expireIn); - ArrayList al = new ArrayList<>(1); - al.add(t); - data = al; - this.expireIn = expireIn; - } - - public void touch() { - timestamp = new Date(System.currentTimeMillis()+expireIn); - } - } - - public static Map obtain(String key) { - Map m = cacheMap.get(key); - if(m==null) { - m = new ConcurrentHashMap<>(); - synchronized(cacheMap) { - cacheMap.put(key, m); - } - } - return m; - } - - /** - * Clean will examine resources, and remove those that have expired. - * - * If "highs" have been exceeded, then we'll expire 10% more the next time. This will adjust after each run - * without checking contents more than once, making a good average "high" in the minimum speed. - * - * @author Jonathan - * - */ - private static final class Clean extends TimerTask { - private final Env env; - private Set set; - - // The idea here is to not be too restrictive on a high, but to Expire more items by - // shortening the time to expire. This is done by judiciously incrementing "advance" - // when the "highs" are exceeded. This effectively reduces numbers of cached items quickly. - private final int high; - private long advance; - private final long timeInterval; - - public Clean(Env env, long cleanInterval, int highCount) { - this.env = env; - high = highCount; - timeInterval = cleanInterval; - advance = 0; - set = new HashSet<>(); - } - - public synchronized void add(String key) { - set.add(key); - } - - public void run() { - int count = 0; - int total = 0; - // look at now. If we need to expire more by increasing "now" by "advance" - Date now = new Date(System.currentTimeMillis() + advance); - - - for(String name : set) { - Map map = cacheMap.get(name); - if(map==null) { - continue; - } - - for(Map.Entry me : map.entrySet()) { - ++total; - if (me.getValue().timestamp.before(now)) { - map.remove(me.getKey()); - ++count; - } - } - } - - if(count>0) { - env.info().log(Level.INFO, "Cache removed",count,"expired Cached Elements out of", total); - } - - // If High (total) is reached during this period, increase the number of expired services removed for next time. - // There's no point doing it again here, as there should have been cleaned items. - if(total>high) { - // advance cleanup by 10%, without getting greater than timeInterval. - advance = Math.min(timeInterval, advance+(timeInterval/10)); - } else { - // reduce advance by 10%, without getting lower than 0. - advance = Math.max(0, advance-(timeInterval/10)); - } - } - } - - public static synchronized void startCleansing(Env env, String ... keys) { - if(cleanseTimer==null) { - cleanseTimer = new Timer("Cache Cleanup Timer"); - int cleanInterval = Integer.parseInt(env.getProperty(CACHE_CLEAN_INTERVAL,"60000")); // 1 minute clean cycles - int highCount = Integer.parseInt(env.getProperty(CACHE_HIGH_COUNT,"5000")); - cleanseTimer.schedule(clean = new Clean(env, cleanInterval, highCount), cleanInterval, cleanInterval); - } - - for(String key : keys) { - clean.add(key); - } - } - - public static void stopTimer() { - if(cleanseTimer!=null) { - cleanseTimer.cancel(); - cleanseTimer = null; - } - } - - public static void addShutdownHook() { - Runtime.getRuntime().addShutdownHook(new Thread() { - @Override - public void run() { - Cache.stopTimer(); - } - }); - } + private static Clean clean; + private static Timer cleanseTimer; + + public static final String CACHE_HIGH_COUNT = "CACHE_HIGH_COUNT"; + public static final String CACHE_CLEAN_INTERVAL = "CACHE_CLEAN_INTERVAL"; + + private static final Map> cacheMap; + + static { + cacheMap = new HashMap<>(); + } + + /** + * Dated Class - store any Data with timestamp + * + * @author Jonathan + * + */ + public static final class Dated { + public Date timestamp; + public List data; + private long expireIn; + + public Dated(List data, long expireIn) { + timestamp = new Date(System.currentTimeMillis()+expireIn); + this.data = data; + this.expireIn = expireIn; + } + + public Dated(T t, long expireIn) { + timestamp = new Date(System.currentTimeMillis()+expireIn); + ArrayList al = new ArrayList<>(1); + al.add(t); + data = al; + this.expireIn = expireIn; + } + + public void touch() { + timestamp = new Date(System.currentTimeMillis()+expireIn); + } + } + + public static Map obtain(String key) { + Map m = cacheMap.get(key); + if (m==null) { + m = new ConcurrentHashMap<>(); + synchronized(cacheMap) { + cacheMap.put(key, m); + } + } + return m; + } + + /** + * Clean will examine resources, and remove those that have expired. + * + * If "highs" have been exceeded, then we'll expire 10% more the next time. This will adjust after each run + * without checking contents more than once, making a good average "high" in the minimum speed. + * + * @author Jonathan + * + */ + private static final class Clean extends TimerTask { + private final Env env; + private Set set; + + // The idea here is to not be too restrictive on a high, but to Expire more items by + // shortening the time to expire. This is done by judiciously incrementing "advance" + // when the "highs" are exceeded. This effectively reduces numbers of cached items quickly. + private final int high; + private long advance; + private final long timeInterval; + + public Clean(Env env, long cleanInterval, int highCount) { + this.env = env; + high = highCount; + timeInterval = cleanInterval; + advance = 0; + set = new HashSet<>(); + } + + public synchronized void add(String key) { + set.add(key); + } + + public void run() { + int count = 0; + int total = 0; + // look at now. If we need to expire more by increasing "now" by "advance" + Date now = new Date(System.currentTimeMillis() + advance); + + + for (String name : set) { + Map map = cacheMap.get(name); + if (map==null) { + continue; + } + + for (Map.Entry me : map.entrySet()) { + ++total; + if (me.getValue().timestamp.before(now)) { + map.remove(me.getKey()); + ++count; + } + } + } + + if (count>0) { + env.debug().log("Cache removed",count,"expired Cached Elements out of", total); + } + + // If High (total) is reached during this period, increase the number of expired services removed for next time. + // There's no point doing it again here, as there should have been cleaned items. + if (total>high) { + // advance cleanup by 10%, without getting greater than timeInterval. + advance = Math.min(timeInterval, advance+(timeInterval/10)); + } else { + // reduce advance by 10%, without getting lower than 0. + advance = Math.max(0, advance-(timeInterval/10)); + } + } + } + + public static synchronized void startCleansing(Env env, String ... keys) { + if (cleanseTimer==null) { + cleanseTimer = new Timer("Cache Cleanup Timer"); + int cleanInterval = Integer.parseInt(env.getProperty(CACHE_CLEAN_INTERVAL,"60000")); // 1 minute clean cycles + int highCount = Integer.parseInt(env.getProperty(CACHE_HIGH_COUNT,"5000")); + cleanseTimer.schedule(clean = new Clean(env, cleanInterval, highCount), cleanInterval, cleanInterval); + } + + for (String key : keys) { + clean.add(key); + } + } + + public static void stopTimer() { + if (cleanseTimer!=null) { + cleanseTimer.cancel(); + cleanseTimer = null; + } + } + + public static void addShutdownHook() { + Runtime.getRuntime().addShutdownHook(new Thread() { + @Override + public void run() { + Cache.stopTimer(); + } + }); + } }