Configuration.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2019 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Martin Ritter                                            *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
#pragma once
 
#include <framework/utilities/EnvironmentVariables.h>
#include <framework/dataobjects/FileMetaData.h>
 
#include <boost/python/list.hpp>
#include <boost/python/tuple.hpp>
 
#include <variant>
#include <set>
 
namespace Belle2::Conditions {
  class CppOrPyList {
  public:
    boost::python::list& ensurePy();
    std::vector<std::string>& ensureCpp();
    void append(const std::string& element);
    void prepend(const std::string& element);
    void shallowCopy(const boost::python::object& source);
  private:
    std::variant<std::vector<std::string>, boost::python::list> m_value;
  };
 
  class Configuration {
  public:
    Configuration();
    static Configuration& getInstance();
    void reset();
 
 
    void appendGlobalTag(const std::string& globalTag) { ensureEditable(); m_globalTags.append(globalTag); }
    void prependGlobalTag(const std::string& globalTag) { ensureEditable(); m_globalTags.prepend(globalTag); }
    void setGlobalTags(const std::vector<std::string>& list) { ensureEditable(); m_globalTags.ensureCpp() = list; }
    void setGlobalTagsPy(const boost::python::list& globalTags) { ensureEditable(); m_globalTags.shallowCopy(globalTags); }
    std::vector<std::string> getGlobalTags() { return m_globalTags.ensureCpp(); }
    boost::python::list getGlobalTagsPy() { return m_globalTags.ensurePy(); }
 
    std::vector<std::string> getDefaultGlobalTags() const;
    boost::python::tuple getDefaultGlobalTagsPy() const;
 
    void setInputGlobaltags(const std::vector<std::string>& inputTags)
    {
      ensureEditable();
      m_inputGlobaltags = inputTags;
    }
 
    void setInputMetadata(const std::vector<FileMetaData>& inputMetadata);
 
    std::vector<std::string> getBaseTags() const;
 
    void overrideGlobalTags() { ensureEditable(); m_overrideEnabled = true; }
    void overrideGlobalTagsPy(const boost::python::list& globalTags);
    bool overrideEnabled() const { return m_overrideEnabled; }
 
    void disableGlobalTagReplay()
    {
      overrideGlobalTags();
      for (const auto& tag : getDefaultGlobalTags()) appendGlobalTag(tag);
    }
 
    std::vector<std::string> getFinalListOfTags();
 
 
 
    void appendTestingPayloadLocation(const std::string& filename) { ensureEditable(); m_testingPayloadLocations.append(filename); }
    void prependTestingPayloadLocation(const std::string& filename) { ensureEditable(); m_testingPayloadLocations.prepend(filename); }
    void setTestingPayloadLocations(const std::vector<std::string>& list) { ensureEditable(); m_testingPayloadLocations.ensureCpp() = list;}
    void setTestingPayloadLocationsPy(const boost::python::list& list) { ensureEditable(); m_testingPayloadLocations.shallowCopy(list); }
    std::vector<std::string> getTestingPayloadLocations() { return m_testingPayloadLocations.ensureCpp(); }
    boost::python::list getTestingPayloadLocationsPy() { return m_testingPayloadLocations.ensurePy(); }
 
 
 
    void appendMetadataProvider(const std::string& provider) { ensureEditable(); m_metadataProviders.append(provider); }
    void prependMetadataProvider(const std::string& provider) { ensureEditable(); m_metadataProviders.prepend(provider); }
    void setMetadataProviders(const std::vector<std::string>& list) { ensureEditable(); m_metadataProviders.ensureCpp() = list; }
    void setMetadataProvidersPy(const boost::python::list& list) { ensureEditable(); m_metadataProviders.shallowCopy(list); }
    std::vector<std::string> getMetadataProviders() { return m_metadataProviders.ensureCpp(); }
    boost::python::list getMetadataProvidersPy() { return m_metadataProviders.ensurePy(); }
 
 
    void appendPayloadLocation(const std::string& location) { ensureEditable(); m_payloadLocations.append(location); }
    void prependPayloadLocation(const std::string& location) { ensureEditable(); m_payloadLocations.prepend(location); }
    void setPayloadLocations(const std::vector<std::string>& list) { ensureEditable(); m_payloadLocations.ensureCpp() = list; }
    void setPayloadLocationsPy(const boost::python::list& list) { ensureEditable(); m_payloadLocations.shallowCopy(list); }
    std::vector<std::string> getPayloadLocations() { return m_payloadLocations.ensureCpp(); }
    boost::python::list getPayloadLocationsPy() { return m_payloadLocations.ensurePy(); }
 
 
 
    void setNewPayloadLocation(const std::string& filename) { ensureEditable(); m_newPayloadFile = filename; }
    std::string getNewPayloadLocation() const { return m_newPayloadFile; }
 
    void setDownloadCacheDirectory(const std::string& directory) { ensureEditable(); m_downloadCacheDirectory = directory; }
    std::string getDownloadCacheDirectory() const { return m_downloadCacheDirectory; }
 
    void setDownloadLockTimeout(size_t timeout) { ensureEditable(); m_downloadLockTimeout = timeout; }
    size_t getDownloadLockTimeout() const { return m_downloadLockTimeout; }
 
    void setUsableTagStates(const std::set<std::string>& states) { ensureEditable(); m_usableTagStates = states; }
    const std::set<std::string>& getUsableTagStates() const { return m_usableTagStates; }
 
    void setGlobaltagCallbackPy(const boost::python::object& obj) { ensureEditable(); m_callback = obj; }
 
 
    void setInitialized(bool value) { m_databaseInitialized = value; }
    static void exposePythonAPI();
  private:
    template<class T> static void fillFromEnv(T& target, const std::string& envName, const std::string& defaultValue)
    {
      const auto values = EnvironmentVariables::getOrCreateList(envName, defaultValue);
      for (const std::string& v : values) target.append(v);
    }
    void ensureEditable() const
    {
      if (m_databaseInitialized)
        throw std::runtime_error("Database already initialized, please reset before changing the configuration object");
    }
    bool m_overrideEnabled{false};
    std::optional<std::vector<std::string>> m_inputGlobaltags;
    std::vector<FileMetaData> m_inputMetadata;
    CppOrPyList m_globalTags;
    CppOrPyList m_testingPayloadLocations;
    CppOrPyList m_metadataProviders;
    CppOrPyList m_payloadLocations;
    std::string m_newPayloadFile{"localdb/database.txt"};
    std::string m_downloadCacheDirectory{""};
    size_t m_downloadLockTimeout{120};
    std::set<std::string> m_usableTagStates{"TESTING", "VALIDATED", "PUBLISHED", "RUNNING"};
    std::optional<boost::python::object> m_callback;
    bool m_databaseInitialized{false};
  };
} // Belle2::Conditions namespace