/home/bes3soft/bes3soft/Boss/7.0.2/dist/7.0.2/Event/ers/ers-00-00-03/src/Issue.cxx

Go to the documentation of this file.

/*
 *  Issue.cxx
 *  ers
 *
 *  Created by Matthias Wiesmann on 26.11.04.
 *  Copyright 2004 CERN. All rights reserved.
 *
 */


#include <iostream>
#include <sstream>
#include <errno.h>
#include <unistd.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>
#include <sysexits.h>

#include "ers/ers.h"
#include "ers/HumanStream.h"
#include <cstring>
#include <typeinfo> 
#define BUFFER_SIZE 256 

#define ISSUE_VALUE_SET_SCALAR(table,key,value) { std::ostringstream stream ; stream << value ;  table[key] = stream.str(); }

namespace {
    ers::Issue *create_issue() { return new ers::Issue(); } 
    bool registered = ers::IssueFactory::instance()->register_issue(ers::Issue::ISSUE_CLASS_NAME,create_issue) ;
} 

using namespace ers ; 

const char* const Issue::CLASS_KEY = "ISSUE_CLASS" ; 
const char* const Issue::COMPILATION_TIME_KEY = "COMPILATION_TIME" ; 
const char* const Issue::COMPILATION_TARGET_KEY = "COMPILATION_TARGET" ; 
const char* const Issue::COMPILATION_DEBUG_LVL_KEY = "COMPILATION_DEBUG_LVL" ; 
const char* const Issue::COMPILER_KEY = "COMPILER" ; 
const char* const Issue::CPP_CLASS_KEY = "ISSUE_CPP_CLASS" ; 
const char* const Issue::ERS_VERSION_KEY = "ERS_VERSION" ;
const char* const Issue::HOST_NAME_KEY = "HOST_NAME" ; 
const char* const Issue::HOST_TYPE_KEY = "HOST_TYPE" ; 
const char* const Issue::HOST_IP_ADDR_KEY = "HOST_IP" ; 
const char* const Issue::MESSAGE_KEY = "MESSAGE" ; 
const char* const Issue::PROCESS_ID_KEY = "PROCESS_ID" ;
const char* const Issue::PROCESS_PWD_KEY = "PROCESS_PWD" ; 
const char* const Issue::PROGRAM_NAME_KEY = "PROGRAM_NAME"; 
const char* const Issue::RESPONSIBILITY_KEY = "RESPONSIBILITY" ; 
const char* const Issue::SEVERITY_KEY = "SEVERITY" ; 
const char* const Issue::SOURCE_POSITION_KEY = "SOURCE_POSITION" ; 
const char* const Issue::SOURCE_PACKAGE_KEY = "SOURCE_PACKAGE" ; 
const char* const Issue::TIME_KEY = "TIME" ; 
const char* const Issue::TRANSIENCE_KEY = "TRANSIENCE" ; 
const char* const Issue::USER_ID_KEY = "USER_ID" ; 
const char* const Issue::USER_NAME_KEY = "USER_NAME" ; 
const char* const Issue::CAUSE_TEXT_KEY = "CAUSE_TEXT"  ;
const char* const Issue::CAUSE_PSEUDO_KEY = "CAUSE" ;
const char* const Issue::QUALIFIER_LIST_KEY = "QUALIFIERS" ; 
const char* const Issue::EXIT_VALUE_KEY = "EXIT_VALUE" ; 

const char* const Issue::ISSUE_CLASS_NAME = "ers::issue" ; 

// Constructors
// ====================================================

Issue::Issue() {
    m_human_description.clear() ; 
    m_cause = 0 ; 
} // Issue

Issue::Issue(const Issue &issue) : std::exception() {
    m_value_table = issue.m_value_table ;
    m_human_description = issue.m_human_description ; 
    if (issue.m_cause) {
        this->m_cause = issue.m_cause->clone(); 
    } else {
        this->m_cause = 0 ; 
    } 
} // Issue

Issue::Issue(const string_map_type &values) {
    cause(); 
    set_values(values); 
    m_human_description.clear();
} // Issue


Issue::Issue(const Context &context, severity_t s, const std::string &m) {
    cause(); 
    setup_common(&context);
    severity(s);
    finish_setup(m); 
} // Issue

Issue::Issue(const Context &context, severity_t s) {
    cause();   
    setup_common(&context);
    severity(s);
} // Issue

Issue::Issue(const Context &context, severity_t s, const std::exception *cause_exception) {
    ERS_PRE_CHECK_PTR(cause_exception);
    cause(cause_exception); 
    setup_common(&context);
    severity(s);
    finish_setup(cause_exception->what()); 
} // Issue

Issue::~Issue() throw() {
    if (m_cause) delete m_cause ; 
    m_cause = 0 ; 
} // ~Issue


// Operators and factory methods 
// ====================================================


Issue *Issue::clone() const { 
    return IssueFactory::instance()->build(this) ; 
} // clone


Issue::operator std::string() const {
    std::string s = human_description();
    return s ;
} // std::string()

Issue Issue::operator=(const Issue &source) {
    Issue target(source);
    return target ; 
} // operator=

bool Issue::operator==(const Issue &other) const throw() {
    if (m_value_table != other.m_value_table) return false ; 
    if (m_cause == other.m_cause) return true ; 
    return (*m_cause) == *(other.m_cause) ; 
} // operator==

const std::string & Issue::operator[](const std::string &key) const throw() {
    return get_value(key,"");
} // operator[]



// ====================================================
// Stream Operators
// ====================================================


std::ostream& ers::operator<<(std::ostream& s, const Issue& i) {
    return s << i.human_description() ; 
} // operator<<

Stream& ers::operator<<(Stream& s, const Issue& i) {
    s.send(&i); 
    return s ; 
} // operator<< 


// ====================================================
// Manipulation of the m_cause field 
// ====================================================

const Issue *Issue::cause() const throw() {
    return m_cause ; 
} // cause

void Issue::cause(const std::exception *c) {
    if (c==0) {
        m_cause = 0 ; 
        return ; 
    } // No cause easy. 
    const Issue *i = dynamic_cast<const Issue *>(c) ; 
    if (i) {
        m_cause = i->clone(); 
    } else {
        m_cause = 0 ; 
    } // if
    set_value(CAUSE_TEXT_KEY,c->what()); 
} // cause


// Value Table manipulation Methods 
// ====================================================

const string_map_type* Issue::get_value_table() const {
    return &m_value_table ; 
} // get_value_table

const std::string &Issue::get_value(const std::string &key, const std::string &def) const throw() {
    string_map_type::const_iterator pos = m_value_table.find(key);
    if (pos!=m_value_table.end()) {
        return pos->second ; 
    } // if
    return def ; 
} // get_value

const std::string &Issue::get_value(const std::string &key) const throw() {
    return get_value(key,Core::empty_string) ; 
} // get_value


int Issue::get_int_value(const std::string &key, int def) const throw() {
    std::string v = get_value(key) ;      
    if (! v.empty()) { // not empty 
        std::istringstream in(v) ;
        int n ; 
        in >> n ;
        return n ; 
        // return atoi(v.c_str());
    } else { // empty 
        return def ; 
    } // empty 
} // get_int_value


long Issue::get_long_value(const std::string &key, long def) const throw() {
    std::string v = get_value(key) ;      
    if (! v.empty()) { // not empty 
        std::istringstream in(v) ;
        long n ; 
        in >> n ;
        return n ; 
        // return atoi(v.c_str());
    } else { // empty 
        return def ; 
    } // empty 
} // get_long_value

double Issue::get_double_value(const std::string key, double def=nan("")) const throw() {
    std::string v = get_value(key) ;      
    if (! v.empty()) { // not empty 
        std::istringstream in(v) ;
        double n ; 
        in >> n ;
        return n ; 
        // return atoi(v.c_str());
    } else { // empty 
        return def ; 
    } // empty     
} // get_double_value


void Issue::set_values(const string_map_type &values) throw() {
    m_value_table = values ;
} // load_values

void Issue::set_value(const std::string &key, uint8_t value) throw() {
    ISSUE_VALUE_SET_SCALAR(m_value_table,key,value); 
} // set_value

void Issue::set_value(const std::string &key, uint16_t value) throw() {
    ISSUE_VALUE_SET_SCALAR(m_value_table,key,value); 
} // set_value

void Issue::set_value(const std::string &key, uint32_t value) throw() {
    ISSUE_VALUE_SET_SCALAR(m_value_table,key,value); 
} // set_value

void Issue::set_value(const std::string &key, uint64_t value) throw() {
    ISSUE_VALUE_SET_SCALAR(m_value_table,key,value); 
} // set_value

void Issue::set_value(const std::string &key, int8_t value) throw() {
    ISSUE_VALUE_SET_SCALAR(m_value_table,key,value); 
} // set_value

void Issue::set_value(const std::string &key, int16_t value) throw() {
    ISSUE_VALUE_SET_SCALAR(m_value_table,key,value); 
} // set_value

void Issue::set_value(const std::string &key, int32_t value) throw() {
    ISSUE_VALUE_SET_SCALAR(m_value_table,key,value); 
} // set_value

void Issue::set_value(const std::string &key, int64_t value) throw() {
    ISSUE_VALUE_SET_SCALAR(m_value_table,key,value); 
} // set_value

void Issue::set_value(const std::string &key, double value) throw() {
    std::ostringstream stream ;
    stream << value ; 
    m_value_table[key] = stream.str();
} // set_value

void Issue::set_value(const std::string &key, const std::string &value) throw() {
    if (! value.empty()) {
        m_value_table[key] = value ;
    }
} // set_value

void Issue::set_value(const std::string &key, const char* value) throw() {
    if (value) {
        std::string value_str = std::string(value) ; 
        set_value(key,value_str); 
    } // if 
} // set_value

void Issue::set_value(const std::string &key, const void* ptr) throw() {
    std::ostringstream stream ;
    stream.setf(std::ios::hex,std::ios::basefield); 
    stream << (unsigned long) ptr ; 
    m_value_table[key] = stream.str();
} // set_value


int Issue::values_number() const {
    return m_value_table.size(); 
} // values_number

// ====================================================
// Insertions Methods
// ====================================================

void Issue::insert(const Context *context) throw() {
    if (context) {
        set_value(SOURCE_POSITION_KEY,context->position()) ; 
        set_value(SOURCE_PACKAGE_KEY,context->package_name()); 
        set_value(COMPILER_KEY,context->compiler()) ; 
        set_value(COMPILATION_TIME_KEY,context->compilation()) ; 
        set_value(COMPILATION_TARGET_KEY,context->host_type()) ; 
        int lvl = ers::Context::debug_level();
        if (lvl>=0) {
            set_value(COMPILATION_DEBUG_LVL_KEY,lvl); 
        } // if
        int frame_number = context->stack_frames();
        for(int i=0;i<frame_number;i++) {
            char key_buffer[256] ; 
            snprintf(key_buffer,sizeof(key_buffer),"SOURCE-STACK-%03x",i);
            set_value(key_buffer,context->stack_frame(i)); 
        } // for
        std::vector<std::string> qualifs = context->qualifiers() ;
        std::vector<std::string>::const_iterator pos ; 
        for(pos=qualifs.begin();pos!=qualifs.end();pos++) {
            add_qualifier(*pos) ; 
        } // for
    } // if context 
} // insert

void Issue::insert_time() throw() {
    time_t now ;
    time(&now); 
    char time_buffer[BUFFER_SIZE] ; 
    ctime_r(&now,time_buffer) ; 
    char *cr = strchr(time_buffer,'\n');
    if (cr) {
        *cr = '\0' ;
    } // carriage return 
    set_value(TIME_KEY,time_buffer); 
} // insert_time

// ====================================================
// Setup Methods
// ====================================================

void Issue::setup_common(const Context *context) throw() {
    const int errno_copy = errno ; // We need to save errno, because it might be changed 
    insert(context);
    insert_time();
    errno = errno_copy ; // we restaure errno 
} // setup_common

/* Cut out stuff to remove dependency
* \li Hostname 
  * \li Process id
  * \li OS and processor of the host
 Process p ; 
    set_value(PROCESS_ID_KEY,p.process_id()); 
    System::User user ; 
    set_value(USER_ID_KEY,user.identity()) ; 
    set_value(USER_NAME_KEY,user.name_safe()) ; 
    set_value(PROCESS_PWD_KEY,System::File::working_directory()); 
    System::LocalHost *localhost = System::LocalHost::instance(); 
    set_value(HOST_NAME_KEY,localhost->full_name()); 
    set_value(HOST_IP_ADDR_KEY,localhost->ip_string()); 
    set_value(HOST_TYPE_KEY,localhost->description()); 

*/


void Issue::finish_setup(const std::string &msg) throw() {
    // set_value(CPP_CLASS_KEY,class_name); 
    set_value(CLASS_KEY, get_class_name()) ;
    set_value(MESSAGE_KEY,msg); 
} // finish_setup



// ====================================================
// Field Access Methods
// ====================================================

const char*Issue::get_class_name() const throw()  {
    if (m_class_name.empty()) {
        const Issue *p = this ;
        m_class_name = ers::Core::umangle_gcc_class_name((typeid(*p)).name()).c_str(); 
        if (m_class_name.empty()) {
             m_class_name=ISSUE_CLASS_NAME ; 
        } // fall back 
    } 
    return m_class_name.c_str() ;
} // get_class_name

severity_t Issue::severity() const throw() {
    std::string value = get_value(SEVERITY_KEY); 
    return ers::Core::parse_severity(value);
} // severity

void Issue::severity(severity_t s) {
    set_value(SEVERITY_KEY,ers::Core::to_string(s)); 
} // severity

bool Issue::is_error() {
    severity_t s = severity(); 
    return (s==ers::error || s== ers::fatal) ;
} // is_error

std::string Issue::severity_message() const {
    return get_value(SEVERITY_KEY);  
} // severity_message


responsibility_t  Issue::responsibility() const throw() {
    std::string value = this->get_value(RESPONSIBILITY_KEY); 
    return ers::Core::parse_responsibility(value);
} // responsability

void Issue::responsibility(responsibility_t  r) {
    set_value(RESPONSIBILITY_KEY,ers::Core::to_string(r)) ; 
} // responsability


void Issue::transience(bool tr) {
    set_value(TRANSIENCE_KEY,ers::Core::to_string(tr)) ; 
} // transience

int Issue::transience() const throw () {
    std::string value = this->get_value(TRANSIENCE_KEY); 
    return ers::Core::parse_boolean(value.c_str());
} // transience


const std::string &Issue::human_description() const throw()  {
    if (m_human_description.empty()) {
         m_human_description = HumanStream::to_string(this) ; 
    } 
    return m_human_description ; 
}  // human_description

const char *Issue::what() const throw() {
    std::string desr = human_description() ; 
    return desr.c_str(); 
} // what();  

const std::string &Issue::message() const throw() {
    return get_value(MESSAGE_KEY) ; 
} // message

int Issue::exit_value() const throw() {
    int v = 1 ; 
    if (transience()==1) v = EX_TEMPFAIL ; 
    return get_int_value(EXIT_VALUE_KEY,v); 
} // exit_value

void Issue::add_qualifier(const std::string &qualif) {
    const std::string &qualif_s = get_value(QUALIFIER_LIST_KEY) ; 
    std::string::size_type pos = qualif_s.find(qualif);
    if (pos!=std::string::npos) return ; // already present
    std::string n_qualif = qualif_s+qualif + " " ; 
    set_value(QUALIFIER_LIST_KEY,n_qualif); 
} // add_qualifier

std::vector<std::string> Issue::qualifiers() const {
    const std::string &qualif_s = get_value(QUALIFIER_LIST_KEY) ; 
    return ers::Core::tokenize(qualif_s,", \t"); 
} // qualifiers

---