Package ucar.nc2.util

Class DiskCache

java.lang.Object
ucar.nc2.util.DiskCache
public class DiskCache extends Object
This is a general purpose utility for determining a place to write files and cache them, eg for uncompressing files. This class does not scour itself.

Note that when a file in the cache is accessed, its lastModified date is set, which is used for the LRU scouring.

The cdm library sometimes needs to write files, eg to uncompress them, or for grib index files, etc. The first choice is to write these files in the same directory that the original file lives in. However, that directory may not be writeable, so we need to find a place to write them to. We also want to use the file if it already exists.

A writeable cache "root directory" is set:

  1. explicitly by setRootDirectory()
  2. through the system property "nj22.cache" if it exists
  3. by appending "/nj22/cache" to the system property "user.home" if it exists
  4. by appending "/nj22/cache" to the system property "user.dir" if it exists
  5. use "./nj22/cache" if none of the above

Scenario 1: want to uncompress a file; check to see if already have done so, otherwise get a File that can be written to. 

 // see if already uncompressed
 File uncompressedFile = FileCache.getFile(uncompressedFilename, false);
 if (!uncompressedFile.exists()) {
   // nope, uncompress it
   UncompressInputStream.uncompress(uriString, uncompressedFile);
 }
 doSomething(uncompressedFile);

Scenario 2: want to write a derived file always in the cache. 

 File derivedFile = FileCache.getCacheFile(derivedFilename);
 if (!derivedFile.exists()) {
   createDerivedFile(derivedFile);
 }
 doSomething(derivedFile);

Scenario 3: same as scenario 1, but use the default Cache policy: 

 File wf = FileCache.getFileStandardPolicy(uncompressedFilename);
 if (!wf.exists()) {
   writeToFile(wf);
   wf.close();
 }
 doSomething(wf);
TODO will move in ver 6

  • Field Details

    • simulateUnwritableDir

      public static boolean simulateUnwritableDir
      debug only

  • Constructor Details

    • DiskCache

      public DiskCache()

  • Method Details

    • setRootDirectory

      public static void setRootDirectory(String cacheDir)
      Set the cache root directory. Create it if it doesnt exist.
      Parameters:
      cacheDir - the cache directory

    • makeRootDirectory

      public static void makeRootDirectory()
      Make sure that the current root directory exists.

    • getRootDirectory

      public static String getRootDirectory()
      Get the name of the root directory
      Returns:
      name of the root directory

    • setCachePolicy

      public static void setCachePolicy(boolean alwaysInCache)
      Set the standard policy used in getWriteableFileStandardPolicy(). Default is to try to create the file in the same directory as the original. Setting alwaysInCache to true means to always create it in the cache directory.
      Parameters:
      alwaysInCache - make this the default policy

    • getFileStandardPolicy

      public static File getFileStandardPolicy(String fileLocation)
      Get a File if it exists. If not, get a File that can be written to. Use the standard policy to decide where to place it.

      Things are a bit complicated, because in order to guarantee a file in an arbitrary location can be written to, we have to try to open it as a FileOutputStream. If we do, we don't want to open it twice, so we return a WriteableFile that contains an opened FileOutputStream. If it already exists, or we get it from cache, we don't need to open it.

      In any case, you must call WriteableFile.close() to make sure its closed.

      Parameters:
      fileLocation - normal file location
      Returns:
      WriteableFile holding the writeable File and a possibly opened FileOutputStream (append false)

    • getFile

      public static File getFile(String fileLocation, boolean alwaysInCache)
      Get a File if it exists. If not, get a File that can be written to. If alwaysInCache, look only in the cache, otherwise, look in the "normal" location first, then in the cache.

      Parameters:
      fileLocation - normal file location
      alwaysInCache - true if you want to look only in the cache
      Returns:
      a File that either exists or is writeable.

    • getCacheFile

      public static File getCacheFile(String fileLocation)
      Get a file in the cache. File may or may not exist. We assume its always writeable. If it does exist, set its LastModifiedDate to current time.
      Parameters:
      fileLocation - normal file location
      Returns:
      equivalent File in the cache.

    • showCache

      public static void showCache(PrintStream pw)

    • cleanCache

      public static void cleanCache(Date cutoff, StringBuilder sbuff)
      Remove all files with date < cutoff.
      Parameters:
      cutoff - earliest date to allow
      sbuff - write results here, null is ok.

    • cleanCache

      public static void cleanCache(long maxBytes, StringBuilder sbuff)
      Remove files if needed to make cache have less than maxBytes bytes file sizes. This will remove oldest files first.
      Parameters:
      maxBytes - max number of bytes in cache.
      sbuff - write results here, null is ok.

    • cleanCache

      public static void cleanCache(long maxBytes, Comparator<File> fileComparator, StringBuilder sbuff)
      Remove files if needed to make cache have less than maxBytes bytes file sizes. This will remove files in sort order defined by fileComparator. The first files in the sort order are kept, until the max bytes is exceeded, then they are deleted.
      Parameters:
      maxBytes - max number of bytes in cache.
      fileComparator - sort files first with this
      sbuff - write results here, null is ok.