BESH4MCache.cc

// This file includes cache handling routines for the HDF4 handler.
// The skeleton of the code is adapted from BESDapResponseCache.cc under bes/dap 
//  Authors:   Kent Yang <myang6@hdfgroup.org>  
// Copyright (c) The HDF Group
 
#include "config.h"
 
#include <sys/stat.h>
#include <iostream>
#include  <sstream>
 
#include "BESH4MCache.h"
#include "BESUtil.h"
 
#include "BESInternalError.h"
#include "TheBESKeys.h"
#include "BESDebug.h"
#include "HDF4RequestHandler.h"
 
using namespace std;
 
BESH4Cache *BESH4Cache::d_instance = nullptr;
bool BESH4Cache::d_enabled = true;
 
const string BESH4Cache::PATH_KEY = "HDF4.Cache.latlon.path";
const string BESH4Cache::PREFIX_KEY = "HDF4.Cache.latlon.prefix";
const string BESH4Cache::SIZE_KEY = "HDF4.Cache.latlon.size";
 
long BESH4Cache::getCacheSizeFromConfig()
{
    if (HDF4RequestHandler::get_cache_latlon_size_exist() == true) {
        BESDEBUG("cache",
            "In BESH4Cache::getCacheSize(): Located BES key " << SIZE_KEY<< "=" << HDF4RequestHandler::get_cache_latlon_size() << endl);
        return HDF4RequestHandler::get_cache_latlon_size();
    }
    else {
        string msg = "[ERROR] BESH4Cache::getCacheSize() - The BES Key " + SIZE_KEY
            + " is not set! It MUST be set to utilize the HDF4 cache. ";
        BESDEBUG("cache", msg);
        throw BESInternalError(msg, __FILE__, __LINE__);
    }
}
 
string BESH4Cache::getCachePrefixFromConfig()
{
    if (HDF4RequestHandler::get_cache_latlon_prefix_exist() == true) {
        BESDEBUG("cache",
            "In BESH4Cache::getCachePrefix(): Located BES key " << PREFIX_KEY<< "=" << HDF4RequestHandler::get_cache_latlon_prefix() << endl);
        return HDF4RequestHandler::get_cache_latlon_prefix();
    }
    else {
        string msg = "[ERROR] BESH4Cache::getCachePrefix() - The BES Key " + PREFIX_KEY
            + " is not set! It MUST be set to utilize the HDF4 cache. ";
        BESDEBUG("cache", msg);
        throw BESInternalError(msg, __FILE__, __LINE__);
    }
}
 
string BESH4Cache::getCacheDirFromConfig()
{
    if (HDF4RequestHandler::get_cache_latlon_path_exist() == true) {
        BESDEBUG("cache",
            "In BESH4Cache::getCacheDirFromConfig(): Located BES key " << PATH_KEY<< "=" << HDF4RequestHandler::get_cache_latlon_path() << endl);
        return HDF4RequestHandler::get_cache_latlon_path();
    }
    else {
        string msg = "[ERROR] BESH4Cache::getCachePrefix() - The BES Key " + PREFIX_KEY
            + " is not set! It MUST be set to utilize the HDF4 cache. ";
        BESDEBUG("cache", msg);
        throw BESInternalError(msg, __FILE__, __LINE__);
    }
}
 
BESH4Cache::BESH4Cache()
{
    BESDEBUG("cache", "In BESH4Cache::BESH4Cache()" << endl);
 
    string cacheDir = getCacheDirFromConfig();
    string prefix = getCachePrefixFromConfig();
    long size_in_megabytes = getCacheSizeFromConfig();
 
    BESDEBUG("cache",
        "BESH4Cache() - Cache config params: " << cacheDir << ", " << prefix << ", " << size_in_megabytes << endl);
 
    // The required params must be present. If initialize() is not called,
    // then d_cache will stay null and is_available() will return false.
    // Also, the directory 'path' must exist, or d_cache will be null.
    if (!cacheDir.empty() && size_in_megabytes > 0) {
        BESDEBUG("cache", "Before calling initialize function." << endl);
        initialize(cacheDir, prefix, size_in_megabytes);
    }
 
    BESDEBUG("cache", "Leaving BESH4Cache::BESH4Cache()" << endl);
}

BESH4Cache *
BESH4Cache::get_instance()
{
    if (d_enabled && d_instance == nullptr) {
        struct stat buf;
        string cache_dir = getCacheDirFromConfig();
        if ((stat(cache_dir.c_str(), &buf) == 0) && (buf.st_mode & S_IFDIR)) {
            try {
                d_instance = new BESH4Cache();
 
                d_enabled = d_instance->cache_enabled();
                if(!d_enabled){
                    delete d_instance;
                    d_instance = nullptr;
                    BESDEBUG("cache", "BESH4Cache::"<<__func__ << "() - " <<
                        "Cache is DISABLED"<< endl);
                }
                else {
#ifdef HAVE_ATEXIT
                    atexit(delete_instance);
#endif
                    BESDEBUG("cache", "BESH4Cache::" << __func__ << "() - " <<
                        "Cache is ENABLED"<< endl);
                }
            }
            catch (BESInternalError &bie) {
                BESDEBUG("cache",
                    "BESH4Cache::get_instance(): Failed to obtain cache! msg: " << bie.get_message() << endl);
            }
        }
    }
 
    return d_instance;
}
 
// Check whether the real lat/lon file size is the same as the expected lat/lon size. If not, return false. 
bool BESH4Cache::is_valid(const string & cache_file_name, const int expected_file_size) const
{
 
    struct stat st;
    int result = stat(cache_file_name.c_str(), &st);
    if (result != 0) {
        string msg = "Cannot check the cached file " + cache_file_name;
        throw BESInternalError(msg, __FILE__, __LINE__);
    }
    if (expected_file_size == st.st_size)
        return true;
    else
        return false;
}
 
// This call will try to obtain the read lock.
bool BESH4Cache::get_data_from_cache(const string & cache_file_name, const int expected_file_size, int &fd)
{
#if 0
    cerr<<"coming to get_data_from_cache "<<endl;
    BESDEBUG("cache", "In BESH4Cache::get_data_from_cache()" << endl);
    cerr<<"cache_file_name is "<<cache_file_name <<endl;
    int fd1;
    string cache_file_name1 = cache_file_name;
    get_read_lock(cache_file_name1,fd1);
 
    cerr<<"After get_read_lock "<<endl;
#endif
    if (false == get_read_lock(cache_file_name, fd))
        return false;
    else if (false == is_valid(cache_file_name, expected_file_size)) {
        unlock_and_close(cache_file_name);
        purge_file(cache_file_name);
        return false;
    }
    else
        return true;
}
 
bool BESH4Cache::write_cached_data(const string & cache_file_name, const int expected_file_size,
    const vector<double> &val)
{
 
    BESDEBUG("cache", "In BESH4Cache::write_cached_data()" << endl);
    int fd = 0;
    bool ret_value = false;
 
    // 1. create_and_lock. 
    if (create_and_lock(cache_file_name, fd)) {
 
        ssize_t ret_val = 0;
 
        // 2. write the file.
        ret_val = write(fd, val.data(), expected_file_size);
 
        // 3. If the written size is not the same as the expected file size, purge the file.
        if (ret_val != expected_file_size) {
            if (unlink(cache_file_name.c_str()) != 0) {
                string msg = "Cannot remove the corrupt cached file " + cache_file_name;
                throw BESInternalError(msg, __FILE__, __LINE__);
            }
 
        }
        else {
            unsigned long long size = update_cache_info(cache_file_name);
            if (cache_too_big(size)) update_and_purge(cache_file_name);
            ret_value = true;
        }
        // 4. release the lock.
        unlock_and_close(cache_file_name);
 
    }
 
    return ret_value;
 
}
 
bool BESH4Cache::write_cached_data2(const string & cache_file_name, const int expected_file_size, const void *buf)
{
 
    BESDEBUG("cache", "In BESH4Cache::write_cached_data()" << endl);
    int fd = 0;
    bool ret_value = false;
 
    // 1. create_and_lock. 
    if (create_and_lock(cache_file_name, fd)) {
 
        ssize_t ret_val = 0;
 
        // 2. write the file.
        ret_val = write(fd, buf, expected_file_size);
 
        // 3. If the written size is not the same as the expected file size, purge the file.
        if (ret_val != expected_file_size) {
            if (unlink(cache_file_name.c_str()) != 0) {
                string msg = "Cannot remove the corrupt cached file " + cache_file_name;
                throw BESInternalError(msg, __FILE__, __LINE__);
            }
 
        }
        else {
            unsigned long long size = update_cache_info(cache_file_name);
            if (cache_too_big(size)) update_and_purge(cache_file_name);
            ret_value = true;
        }
        // 4. release the lock.
        unlock_and_close(cache_file_name);
 
    }
 
    return ret_value;
 
}
#if 0
void BESH4Cache::dummy_test_func() {
 
    cerr<<"BESH4Cache function is fine "<<endl;
 
}
 
string BESH4Cache::get_cache_file_name_h4(const string & src, bool mangle) {
 
    return src;
}
#endif