00001 #include "otsdaq-core/ConfigurationInterface/DatabaseConfigurationInterface.h"
00002 #include "otsdaq-core/ConfigurationDataFormats/ConfigurationBase.h"
00003 #include "otsdaq-core/MessageFacility/MessageFacility.h"
00004 #include "otsdaq-core/Macros/CoutHeaderMacros.h"
00005
00006
00007 #include <iostream>
00008 #include <string>
00009 #include <algorithm>
00010 #include <iterator>
00011
00012 #include "artdaq-database/ConfigurationDB/configurationdbifc.h"
00013 #include "artdaq-database/BasicTypes/basictypes.h"
00014
00015 #include "artdaq-database/StorageProviders/FileSystemDB/provider_filedb.h"
00016 #include "artdaq-database/StorageProviders/FileSystemDB/provider_filedb_index.h"
00017 #include "artdaq-database/ConfigurationDB/configuration_common.h"
00018 #include "artdaq-database/ConfigurationDB/dispatch_common.h"
00019 #include "JSONConfigurationHandler.h.unused"
00020
00021
00022
00023 using namespace ots;
00024
00025 using artdaq::database::basictypes::FhiclData;
00026 using artdaq::database::basictypes::JsonData;
00027
00028 using ots::DatabaseConfigurationInterface;
00029 using config_version_map_t = ots::DatabaseConfigurationInterface::config_version_map_t;
00030
00031 namespace db = artdaq::database::configuration;
00032 using VersionInfoList_t = db::ConfigurationInterface::VersionInfoList_t;
00033
00034 constexpr auto default_dbprovider = "filesystem";
00035 constexpr auto default_entity = "OTSROOT";
00036
00037
00038 DatabaseConfigurationInterface::DatabaseConfigurationInterface()
00039 {
00040 #ifdef DEBUG_ENABLE
00041
00042 if(0)
00043 {
00044 artdaq::database::configuration::debug::ExportImport();
00045 artdaq::database::configuration::debug::ManageAliases();
00046 artdaq::database::configuration::debug::ManageConfigs();
00047 artdaq::database::configuration::debug::ManageDocuments();
00048 artdaq::database::configuration::debug::Metadata();
00049
00050 artdaq::database::configuration::debug::detail::ExportImport();
00051 artdaq::database::configuration::debug::detail::ManageAliases();
00052 artdaq::database::configuration::debug::detail::ManageConfigs();
00053 artdaq::database::configuration::debug::detail::ManageDocuments();
00054 artdaq::database::configuration::debug::detail::Metadata();
00055
00056 artdaq::database::configuration::debug::options::OperationBase();
00057 artdaq::database::configuration::debug::options::BulkOperations();
00058 artdaq::database::configuration::debug::options::ManageDocuments();
00059 artdaq::database::configuration::debug::options::ManageConfigs();
00060 artdaq::database::configuration::debug::options::ManageAliases();
00061
00062 artdaq::database::configuration::debug::MongoDB();
00063 artdaq::database::configuration::debug::UconDB();
00064 artdaq::database::configuration::debug::FileSystemDB();
00065
00066 artdaq::database::filesystem::index::debug::enable();
00067
00068 artdaq::database::filesystem::debug::enable();
00069 artdaq::database::mongo::debug::enable();
00070
00071 artdaq::database::docrecord::debug::JSONDocumentBuilder();
00072 artdaq::database::docrecord::debug::JSONDocument();
00073
00074
00075
00076
00077 }
00078 #endif
00079
00080 }
00081
00082
00083
00084
00085 void DatabaseConfigurationInterface::fill(ConfigurationBase* configuration, ConfigurationVersion version) const
00086 throw(std::runtime_error)
00087 {
00088 auto ifc = db::ConfigurationInterface{default_dbprovider};
00089
00090 auto versionstring = version.toString();
00091
00092
00093
00094 auto result =
00095 ifc.template loadVersion<decltype(configuration), JsonData>(configuration, versionstring, default_entity);
00096
00097 if (result.first)
00098 {
00099
00100 configuration->getViewP()->setVersion(version);
00101 return;
00102 }
00103 __SS__ << "\n\nDBI Error while filling '" << configuration->getConfigurationName() <<
00104 "' version '" << versionstring << "' - are you sure this version exists?" <<
00105 "Here is the error:\n\n" << result.second << std::endl;
00106 std::cout << __COUT_HDR_FL__ << "\n" << ss.str();
00107 throw std::runtime_error(ss.str());
00108 }
00109
00110
00111
00112 void DatabaseConfigurationInterface::saveActiveVersion(const ConfigurationBase*
00113 configuration, bool overwrite) const
00114 throw(std::runtime_error)
00115 {
00116 auto ifc = db::ConfigurationInterface{default_dbprovider};
00117
00118
00119
00120 auto versionstring = configuration->getView().getVersion().toString();
00121
00122
00123
00124
00125 auto result = overwrite ?
00126 ifc.template overwriteVersion<decltype(configuration), JsonData>(configuration, versionstring, default_entity) :
00127 ifc.template storeVersion<decltype(configuration), JsonData>(configuration, versionstring, default_entity);
00128
00129 if (result.first)
00130 return;
00131
00132 __SS__ << "DBI Error:" << result.second << std::endl;
00133 std::cout << __COUT_HDR_FL__ << "\n" << ss.str();
00134 throw std::runtime_error(ss.str());
00135 }
00136
00137
00138
00139 ConfigurationVersion DatabaseConfigurationInterface::findLatestVersion(const ConfigurationBase* configuration) const
00140 noexcept
00141 {
00142 auto versions = getVersions(configuration);
00143
00144 std::cout << __COUT_HDR_FL__ << "Config Name: " << configuration->getConfigurationName() << std::endl;
00145 std::cout << __COUT_HDR_FL__ << "All Versions: " ;
00146 for(auto &v : versions)
00147 std::cout << v << " ";
00148 std::cout << std::endl;
00149
00150 if (!versions.size()) return ConfigurationVersion();
00151
00152 return *(versions.rbegin());
00153 }
00154
00155
00156
00157 std::set<ConfigurationVersion> DatabaseConfigurationInterface::getVersions(const ConfigurationBase* configuration) const
00158 noexcept
00159 try
00160 {
00161 auto ifc = db::ConfigurationInterface{default_dbprovider};
00162 auto result = ifc.template getVersions<decltype(configuration)>(configuration, default_entity);
00163
00164 auto resultSet = std::set<ConfigurationVersion>{};
00165 for(std::string const& version:result)
00166 resultSet.insert(ConfigurationVersion(std::stol(version, 0, 10)));
00167
00168
00169
00170
00171
00172
00173
00174
00175
00176
00177
00178
00179
00180
00181 return resultSet;
00182 }
00183 catch (std::exception const& e)
00184 {
00185 std::cout << __COUT_HDR_FL__ << "DBI Exception:" << e.what() << "\n";
00186 return {};
00187 }
00188
00189
00190
00191
00192 std::set<std::string > DatabaseConfigurationInterface::getAllConfigurationNames() const
00193 throw(std::runtime_error)
00194 try
00195 {
00196 auto ifc = db::ConfigurationInterface{default_dbprovider};
00197
00198 auto collection_name_prefix=std::string{};
00199
00200 return ifc.listCollections(collection_name_prefix);
00201 }
00202 catch (std::exception const& e)
00203 {
00204 __SS__ << "DBI Exception:" << e.what() << "\n";
00205 __COUT_ERR__ << ss.str();
00206 throw std::runtime_error(ss.str());
00207 }
00208 catch (...)
00209 {
00210 __SS__ << "DBI Unknown exception.\n";
00211 __COUT_ERR__ << ss.str();
00212 throw std::runtime_error(ss.str());
00213 }
00214
00215
00216
00217 std::set<std::string > DatabaseConfigurationInterface::getAllConfigurationGroupNames(const std::string &filterString) const
00218 throw(std::runtime_error) try
00219 {
00220 auto ifc = db::ConfigurationInterface{default_dbprovider};
00221
00222 if(filterString == "")
00223 return ifc.findGlobalConfigurations("*");
00224 else
00225 return ifc.findGlobalConfigurations(filterString + "*");
00226 }
00227 catch (std::exception const& e)
00228 {
00229 __SS__ << "DBI Exception:" << e.what() << "\n";
00230 __COUT_ERR__ << ss.str();
00231 throw std::runtime_error(ss.str());
00232 }
00233 catch (...)
00234 {
00235 __SS__ << "DBI Unknown exception.\n";
00236 __COUT_ERR__ << ss.str();
00237 throw std::runtime_error(ss.str());
00238 }
00239
00240
00241
00242
00243 std::set<ConfigurationGroupKey > DatabaseConfigurationInterface::getKeys(const std::string &groupName) const
00244 {
00245 std::set<ConfigurationGroupKey> retSet;
00246 std::set<std::string > names = getAllConfigurationGroupNames();
00247 for(auto &n : names)
00248 if(n.find(groupName) == 0)
00249 retSet.insert(ConfigurationGroupKey(n));
00250 return retSet;
00251 }
00252
00253
00254
00255 config_version_map_t DatabaseConfigurationInterface::getConfigurationGroupMembers(
00256 std::string const& configurationGroup, bool includeMetaDataTable) const
00257 throw(std::runtime_error)
00258 try
00259 {
00260
00261 auto ifc = db::ConfigurationInterface{default_dbprovider};
00262 auto result = ifc.loadGlobalConfiguration(configurationGroup);
00263
00264 auto to_map = [](auto const& inputList, bool includeMetaDataTable) {
00265 auto resultMap = config_version_map_t{};
00266
00267 std::for_each(inputList.begin(), inputList.end(),
00268 [&resultMap](auto const& info) { resultMap[info.configuration] = std::stol(info.version, 0, 10); });
00269
00270 if(!includeMetaDataTable)
00271 {
00272
00273 auto metaTable =
00274 resultMap.find(GROUP_METADATA_TABLE_NAME);
00275 if(metaTable != resultMap.end())
00276 resultMap.erase(metaTable);
00277 }
00278 return resultMap;
00279 };
00280
00281 return to_map(result,includeMetaDataTable);
00282 }
00283 catch (std::exception const& e)
00284 {
00285 __SS__ << "DBI Exception:" << e.what() << "\n";
00286 __COUT_ERR__ << ss.str();
00287 throw std::runtime_error(ss.str());
00288 }
00289 catch (...)
00290 {
00291 __SS__ << "DBI Unknown exception.\n";
00292 __COUT_ERR__ << ss.str();
00293 throw std::runtime_error(ss.str());
00294 }
00295
00296
00297
00298 void DatabaseConfigurationInterface::saveConfigurationGroup(config_version_map_t const& configurationMap,
00299 std::string const& configurationGroup) const
00300 throw(std::runtime_error)
00301 try
00302 {
00303 auto ifc = db::ConfigurationInterface{default_dbprovider};
00304
00305 auto to_list = [](auto const& inputMap) {
00306 auto resultList = VersionInfoList_t{};
00307 std::transform(inputMap.begin(), inputMap.end(), std::back_inserter(resultList), [](auto const& mapEntry) {
00308 return VersionInfoList_t::value_type{mapEntry.first, mapEntry.second.toString(), default_entity};
00309 });
00310
00311 return resultList;
00312 };
00313
00314 auto result = ifc.storeGlobalConfiguration(to_list(configurationMap), configurationGroup);
00315
00316 if (result.first) return;
00317
00318 throw std::runtime_error(result.second);
00319 }
00320 catch (std::exception const& e)
00321 {
00322 __SS__ << "DBI Exception:" << e.what() << "\n";
00323 __COUT_ERR__ << ss.str();
00324 throw std::runtime_error(ss.str());
00325 }
00326 catch (...)
00327 {
00328 __SS__ << "DBI Unknown exception.\n";
00329 __COUT_ERR__ << ss.str();
00330 throw std::runtime_error(ss.str());
00331 }
00332
00333