PoolDBOutputService.h

Go to the documentation of this file.

#ifndef CondCore_PoolDBOutputService_h
#define CondCore_PoolDBOutputService_h
#include "FWCore/ServiceRegistry/interface/ActivityRegistry.h"
#include "FWCore/Utilities/interface/TypeID.h"
#include "CondCore/CondDB/interface/Session.h"
#include <string>
#include <map>
#include <mutex>

//
// Package:     DBOutputService
// Class  :     PoolDBOutputService
//
//
// Author:      Zhen Xie
// Fixes and other changes: Giacomo Govi
//

namespace edm {
  class Event;
  class EventSetup;
  class ParameterSet;
}  // namespace edm
namespace cond {

  inline std::string classNameForTypeId(const std::type_info& typeInfo) {
    edm::TypeID type(typeInfo);
    return type.className();
  }

  namespace service {

    class PoolDBOutputService {
    public:
      PoolDBOutputService(const edm::ParameterSet& iConfig, edm::ActivityRegistry& iAR);
      //use these to control connections
      //void  postBeginJob();
      void postEndJob();

      //
      // return the database session in use ( GG: not sure this is still useful... )
      //
      cond::persistency::Session session() const;
      //
      std::string tag(const std::string& recordName);
      bool isNewTagRequest(const std::string& recordName);

      //
      template <typename T>
      void writeOne(T* payload, Time_t time, const std::string& recordName, bool withlogging = false) {
        if (!payload)
          throwException("Provided payload pointer is invalid.", "PoolDBOutputService::writeOne");
        std::lock_guard<std::recursive_mutex> lock(m_mutex);
        if (!m_dbstarted)
          this->initDB();
        Hash payloadId = m_session.storePayload(*payload);
        std::string payloadType = cond::demangledName(typeid(T));
        if (isNewTagRequest(recordName)) {
          createNewIOV(payloadId, payloadType, time, endOfTime(), recordName, withlogging);
        } else {
          appendSinceTime(payloadId, time, recordName, withlogging);
        }
      }

      // close the IOVSequence setting lastTill
      void closeIOV(Time_t lastTill, const std::string& recordName, bool withlogging = false);

      //
      template <typename T>
      void createNewIOV(T* firstPayloadObj,
                        cond::Time_t firstSinceTime,
                        cond::Time_t firstTillTime,
                        const std::string& recordName,
                        bool withlogging = false) {
        if (!firstPayloadObj)
          throwException("Provided payload pointer is invalid.", "PoolDBOutputService::createNewIOV");
        std::lock_guard<std::recursive_mutex> lock(m_mutex);
        if (!m_dbstarted)
          this->initDB();
        createNewIOV(m_session.storePayload(*firstPayloadObj),
                     cond::demangledName(typeid(T)),
                     firstSinceTime,
                     firstTillTime,
                     recordName,
                     withlogging);
      }

      void createNewIOV(const std::string& firstPayloadId,
                        const std::string payloadType,
                        cond::Time_t firstSinceTime,
                        cond::Time_t firstTillTime,
                        const std::string& recordName,
                        bool withlogging = false);

      // this one we need to avoid to adapt client code around... to be removed in the long term!
      void createNewIOV(const std::string& firstPayloadId,
                        cond::Time_t firstSinceTime,
                        cond::Time_t firstTillTime,
                        const std::string& recordName,
                        bool withlogging = false);

      //
      template <typename T>
      void appendSinceTime(T* payloadObj,
                           cond::Time_t sinceTime,
                           const std::string& recordName,
                           bool withlogging = false) {
        if (!payloadObj)
          throwException("Provided payload pointer is invalid.", "PoolDBOutputService::appendSinceTime");
        appendSinceTime(m_session.storePayload(*payloadObj), sinceTime, recordName, withlogging);
      }

      // Append the payload and its valid sinceTime into the database
      // Note: the iov index appended to MUST pre-existing and the existing
      // conditions data are retrieved from the DB
      //
      void appendSinceTime(const std::string& payloadId,
                           cond::Time_t sinceTime,
                           const std::string& recordName,
                           bool withlogging = false);

      //
      // Service time utility method
      // return the infinity value according to the given timetype
      //
      cond::Time_t endOfTime() const;
      //
      // Service time utility method
      // return beginning of time value according to the given timetype
      //
      cond::Time_t beginOfTime() const;
      //
      // Service time utility method
      // return the time value of the current edm::Event according to the
      // given timetype
      //
      cond::Time_t currentTime() const;

      // optional. User can inject additional information into the log associated with a given record
      void setLogHeaderForRecord(const std::string& recordName,
                                 const std::string& provenance,
                                 const std::string& usertext);

      //
      // Retrieve tag information of the data
      //
      void tagInfo(const std::string& recordName, cond::TagInfo_t& result);

      virtual ~PoolDBOutputService();

      void forceInit();

    private:
      //
      //use these to control transaction interval
      //
      void preEventProcessing(edm::StreamContext const&);
      void preGlobalBeginLumi(edm::GlobalContext const&);
      void preGlobalBeginRun(edm::GlobalContext const&);
      void preModuleEvent(edm::StreamContext const&, edm::ModuleCallingContext const&);
      void postModuleEvent(edm::StreamContext const&, edm::ModuleCallingContext const&);

      struct Record {
        Record() : m_tag(), m_isNewTag(false), m_idName(), m_timetype(cond::runnumber), m_closeIOV(false) {}

        std::string timetypestr() const { return cond::timeTypeSpecs[m_timetype].name; }
        std::string m_tag;
        bool m_isNewTag;
        std::string m_idName;
        cond::TimeType m_timetype;
        bool m_closeIOV;
      };

      void fillRecord(edm::ParameterSet& pset);

      void connect();
      void disconnect();
      void initDB(bool dummy = false);

      Record& lookUpRecord(const std::string& recordName);
      cond::UserLogInfo& lookUpUserLogInfo(const std::string& recordName);

    private:
      std::recursive_mutex m_mutex;
      cond::TimeType m_timetype;
      std::string m_timetypestr;
      std::vector<cond::Time_t> m_currentTimes;

      cond::persistency::Session m_session;
      bool m_dbstarted;

      std::map<std::string, Record> m_callbacks;
      std::vector<std::pair<std::string, std::string> > m_newtags;
      bool m_closeIOV;
      std::map<std::string, cond::UserLogInfo> m_logheaders;

    };  //PoolDBOutputService
  }     // namespace service
}  // namespace cond
#endif