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__ << 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__ << 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 std::cout << __COUT_HDR_FL__ << "DBI Exception:" << e.what() << "\n";
00205 throw std::runtime_error(e.what());
00206 }
00207 catch (...)
00208 {
00209 std::cout << __COUT_HDR_FL__ << "DBI Unknown exception.\n";
00210 throw std::runtime_error("DBI Unknown exception.");
00211 }
00212
00213
00214
00215 std::set<std::string > DatabaseConfigurationInterface::getAllConfigurationGroupNames(const std::string &filterString) const
00216 throw(std::runtime_error) try
00217 {
00218 auto ifc = db::ConfigurationInterface{default_dbprovider};
00219
00220 if(filterString == "")
00221 return ifc.findGlobalConfigurations("*");
00222 else
00223 return ifc.findGlobalConfigurations(filterString + "*");
00224 }
00225 catch (std::exception const& e)
00226 {
00227 std::cout << __COUT_HDR_FL__ << "DBI Exception:" << e.what() << "\n";
00228 throw std::runtime_error(e.what());
00229 }
00230 catch (...)
00231 {
00232 std::cout << __COUT_HDR_FL__ << "DBI Unknown exception.\n";
00233 throw std::runtime_error("DBI Unknown exception.");
00234 }
00235
00236
00237
00238
00239 std::set<ConfigurationGroupKey > DatabaseConfigurationInterface::getKeys(const std::string &groupName) const
00240 {
00241 std::set<ConfigurationGroupKey> retSet;
00242 std::set<std::string > names = getAllConfigurationGroupNames();
00243 for(auto &n : names)
00244 if(n.find(groupName) == 0)
00245 retSet.insert(ConfigurationGroupKey(n));
00246 return retSet;
00247 }
00248
00249
00250
00251 config_version_map_t DatabaseConfigurationInterface::getConfigurationGroupMembers(
00252 std::string const& configurationGroup, bool includeMetaDataTable) const
00253 throw(std::runtime_error)
00254 try
00255 {
00256
00257 auto ifc = db::ConfigurationInterface{default_dbprovider};
00258 auto result = ifc.loadGlobalConfiguration(configurationGroup);
00259
00260 auto to_map = [](auto const& inputList, bool includeMetaDataTable) {
00261 auto resultMap = config_version_map_t{};
00262
00263 std::for_each(inputList.begin(), inputList.end(),
00264 [&resultMap](auto const& info) { resultMap[info.configuration] = std::stol(info.version, 0, 10); });
00265
00266 if(!includeMetaDataTable)
00267 {
00268
00269 auto metaTable =
00270 resultMap.find(GROUP_METADATA_TABLE_NAME);
00271 if(metaTable != resultMap.end())
00272 resultMap.erase(metaTable);
00273 }
00274 return resultMap;
00275 };
00276
00277 return to_map(result,includeMetaDataTable);
00278 }
00279 catch (std::exception const& e)
00280 {
00281 std::cout << __COUT_HDR_FL__ << "DBI Exception:" << e.what() << "\n";
00282 throw std::runtime_error(e.what());
00283 }
00284 catch (...)
00285 {
00286 std::cout << __COUT_HDR_FL__ << "DBI Unknown exception.\n";
00287 throw std::runtime_error("DBI Unknown exception.");
00288 }
00289
00290
00291
00292 void DatabaseConfigurationInterface::saveConfigurationGroup(config_version_map_t const& configurationMap,
00293 std::string const& configurationGroup) const
00294 throw(std::runtime_error)
00295 try
00296 {
00297 auto ifc = db::ConfigurationInterface{default_dbprovider};
00298
00299 auto to_list = [](auto const& inputMap) {
00300 auto resultList = VersionInfoList_t{};
00301 std::transform(inputMap.begin(), inputMap.end(), std::back_inserter(resultList), [](auto const& mapEntry) {
00302 return VersionInfoList_t::value_type{mapEntry.first, mapEntry.second.toString(), default_entity};
00303 });
00304
00305 return resultList;
00306 };
00307
00308 auto result = ifc.storeGlobalConfiguration(to_list(configurationMap), configurationGroup);
00309
00310 if (result.first) return;
00311
00312 throw std::runtime_error(result.second);
00313 }
00314 catch (std::exception const& e)
00315 {
00316 std::cout << __COUT_HDR_FL__ << "DBI Exception:" << e.what() << "\n";
00317 throw std::runtime_error(e.what());
00318 }
00319 catch (...)
00320 {
00321 std::cout << __COUT_HDR_FL__ << "DBI Unknown exception.\n";
00322 throw std::runtime_error("DBI Unknown exception.");
00323 }
00324
00325