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