Configuration.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
#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>
#include <optional>
 
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(); }

    static std::vector<std::string> getDefaultGlobalTags();
    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(); }
    // exposed to Python as a property: boost::python cannot wrap a function
    // returning a reference without an explicit return_value_policy
    // cppcheck-suppress returnByReference
    std::string getDefaultRemoteMetadataProviderServer() { return m_defaultLegacyRemoteMetadataProviderServer; }
    // exposed to Python as a property: boost::python cannot wrap a function
    // returning a reference without an explicit return_value_policy
    // cppcheck-suppress returnByReference
    std::string getDefaultHSFRemoteMetadataProviderServer() { return m_defaultHSFRemoteMetadataProviderServer; }
    const std::string& getDefaultLocalMetadataProviderPath() { return m_defaultLocalMetadataProviderPath; }



    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; }
    const std::string& getNewPayloadLocation() const { return m_newPayloadFile; }

    void setDownloadCacheDirectory(const std::string& directory) { ensureEditable(); m_downloadCacheDirectory = directory; }
    const 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_defaultLegacyRemoteMetadataProviderServer{"http://belle2db.sdcc.bnl.gov/b2s/rest/"};
    std::string m_defaultHSFRemoteMetadataProviderServer{"http://blcdb.sdcc.bnl.gov/api/cdb_rest/"};
    std::string m_defaultLocalMetadataProviderPath{"/cvmfs/belle.cern.ch/conditions"};
    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",
      "locked", "frozen"};

    std::optional<boost::python::object> m_callback;
    bool m_databaseInitialized{false};
  };
} // Belle2::Conditions namespace