source: MDService2/trunk/MDService2/src/eu/clarin/cmdi/mdservice/action/Cache.java @ 521

package eu.clarin.cmdi.mdservice.action;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.Writer;

/**
 * This is a rudimentary caching mechanism.
 * serializes the inputstream to a file (identifier => filename)
 * and returns the inpustream based on the identifier
 * @author master
 *
 */
/* TODO: necessary to maintain own index
 * for resolution of IDs to filenames
 */


public class Cache {
        public static String PREFIX = "_xc";
        
        private static Cache singleton;
        private String cachepath; 
        private Integer cachecounter;
        private static final Integer start_cache = 1;
        
        
        public Cache () {               
                cachepath = Admin.getConfig().getProperty("cache.path");
                cachecounter = initCachecounter();
        }
        
        public static Cache getCache() {
                if (singleton == null) {
                        singleton = new Cache();
                } 
                return singleton;
        }

        protected void finalize() throws Throwable {        
            try {               
                updateCachecounter();
            } catch(Exception e) {
            }       
            finally {           
                super.finalize();
                //more code can be written here as per need of application              
            }
        }
        
        /**
         * here the external key for the data gets cache-internal counter-id assigned
         * which is also returned back
         * can be used (as shorthand instead of the (long) external key) from outside to retrieve the data.
         * This is primarily meant to be able to reuse the recordset-data, when reading one record.  
         * @param id
         * @param instream
         * @return
         */
        public String putInCache(String id, InputStream instream) {

                Integer c = getCounter();
                String xc = PREFIX + c.toString();
            //Admin.writeToFile(formPath(id + xc),instream);
                Admin.writeToFile(formPath(id),instream);
            return xc;
        }
        
        
        public InputStream getFromCache(String id) {
                   File f = new File (formPath(id));
                    
                    if (f.exists()) { // read from file to InputStream;
                        InputStream instream;
                                try {
                                        instream = new FileInputStream(f);
                                        return instream;
                                } catch (FileNotFoundException e) {
                                        // TODO Auto-generated catch block
                                        Admin.notifyUser("Cache: file not found" + f.getPath());
                                        e.printStackTrace();
                                        return null;
                                }
                        
                    } else { //not cached, my dear 
                        return null;
                    }       
        }
 
         //TODO: sanitize-key
        public String formPath (String id) {
            String path = cachepath + id + ".xml";
            return path;
        }
        
        public Integer getCounter () {
                cachecounter = cachecounter +1 ;
                return cachecounter;
        }
        
        /**
         * read counter-integer from file in cache
         * or start that file
         * @return
         */
        public Integer initCachecounter() {
        Integer counter = start_cache;
                boolean init=false;
                File f = new File (Admin.getConfig().getProperty("cache.path") + "counter.txt");
                FileInputStream fis ;
            if (!f.exists()) {
                        try {
                                f.createNewFile();
                        } catch (IOException e2) {
                                Admin.notifyUser("ERROR creating cache counter");
                                e2.printStackTrace();
                        }
            }
            
            try {
              //use buffering, reading one line at a time
              //FileReader always assumes default encoding is OK!
                BufferedReader input =  new BufferedReader(new FileReader(f));
                        try {
                                String line = null; //not declared within while loop
                        /*
                        * readLine is a bit quirky :
                        * it returns the content of a line MINUS the newline.
                        * it returns null only for the END of the stream.
                        * it returns an empty String if two newlines appear in a row.
                        */
                        try {
                                        if (( line = input.readLine()) != null){
                                                try {
                                                        counter = new Integer(line);
                                                } catch (NumberFormatException e) {
                                                // if not a number, write a number
                                                        init=true;      
                                                }  
                                        } else {
                                                init=true;
                                        }
                                } catch (IOException e) {
                                        init=true;
                                }
                        
                        if (init) {                                                     
                            writeCachecounter( start_cache);                                    
                        }
                        
                } finally {
                input.close();
             }          
            }  catch (IOException ex){
                ex.printStackTrace();
            }
            return counter;
        }

        public void updateCachecounter () {
            writeCachecounter( cachecounter);
        }
        public void writeCachecounter (Integer i) {
                File f = new File (Admin.getConfig().getProperty("cache.path") + "counter.txt");
            
                try {
                        Writer output = new BufferedWriter(new FileWriter(f));          
              //FileWriter always assumes default encoding is OK!
                        try {
                                output.write( i);
                        } finally {
                                output.close();
                        }       
                } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
        }
}