FileCache.h

// -*- indent-tabs-mode: nil -*-

#ifndef FILECACHE_H_
#define FILECACHE_H_

#include <sstream>
#include <vector>
#include <map>
#include <set>
#include <arc/DateTime.h>
#include <arc/Logger.h>

#include "FileCacheHash.h"

namespace Arc {


  struct CacheParameters {
    std::string cache_path;
    std::string cache_link_path;
  };

#ifndef WIN32


  class FileCache {
   private:
    std::map <std::string, struct CacheParameters> _cache_map;
    std::vector<struct CacheParameters> _caches;
    std::vector<struct CacheParameters> _remote_caches;
    std::vector<struct CacheParameters> _draining_caches;
    std::set<std::string> _urls_unlocked;
    std::string _id;
    uid_t _uid;
    gid_t _gid;

    static const std::string CACHE_DATA_DIR;
    static const std::string CACHE_JOB_DIR;
    static const int CACHE_DIR_LENGTH;
    static const int CACHE_DIR_LEVELS;
    static const std::string CACHE_META_SUFFIX;
    static const int CACHE_DEFAULT_AUTH_VALIDITY;
    static const int CACHE_LOCK_TIMEOUT;
    static const int CACHE_META_LOCK_TIMEOUT;

    bool _init(const std::vector<std::string>& caches,
               const std::vector<std::string>& remote_caches,
               const std::vector<std::string>& draining_caches,
               const std::string& id,
               uid_t job_uid,
               gid_t job_gid);
    bool _checkMetaFile(const std::string& filename, const std::string& url, bool& is_locked);
    bool _createMetaFile(const std::string& meta_file, const std::string& content, bool& is_locked);
    std::string _getMetaFileName(const std::string& url);
    std::string _getHash(const std::string& url) const;
    struct CacheParameters _chooseCache(const std::string& url) const;
    float _getCacheInfo(const std::string& path) const;
    bool _cleanFilesAndReturnFalse(const std::string& hard_link_file, bool& locked);

    static Logger logger;

   public:

    FileCache(const std::string& cache_path,
              const std::string& id,
              uid_t job_uid,
              gid_t job_gid);


    FileCache(const std::vector<std::string>& caches,
              const std::string& id,
              uid_t job_uid,
              gid_t job_gid);


    FileCache(const std::vector<std::string>& caches,
              const std::vector<std::string>& remote_caches,
              const std::vector<std::string>& draining_caches,
              const std::string& id,
              uid_t job_uid,
              gid_t job_gid);

    FileCache(): _uid(0),_gid(0) {
      _caches.clear();
    }


    bool Start(const std::string& url,
               bool& available,
               bool& is_locked,
               bool use_remote = true,
               bool delete_first = false);


    bool Stop(const std::string& url);


    bool StopAndDelete(const std::string& url);


    std::string File(const std::string& url);


    bool Link(const std::string& link_path,
              const std::string& url,
              bool copy,
              bool executable,
              bool holding_lock,
              bool& try_again);


    bool Release() const;


    bool AddDN(const std::string& url, const std::string& DN, const Time& expiry_time);


    bool CheckDN(const std::string& url, const std::string& DN);


    bool CheckCreated(const std::string& url);


    Time GetCreated(const std::string& url);


    bool CheckValid(const std::string& url);


    Time GetValid(const std::string& url);


    bool SetValid(const std::string& url, const Time& val);

    operator bool() {
      return (!_caches.empty());
    };

    bool operator==(const FileCache& a);

  };

#else

  class FileCache {
  public:
    FileCache(const std::string& cache_path,
              const std::string& id,
              int job_uid,
              int job_gid) {}
    FileCache(const std::vector<std::string>& caches,
              const std::string& id,
              int job_uid,
              int job_gid) {}
    FileCache(const std::vector<std::string>& caches,
              const std::vector<std::string>& remote_caches,
              const std::vector<std::string>& draining_caches,
              const std::string& id,
              int job_uid,
              int job_gid,
              int cache_max=100,
              int cache_min=100) {}
    FileCache(const FileCache& cache) {}
    FileCache() {}
    bool Start(const std::string& url, bool& available, bool& is_locked, bool use_remote=true, bool delete_first=false) { return false; }
    bool Stop(const std::string& url) { return false; }
    bool StopAndDelete(const std::string& url) {return false; }
    std::string File(const std::string& url) { return url; }
    bool Link(const std::string& link_path, const std::string& url, bool copy, bool executable, bool holding_lock, bool& try_again)  { return false; }
    bool Release() const { return false;}
    bool AddDN(const std::string& url, const std::string& DN, const Time& expiry_time) { return false;}
    bool CheckDN(const std::string& url, const std::string& DN) { return false; }
    bool CheckCreated(const std::string& url){ return false; }
    Time GetCreated(const std::string& url) { return Time(); }
    bool CheckValid(const std::string& url) { return false; }
    Time GetValid(const std::string& url)  { return Time(); }
    bool SetValid(const std::string& url, const Time& val) { return false; }
    operator bool() {
      return false;
    };
    bool operator==(const FileCache& a)  { return false; }
  };
#endif /*WIN32*/


} // namespace Arc

#endif /*FILECACHE_H_*/