--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/geo-backend/src/main/java/de/intevation/gnv/geobackend/base/query/cache/CacheCleaner.java	Tue Apr 20 12:42:17 2010 +0000
@@ -0,0 +1,229 @@
+/**
+ *
+ */
+package de.intevation.gnv.geobackend.base.query.cache;
+
+import java.sql.Date;
+import java.util.Collection;
+import java.util.Iterator;
+
+import org.apache.log4j.Logger;
+
+import de.intevation.gnv.geobackend.base.Result;
+import de.intevation.gnv.geobackend.base.query.DefaultQueryExceutor;
+import de.intevation.gnv.geobackend.base.query.QueryExecutor;
+import de.intevation.gnv.geobackend.base.query.QueryExecutorFactory;
+import de.intevation.gnv.geobackend.base.query.exception.QueryException;
+import de.intevation.gnv.geobackend.util.DateUtils;
+
+/**
+ * Thread that looks every n - Minutes if an Cache has to be cleanedup.
+ * You can configure the Timeout in Seconds using the Systemproperty
+ * @author <a href="mailto:tim.englich@intevation.de">Tim Englich</a>
+ *
+ */
+public class CacheCleaner extends Thread {
+
+    /**
+     * the logger, used to log exceptions and additonaly information
+     */
+    private static Logger log = Logger.getLogger(CacheCleaner.class);
+
+    /**
+     * The Systemproperty-identifier for the Configuration of the TimeInterval
+     */
+    public static final String CACHE_CLEANER_INTERVAL = "caching.cleaner.interval";
+    
+    /**
+     * The Time To wait between two Cleanups.
+     */
+    private long timeout = 1000 * 60; // 1 Minute
+    
+    /**
+     * The Border which has to be used to Query the updated Tables.
+     */
+    private long lowerBorderTime = 0;
+
+    /**
+     * The Id to Lookup the SQL-Statement for fetchung the Names of the
+     * updated Tables.
+     */
+    private String queryID = "updated_tables";
+
+    /**
+     * Constructor
+     */
+    public CacheCleaner() {
+        this.setUp();
+    }
+
+    /**
+     * Constructor
+     * @param arg0
+     */
+    public CacheCleaner(Runnable arg0) {
+        super(arg0);
+        this.setUp();
+    }
+
+    /**
+     * Constructor
+     * @param arg0
+     */
+    public CacheCleaner(String arg0) {
+        super(arg0);
+        this.setUp();
+    }
+
+    /**
+     * Constructor
+     * @param arg0
+     * @param arg1
+     */
+    public CacheCleaner(ThreadGroup arg0, Runnable arg1) {
+        super(arg0, arg1);
+        this.setUp();
+    }
+
+    /**
+     * Constructor
+     * @param arg0
+     * @param arg1
+     */
+    public CacheCleaner(ThreadGroup arg0, String arg1) {
+        super(arg0, arg1);
+        this.setUp();
+    }
+
+    /**
+     * Constructor
+     * @param arg0
+     * @param arg1
+     */
+    public CacheCleaner(Runnable arg0, String arg1) {
+        super(arg0, arg1);
+        this.setUp();
+    }
+
+    /**
+     * Constructor
+     * @param arg0
+     * @param arg1
+     * @param arg2
+     */
+    public CacheCleaner(ThreadGroup arg0, Runnable arg1, String arg2) {
+        super(arg0, arg1, arg2);
+        this.setUp();
+    }
+
+    /**
+     * Constructor
+     * @param arg0
+     * @param arg1
+     * @param arg2
+     * @param arg3
+     */
+    public CacheCleaner(ThreadGroup arg0, Runnable arg1, String arg2, long arg3) {
+        super(arg0, arg1, arg2, arg3);
+        this.setUp();
+    }
+    
+    /**
+     * Sets up the members of the CacheCleaner.
+     */
+    protected void setUp(){
+        String intervalValue = System.getProperty(CACHE_CLEANER_INTERVAL);
+        if (intervalValue != null){
+            log.info("Set Interval to "+intervalValue+" Seconds");
+            try {
+                this.timeout = Long.parseLong(intervalValue) * 1000;
+            } catch (NumberFormatException e) {
+                log.error(e,e);
+            }
+        }
+    }
+
+    /**
+     * This Method can be used do run the Main-Mechanism of the Thread e.g
+     * from a Unittest.
+     * @return
+     */
+    public boolean test(){
+        log.debug("CacheCleaner.test");
+        this.cleanup();
+        return true;
+    }
+
+    @Override
+    public void run() {
+        log.debug("CacheCleaner.run");
+        long requiredTime = 0;
+        this.lowerBorderTime = System.currentTimeMillis();
+        while (true){
+            long startTime = 0;
+            try {
+                long nextTimeout = timeout-requiredTime;
+                if (nextTimeout > 0){
+                    Thread.sleep(nextTimeout);
+                }
+                startTime = System.currentTimeMillis();
+                log.debug("Sleep "+nextTimeout+"ms cleanup Cache now");
+                this.cleanup();
+            } catch (InterruptedException e) {
+                log.error(e,e);
+            } catch (Exception e){
+                log.error(e,e);
+            }  catch (Throwable t){
+                log.error(t,t);
+            }finally{
+                requiredTime = System.currentTimeMillis() - startTime;
+                log.debug("CleanUp required "+requiredTime);
+            }
+        }
+    }
+
+    /**
+     * Method that do the Cleanup-Work
+     */
+    protected void cleanup(){
+        log.debug("CacheCleaner.cleanup");
+        try {
+            // We have to go this Way to avoid using the Cache for this Query.
+            String[] tableNames = this.getUpdatedTableNames();
+            if (tableNames != null){
+                QueryExecutorFactory.getInstance()
+                                    .getQueryExecutor().clearCache(tableNames);
+            }
+        } catch (QueryException e) {
+            log.error(e,e);
+        }
+        
+    }
+
+    /**
+     * Returns the Names of the Tables which have been updated.
+     * @return the Names of the Tables which have been updated.
+     * @throws QueryException
+     */
+    protected String[] getUpdatedTableNames()throws QueryException {
+        String[] tableNames = null;
+        QueryExecutor queryExecutor = new DefaultQueryExceutor();
+        Date date = new Date(this.lowerBorderTime);
+        this.lowerBorderTime = System.currentTimeMillis();
+        log.debug("New Lookup at "+DateUtils.getPatternedDateAmer(new Date(lowerBorderTime)));
+        String queryDate = DateUtils.getPatternedDateAmer(date);
+        Collection<Result> result = queryExecutor.
+                                      executeQuery(queryID, 
+                                                   new String[]{queryDate});
+        if (result != null && !result.isEmpty()){
+            tableNames = new String[result.size()];
+            Iterator<Result> it = result.iterator();
+            int i = 0;
+            while (it.hasNext()){
+                tableNames[i++] = it.next().getString(0).toUpperCase();
+                log.debug("Table that was updated: "+tableNames[i-1]);
+            }
+        }
+        return tableNames;
+    }
+}