MessageLoggerScribe.h

Go to the documentation of this file.

#ifndef FWCore_MessageService_MessageLoggerScribe_h
#define FWCore_MessageService_MessageLoggerScribe_h
 
#include "FWCore/Utilities/interface/value_ptr.h"
#include "FWCore/Utilities/interface/propagate_const.h"
 
#include "FWCore/MessageService/interface/ELdestination.h"
#include "FWCore/MessageService/interface/MessageLoggerDefaults.h"
#include "FWCore/MessageLogger/interface/MessageLoggerQ.h"
#include "FWCore/MessageLogger/interface/AbstractMLscribe.h"
 
#include "FWCore/ParameterSet/interface/ParameterSet.h"
 
#include <memory>
 
#include <iosfwd>
#include <vector>
#include <map>
 
#include <iostream>
 
namespace edm {
  namespace service {
 
    // ----------------------------------------------------------------------
    //
    // MessageLoggerScribe.h
    //
    // Changes:
    //
    //   1 - 2/6/07  mf
    //  Set up ability to get a remembered pointer to the ErrorLog of an
    //      instance of MessageLoggerScribe, from a non-member function, via
    //  getErrorLog_ptr(), and a corresponding routine to remember the pointer
    //  as setStaticErrorLog_ptr().  Needed if we decide to send an explicit
    //      message from the scribe.
    //
    //   2 - ?/?/? before 3/1/07 jm
    //   Modify parameter getting template so as not to catch tracked ones
    //   (that is, to crash if user mistakenly does not say untracked)
    //
    //   3 - 3/13/07 mf
    //   Added configure_ordinary_destinations, configure_fwkJobReports,
    //   and configure_statistics to allow these to be broken out of
    //   configure_errorlog.
    //
    //   4 - 3/26/07 mf
    //   Added configure_default_fwkJobReport, which implements the config
    //   originally placed in the .cfi file.
    //
    //   5 - 6/15/07 mf
    //   Accommodations for use of MessageLoggerDefault structure
    //
    //   6 - 7/24/07 mf
    //   Instace variable indicating that we really are logging what is sent.
    //   This is to be able to supress the <generator> info sent at exit by
    //   the JobReport, in the case where no .cfg file was given.
    //
    //   7 - 4/8/08 mf
    //   Modified getAparameter behavior when tracked parameter is found,
    //   for nicer output message.
    //
    //   8 - 6/19/08 mf
    //   triggerFJRmessageSummary
    //
    //   9 - 10/21/08 mf
    //   variables and routines in preparation for single-thread
    //
    //  10 - 10/22/08 mf
    //   derivation from AbstractMLscribe to allow for single-thread calling
    //   from MessageLoggerQ without introducing coupling to MessageService
    //
    //  11 - 5/26/09 mf
    //   restore getAparameter behavior to NOT throw for tracked, since
    //       now this will be caught when validating the PSet.
    //
    //  12 - 8/10/09 mf, cj
    //   member data  to hold shared pointer to thread queue
    //
    // -----------------------------------------------------------------------
 
    class ThreadQueue;
    class ELadministrator;
    class ELstatistics;
 
    class MessageLoggerScribe : public AbstractMLscribe {
    public:
      // ---  birth/death:
 
      // ChangeLog 12
      explicit MessageLoggerScribe(std::shared_ptr<ThreadQueue> queue);
 
      ~MessageLoggerScribe() override;
 
      // --- receive and act on messages:
      virtual void run();
      // changelog 10
      void runCommand(MessageLoggerQ::OpCode opcode, void* operand) override;
      // changeLog 9
 
    private:
      // --- convenience typedefs
      typedef std::string String;
      typedef std::vector<String> vString;
      typedef ParameterSet PSet;
 
      // --- log one consumed message
      void log(ErrorObj* errorobj_p);
 
      // --- cause statistics destinations to output
      void triggerStatisticsSummaries();
      void triggerFJRmessageSummary(std::map<std::string, double>& sm);
 
      // --- handle details of configuring via a ParameterSet:
      void configure_errorlog();
      void configure_ordinary_destinations();  // Change Log 3
      void configure_statistics();             // Change Log 3
      void configure_dest(std::shared_ptr<ELdestination> dest_ctrl, String const& filename);
 
#define VALIDATE_ELSEWHERE  // ChangeLog 11
 
#ifdef OLDSTYLE
      template <class T>
      T getAparameter(PSet const& p, std::string const& id, T const& def) {
        T t;
        try {
          t = p.template getUntrackedParameter<T>(id, def);
        } catch (...) {
          t = p.template getParameter<T>(id);
          std::cerr << "Tracked parameter " << id << " used in MessageLogger configuration.\n"
                    << "Use of tracked parameters for the message service "
                    << "is deprecated.\n"
                    << "The .cfg file should be modified to make this untracked.\n";
        }
        return t;
      }
#else
#ifdef SIMPLESTYLE
      template <class T>
      T getAparameter(PSet const& p, std::string const& id, T const& def) {
        T t;
        t = p.template getUntrackedParameter<T>(id, def);
        return t;
      }  // changelog 2
#else
#ifdef VALIDATE_ELSEWHERE
      template <class T>  // ChangeLog 11
      T getAparameter(PSet const& p, std::string const& id, T const& def) {
        T t = def;
        try {
          t = p.template getUntrackedParameter<T>(id, def);
        } catch (...) {
          try {
            t = p.template getParameter<T>(id);
          } catch (...) {
            // Since PSetValidation will catch such errors, we simply proceed as
            // best we can in case we are setting up the logger just to contain the
            // validation-caught error messages.
          }
        }
        return t;
      }
#else  // Do not tolerate errors
      template <class T>
      T getAparameter(PSet const& p, std::string const& id, T const& def) {  // changelog 7
        T t;
        try {
          t = p.template getUntrackedParameter<T>(id, def);
        } catch (cms::Exception& e) {
          try {
            t = p.template getParameter<T>(id);
          } catch (...) {
            // if we get here, this was NOT a simple tracked parameter goof.
            // we should just rethrow the ORIGINAL error
            e.raise();
          }
          std::cerr << "Tracked parameter " << id << " used in MessageLogger configuration.\n"
                    << "Use of tracked parameters for the message service "
                    << "is not allowed.\n"
                    << "The .cfg file should be modified to make this untracked.\n";
          e.raise();
        } catch (...) {
          // This is not the usual tracked/untracked error; we can't add useful info
          throw;
        }
        return t;
      }
 
#endif  // VALIDATE_ELSEWHERE
#endif  // SIMPLESTYLE
#endif  // OLD_STYLE and the else Do not tolerate errors
 
#ifdef REMOVE
      template <class T>
      T getCategoryDefault(PSet* p, std::string const& id, std::string const& def) {
        T t;
        t = p->template getUntrackedParameter<T>(id, def);
        return t;
      }
#endif
 
      // --- other helpers
      void parseCategories(std::string const& s, std::vector<std::string>& cats);
 
      // --- data:
      edm::propagate_const<std::shared_ptr<ELadministrator>> admin_p;
      std::shared_ptr<ELdestination> early_dest;
      std::vector<edm::propagate_const<std::shared_ptr<std::ofstream>>> file_ps;
      edm::propagate_const<std::shared_ptr<PSet>> job_pset_p;
      std::map<String, edm::propagate_const<std::ostream*>> stream_ps;
      std::vector<String> ordinary_destination_filenames;
      std::vector<std::shared_ptr<ELstatistics>> statisticsDestControls;
      std::vector<bool> statisticsResets;
      bool clean_slate_configuration;
      value_ptr<MessageLoggerDefaults> messageLoggerDefaults;
      bool active;
      bool singleThread;                                           // changeLog 9
      bool done;                                                   // changeLog 9
      bool purge_mode;                                             // changeLog 9
      int count;                                                   // changeLog 9
      edm::propagate_const<std::shared_ptr<ThreadQueue>> m_queue;  // changeLog 12
 
    };  // MessageLoggerScribe
 
  }  // end of namespace service
}  // namespace edm
 
#endif  // FWCore_MessageService_MessageLoggerScribe_h