ESSources/interface/ProductResolver.h

0001 #ifndef CondCore_ESSources_ProductResolver_H
0002 #define CondCore_ESSources_ProductResolver_H
0003
0004 #include <cassert>
0005 //#include <iostream>
0006 #include <memory>
0007 #include <string>
0008 #include <mutex>
0009
0010 // user include files
0011 #include "FWCore/Framework/interface/ESSourceProductResolverTemplate.h"
0012 #include "FWCore/Framework/interface/DataKey.h"
0013 #include "FWCore/Framework/interface/EventSetupRecordKey.h"
0014
0015 #include "CondCore/CondDB/interface/IOVProxy.h"
0016 #include "CondCore/CondDB/interface/PayloadProxy.h"
0017 #include "CondCore/CondDB/interface/Time.h"
0018 #include "CondCore/CondDB/interface/Types.h"
0019
0020 // expose a cond::PayloadProxy as a eventsetup::ESProductResolver
0021 namespace cond {
0022   template <typename DataT>
0023   struct DefaultInitializer {
0024     void operator()(DataT&) {}
0025   };
0026
0027   template <class RecordT, class DataT, typename Initializer = cond::DefaultInitializer<DataT>>
0028   class ProductResolver : public edm::eventsetup::ESSourceProductResolverTemplate<DataT> {
0029   public:
0030     explicit ProductResolver(std::shared_ptr<cond::persistency::PayloadProxy<DataT>> pdata,
0031                              edm::SerialTaskQueue* iQueue,
0032                              std::mutex* iMutex)
0033         : edm::eventsetup::ESSourceProductResolverTemplate<DataT>(iQueue, iMutex), m_data{pdata} {}
0034     //ProductResolver(); // stop default
0035     const ProductResolver& operator=(const ProductResolver&) = delete;  // stop default
0036
0037     // ---------- const member functions ---------------------
0038
0039     // ---------- static member functions --------------------
0040
0041     // ---------- member functions ---------------------------
0042   protected:
0043     void prefetch(edm::eventsetup::DataKey const& iKey, edm::EventSetupRecordDetails) final {
0044       m_data->make();
0045       m_initializer(const_cast<DataT&>((*m_data)()));
0046     }
0047
0048     DataT const* fetch() const final { return &(*m_data)(); }
0049
0050   private:
0051     void initializeForNewIOV() override { m_data->initializeForNewIOV(); }
0052
0053     // ---------- member data --------------------------------
0054
0055     std::shared_ptr<cond::persistency::PayloadProxy<DataT>> m_data;
0056     Initializer m_initializer;
0057   };
0058
0059   /* ABI bridging between the cond world and eventsetup world
0060    * keep them separated!
0061    */
0062   class ProductResolverWrapperBase {
0063   public:
0064     typedef std::shared_ptr<cond::persistency::BasePayloadProxy> ProxyP;
0065     typedef std::shared_ptr<edm::eventsetup::ESProductResolver> esResolverP;
0066
0067     // limitation of plugin manager...
0068     typedef std::pair<std::string, std::string> Args;
0069
0070     virtual edm::eventsetup::TypeTag type() const = 0;
0071     virtual ProxyP proxy(unsigned int iovIndex) const = 0;
0072     virtual esResolverP esResolver(unsigned int iovIndex) const = 0;
0073     virtual edm::eventsetup::EventSetupRecordKey recordKey() const = 0;
0074
0075     ProductResolverWrapperBase();
0076     // late initialize (to allow to load ALL library first)
0077     virtual void lateInit(persistency::Session& session,
0078                           const std::string& tag,
0079                           const boost::posix_time::ptime& snapshotTime,
0080                           std::string const& il,
0081                           std::string const& cs,
0082                           edm::SerialTaskQueue* queue,
0083                           std::mutex* mutex) = 0;
0084
0085     virtual void initConcurrentIOVs(unsigned int nConcurrentIOVs) = 0;
0086
0087     void addInfo(std::string const& il, std::string const& cs, std::string const& tag);
0088
0089     virtual ~ProductResolverWrapperBase();
0090
0091     std::string const& label() const { return m_label; }
0092     std::string const& connString() const { return m_connString; }
0093     std::string const& tag() const { return m_tag; }
0094     persistency::IOVProxy& iovProxy() { return m_iovProxy; }
0095     persistency::IOVProxy const& iovProxy() const { return m_iovProxy; }
0096     Iov_t const& currentIov() const { return m_currentIov; }
0097     persistency::Session& session() { return m_session; }
0098     persistency::Session const& session() const { return m_session; }
0099     std::shared_ptr<std::vector<Iov_t>> const& requests() const { return m_requests; }
0100
0101     void setSession(persistency::Session const& v) { m_session = v; }
0102
0103     void loadTag(std::string const& tag);
0104     void loadTag(std::string const& tag, boost::posix_time::ptime const& snapshotTime);
0105     void reload();
0106
0107     ValidityInterval setIntervalFor(Time_t target);
0108     TimeType timeType() const { return m_iovProxy.tagInfo().timeType; }
0109
0110     void setPrintDebug(bool printDebug) { m_printDebug = printDebug; }
0111
0112   private:
0113     std::string m_label;
0114     std::string m_connString;
0115     std::string m_tag;
0116     persistency::IOVProxy m_iovProxy;
0117     Iov_t m_currentIov;
0118     persistency::Session m_session;
0119     std::shared_ptr<std::vector<Iov_t>> m_requests;
0120
0121     // whether additional debug info should be printed in loadTag and setIntervalFor
0122     bool m_printDebug = false;
0123   };
0124 }  // namespace cond
0125
0126 /* bridge between the cond world and eventsetup world
0127  * keep them separated!
0128  */
0129 template <class RecordT, class DataT, typename Initializer = cond::DefaultInitializer<DataT>>
0130 class ProductResolverWrapper : public cond::ProductResolverWrapperBase {
0131 public:
0132   typedef ::cond::ProductResolver<RecordT, DataT, Initializer> ProductResolver;
0133
0134   // constructor from plugin...
0135   explicit ProductResolverWrapper(const char* source = nullptr) : m_source(source ? source : "") {
0136     //NOTE: We do this so that the type 'DataT' will get registered
0137     // when the plugin is dynamically loaded
0138     m_type = edm::eventsetup::DataKey::makeTypeTag<DataT>();
0139   }
0140
0141   // late initialize (to allow to load ALL library first)
0142   void lateInit(cond::persistency::Session& iSession,
0143                 const std::string& tag,
0144                 const boost::posix_time::ptime& snapshotTime,
0145                 std::string const& il,
0146                 std::string const& cs,
0147                 edm::SerialTaskQueue* queue,
0148                 std::mutex* mutex) override {
0149     setSession(iSession);
0150     // set the IOVProxy
0151     loadTag(tag, snapshotTime);
0152     // Only make the first PayloadProxy object now because we don't know yet
0153     // how many we will need.
0154     m_proxies.push_back(std::make_shared<cond::persistency::PayloadProxy<DataT>>(
0155         &currentIov(), &session(), &requests(), m_source.empty() ? (const char*)nullptr : m_source.c_str()));
0156     m_esResolvers.push_back(std::make_shared<ProductResolver>(m_proxies[0], queue, mutex));
0157     addInfo(il, cs, tag);
0158   }
0159
0160   void initConcurrentIOVs(unsigned int nConcurrentIOVs) override {
0161     // Create additional PayloadProxy objects if we are allowing
0162     // multiple IOVs to run concurrently.
0163     if (m_proxies.size() != nConcurrentIOVs) {
0164       assert(m_proxies.size() == 1);
0165       auto queue = m_esResolvers.front()->queue();
0166       auto mutex = m_esResolvers.front()->mutex();
0167       for (unsigned int i = 1; i < nConcurrentIOVs; ++i) {
0168         m_proxies.push_back(std::make_shared<cond::persistency::PayloadProxy<DataT>>(
0169             &currentIov(), &session(), &requests(), m_source.empty() ? (const char*)nullptr : m_source.c_str()));
0170         m_esResolvers.push_back(std::make_shared<ProductResolver>(m_proxies[i], queue, mutex));
0171         // This does nothing except in the special case of a KeyList PayloadProxy.
0172         // They all need to have copies of the same IOVProxy object.
0173         m_proxies[i]->initKeyList(*m_proxies[0]);
0174       }
0175       assert(m_proxies.size() == nConcurrentIOVs);
0176     }
0177     assert(m_proxies.size() == m_esResolvers.size());
0178   }
0179
0180   edm::eventsetup::TypeTag type() const override { return m_type; }
0181   ProxyP proxy(unsigned int iovIndex) const override { return m_proxies.at(iovIndex); }
0182   esResolverP esResolver(unsigned int iovIndex) const override { return m_esResolvers.at(iovIndex); }
0183
0184   // ProductResolverWrapper returning the Key for the RecordT
0185   // guarantees the proper linking order between the Records and
0186   // CondDBESSource
0187   edm::eventsetup::EventSetupRecordKey recordKey() const final {
0188     return edm::eventsetup::EventSetupRecordKey::makeKey<RecordT>();
0189   }
0190
0191 private:
0192   std::string m_source;
0193   edm::eventsetup::TypeTag m_type;
0194   std::vector<std::shared_ptr<cond::persistency::PayloadProxy<DataT>>> m_proxies;
0195   std::vector<std::shared_ptr<ProductResolver>> m_esResolvers;
0196 };
0197
0198 #endif /* CondCore_ESSources_ProductResolver_H */