DAPCache3.h

Go to the documentation of this file.

// DAPCache3.h
 
// This file was originally part of bes, A C++ back-end server
// implementation framework for the OPeNDAP Data Access Protocol.
// Copied to libdap. This is used to cache responses built from
// functional CE expressions.
 
// Copyright (c) 2012 OPeNDAP, Inc
// Author: James Gallagher <jgallagher@opendap.org>,
// Patrick West <pwest@ucar.edu> and Jose Garcia <jgarcia@ucar.edu>
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
//
// You can contact University Corporation for Atmospheric Research at
// 3080 Center Green Drive, Boulder, CO 80301
 
#ifndef DAPCache3_h_
#define DAPCache3_h_ 1
 
// #include <algorithm>
#include <list>
#include <map>
#include <string>
// #include <sstream>
 
#include "DapObj.h"
 
#if 0
#include "BESDebug.h"
#include "BESObj.h"
 
class BESKeys;
#endif
 
namespace libdap {
 
// These typedefs are used to record information about the files in the cache.
// See DAPCache3.cc and look at the purge() method.
typedef struct {
    string name;
    unsigned long long size;
    time_t time;
} cache_entry;
 
typedef std::list<cache_entry> CacheFiles;

class DAPCache3 : public libdap::DapObj {
 
private:
    static DAPCache3 *d_instance;
 
    static const char DAP_CACHE_CHAR = '#';
 
    string d_cache_dir; 
    string d_prefix;    

    unsigned long long d_max_cache_size_in_bytes;
    // When we purge, how much should we throw away. Set in the ctor to 80% of the max size.
    unsigned long long d_target_size;
#if 0
    // This class implements a singleton, so the constructor is hidden.
    BESCache3(BESKeys *keys, const string &cache_dir_key, const string &prefix_key, const string &size_key);
#endif
    // Testing
    DAPCache3(const string &cache_dir, const string &prefix, unsigned long long size);
 
    // Suppress the assignment operator and default copy ctor, ...
    DAPCache3();
    DAPCache3(const DAPCache3 &);
    DAPCache3 &operator=(const DAPCache3 &rhs);
 
    void m_check_ctor_params();
    void m_initialize_cache_info();
 
    unsigned long long m_collect_cache_dir_info(CacheFiles &contents);

    string d_cache_info;
    int d_cache_info_fd;
 
    void m_record_descriptor(const string &file, int fd);
    int m_get_descriptor(const string &file);
 
    // map that relates files to the descriptor used to obtain a lock
    typedef std::map<string, int> FilesAndLockDescriptors;
    FilesAndLockDescriptors d_locks;
 
    // Life-cycle control
    virtual ~DAPCache3() {}
    static void delete_instance();
 
public:
    static DAPCache3 *get_instance(const string &cache_dir, const string &prefix, unsigned long long size);
    static DAPCache3 *get_instance();
 
    string get_cache_file_name(const string &src, bool mangle = true);
 
    virtual bool create_and_lock(const string &target, int &fd);
    virtual bool get_read_lock(const string &target, int &fd);
    virtual void exclusive_to_shared_lock(int fd);
    virtual void unlock_and_close(const string &target);
    virtual void unlock_and_close(int fd);
 
    virtual void lock_cache_write();
    virtual void lock_cache_read();
    virtual void unlock_cache();
 
    virtual unsigned long long update_cache_info(const string &target);
    virtual bool cache_too_big(unsigned long long current_size) const;
    virtual unsigned long long get_cache_size();
    virtual void update_and_purge(const string &new_file);
    virtual void purge_file(const string &file);
 
#if 0
    static BESCache3 *get_instance(BESKeys *keys, const string &cache_dir_key, const string &prefix_key, const string &size_key);
#endif
 
    virtual void dump(ostream &strm) const;
};
 
} // namespace libdap
 
#endif // DAPCache3_h_