{

struct CachedObject {

std::shared_ptr<void> objPtr;

void* noCleanupPtr = nullptr; // if assigned instead of objPtr, no cleanup will be done on exit (for global objects cleaned up by the root, e.g. gGeoManager)

std::string uuid;

long startvalidity = 0;

long endvalidity = -1;

long cacheValidFrom = 0; // time for which the object was cached

long cacheValidUntil = -1; // object is guaranteed to be valid till this time (modulo new updates)

size_t minSize = -1ULL;

size_t maxSize = 0;

int queries = 0;

int fetches = 0;

int failures = 0;

std::map<std::string, std::string> cacheOfHeaders;

bool isValid(long ts) { return ts < endvalidity && ts >= startvalidity; }

bool isCacheValid(long ts)

{

LOGP(debug, "isCacheValid : {} : {} : {} --> {}", cacheValidFrom, ts, cacheValidUntil, isValid(ts));

return ts < cacheValidUntil && isValid(ts);

}

void clear()

{

noCleanupPtr = nullptr;

objPtr.reset();

uuid = "";

startvalidity = 0;

endvalidity = -1;

cacheOfHeaders.clear();

}

};

public:

using MD = std::map<std::string, std::string>;

CCDBManagerInstance(std::string const& path) : mCCDBAccessor{}

{

mCCDBAccessor.init(path);

mDeplMode = o2::framework::DefaultsHelpers::deploymentMode();

}

/// set a URL to query from

void setURL(const std::string& url);

/// set timestamp cache for all queries

void setTimestamp(long t)

{

if (t >= 0) {

mTimestamp = t;

}

}

/// query current URL

std::string const& getURL() const { return mCCDBAccessor.getURL(); }

/// query timestamp

long getTimestamp() const { return mTimestamp; }

/// retrieve an object of type T from CCDB as stored under path and timestamp. Optional to get the headers.

template <typename T>

T* getForTimeStamp(std::string const& path, long timestamp, std::map<std::string, std::string>* headers = nullptr);

/// retrieve an object of type T from CCDB as stored under path and using the timestamp in the middle of the run

template <typename T>

T* getForRun(std::string const& path, int runNumber, bool setRunMetadata = false);

/// retrieve an object of type T from CCDB as stored under path, timestamp and metaData

template <typename T>

T* getSpecific(std::string const& path, long timestamp = -1, MD metaData = MD(), std::map<std::string, std::string>* headers = nullptr)

{

// TODO: add some error info/handling when failing

mMetaData = metaData;

auto obj = getForTimeStamp<T>(path, timestamp, headers);

return obj;

}

/// retrieve an object of type T from CCDB as stored under path and using the timestamp in the middle of the run + metadata. The run number is provided separately to conform to typical analysis use (in which case metadata does not include runNumber)

template <typename T>

T* getSpecificForRun(std::string const& path, int runNumber, MD const& metaData = MD());

/// detect online processing modes (i.e. CCDB objects may be updated in the lifetime of the manager)

bool isOnline() const { return mDeplMode == o2::framework::DeploymentMode::OnlineAUX || mDeplMode == o2::framework::DeploymentMode::OnlineDDS || mDeplMode == o2::framework::DeploymentMode::OnlineECS; }

/// retrieve an object of type T from CCDB as stored under path; will use the timestamp member

template <typename T>

T* get(std::string const& path)

{

return getForTimeStamp<T>(path, mTimestamp);

}

// gain access to underlaying CCDB layer (to allow for more complex queries without need to reinit another API)

CcdbApi& getCCDBAccessor() { return mCCDBAccessor; }

bool isHostReachable() const { return mCCDBAccessor.isHostReachable(); }

/// clear all entries in the cache

void clearCache() { mCache.clear(); }

/// clear particular entry in the cache

void clearCache(std::string const& path) { mCache.erase(path); }

/// check if caching is enabled

bool isCachingEnabled() const { return mCachingEnabled; }

/// disable or enable caching

void setCaching(bool v)

{

mCachingEnabled = v;

if (!v) {

clearCache();

}

}

/// Check if an object in cache is valid

bool isCachedObjectValid(std::string const& path, long timestamp)

{

if (!isCachingEnabled()) {

return false;

}

return (mCheckObjValidityEnabled && mCache[path].isValid(timestamp)) || mCache[path].isCacheValid(timestamp); // use stricter check

}

/// check if checks of object validity before CCDB query is enabled

bool isLocalObjectValidityCheckingEnabled() const { return mCheckObjValidityEnabled; }

/// set the flag to check object validity before CCDB query

void setLocalObjectValidityChecking(bool v = true) { mCheckObjValidityEnabled = v; }

/// set the object upper validity limit

void setCreatedNotAfter(long v) { mCreatedNotAfter = v; }

/// get the object upper validity limit

long getCreatedNotAfter() const { return mCreatedNotAfter; }

/// reset the object upper validity limit

void resetCreatedNotAfter() { mCreatedNotAfter = 0; }

/// set the object upper validity limit

void setCreatedNotBefore(long v) { mCreatedNotBefore = v; }

/// get the object upper validity limit

long getCreatedNotBefore() const { return mCreatedNotBefore; }

/// reset the object upper validity limit

void resetCreatedNotBefore() { mCreatedNotBefore = 0; }

/// get the fatalWhenNull state

bool getFatalWhenNull() const { return mFatalWhenNull; }

/// set the fatal property (when false; nullptr object responses will not abort)

void setFatalWhenNull(bool b) { mFatalWhenNull = b; }

/// A convenience function for MC to fetch

/// valid start and end timestamps for recorded TF data given an ALICE run number.

/// In absence of STF/ETF fields in the RCT with fall back to CTP SOX/EOX then to

/// ECS SOR/EOR.

/// On error it fatals (if fatal == true) or else returns the pair -1, -1.

std::pair<int64_t, int64_t> getRunDuration(int runnumber, bool fatal = true);

static std::pair<int64_t, int64_t> getRunDuration(o2::ccdb::CcdbApi const& api, int runnumber, bool fatal = true);

static std::pair<int64_t, int64_t> getRunDuration(const MD& headers);

std::string getSummaryString() const;

size_t getFetchedSize() const { return mFetchedSize; }

void report(bool longrep = false);

void endOfStream();

private:

// method to print (fatal) error

void reportFatal(std::string_view s);

// we access the CCDB via the CURL based C++ API

o2::ccdb::CcdbApi mCCDBAccessor;

std::unordered_map<std::string, CachedObject> mCache; //! map for {path, CachedObject} associations

MD mMetaData; // some dummy object needed to talk to CCDB API

MD mHeaders; // headers to retrieve tags

long mTimestamp{o2::ccdb::getCurrentTimestamp()}; // timestamp to be used for query (by default "now")

bool mCanDefault = false; // whether default is ok --> useful for testing purposes done standalone/isolation

bool mCachingEnabled = true; // whether caching is enabled

bool mCheckObjValidityEnabled = false; // wether the validity of cached object is checked before proceeding to a CCDB API query

bool mFatalWhenNull = true; // if nullptr blob replies should be treated as fatal (can be set by user)

long mCreatedNotAfter = 0; // upper limit for object creation timestamp (TimeMachine mode) - If-Not-After HTTP header

long mCreatedNotBefore = 0; // lower limit for object creation timestamp (TimeMachine mode) - If-Not-Before HTTP header

long mTimerMS = 0; // timer for queries

size_t mFetchedSize = 0; // total fetched size

int mQueries = 0; // total number of object queries

int mFetches = 0; // total number of succesful fetches from CCDB

int mFailures = 0; // total number of failed fetches

o2::framework::DeploymentMode mDeplMode; // O2 deployment mode

ClassDefNV(CCDBManagerInstance, 1);

{

public:

static BasicCCDBManager& instance()

{

const std::string ccdbUrl{o2::base::NameConf::getCCDBServer()};

static BasicCCDBManager inst{ccdbUrl};

return inst;

}

private:

using CCDBManagerInstance::CCDBManagerInstance;

BasicCCDBManager(std::string const& url) : CCDBManagerInstance(url)

{

const char* t = getenv("ALICEO2_CCDB_CONDITION_NOT_AFTER");

if (t) {

auto timeaslong = strtol(t, nullptr, 10);

if (timeaslong != 0L) {

LOG(info) << "CCDB Time-machine constrained detected. Setting condition-not-after constrained to timestamp " << timeaslong;

setCreatedNotAfter(timeaslong);

}

}

}