QString ThresholdHelper::toString(void)
{
if (isValid())
return QObject::tr("Set %1\% %2 To %3")
.arg(QString::number(m_weight * 100), Severity(m_sevIn).toString(), Severity(m_sevOut).toString());
return QString();
}
Severity Severity::operator *(Severity& sev) const
{
switch(m_sev) {
case ngrt4n::Critical:
return Severity(m_sev);
break;
case ngrt4n::Normal:
return sev;
break;
case ngrt4n::Minor:
if(sev.m_sev == ngrt4n::Critical ||
sev.m_sev == ngrt4n::Major ||
sev.m_sev == ngrt4n::Unknown)
return sev;
return Severity(m_sev);
break;
case ngrt4n::Major:
if(sev.m_sev == ngrt4n::Critical ||
sev.m_sev == ngrt4n::Unknown)
return sev;
return Severity(m_sev);
break;
default:
// MonitorBroker::CRITICITY_UNKNOWN
if(sev.m_sev == ngrt4n::Critical)
return sev;
break;
} //end switch
return Severity(ngrt4n::Unknown);
}
/// Calculate the OR of two error objects.
///\return An error object that is the OR of the two error object operands.
XsError &XsError::operator |= ( XsError const &rXsError ) ///< 2nd operand.
{
// Concatenate the error messages.
if ( IsError() && rXsError.IsError() )
*this += "\n- AND -\n";
if ( rXsError.IsError() )
*this += (ErrorMsgType)rXsError;
// Severity of the combined errors is the largest severity.
Severity( MAX( Severity(), rXsError.Severity() ) );
return *this;
}
Severity Severity::operator--()
{
switch(m_sev) {
case ngrt4n::Critical:
return Severity(ngrt4n::Major);
break;
case ngrt4n::Major:
return Severity(ngrt4n::Minor);
break;
default: //leave as is
break;
}
return Severity(m_sev);
}
void
MessageAttributes::SetFromNode(DataNode *parentNode)
{
if(parentNode == 0)
return;
DataNode *searchNode = parentNode->GetNode("MessageAttributes");
if(searchNode == 0)
return;
DataNode *node;
if((node = searchNode->GetNode("text")) != 0)
SetText(node->AsString());
if((node = searchNode->GetNode("unicode")) != 0)
SetUnicode(node->AsUnsignedCharVector());
if((node = searchNode->GetNode("hasUnicode")) != 0)
SetHasUnicode(node->AsBool());
if((node = searchNode->GetNode("severity")) != 0)
{
// Allow enums to be int or string in the config file
if(node->GetNodeType() == INT_NODE)
{
int ival = node->AsInt();
if(ival >= 0 && ival < 5)
SetSeverity(Severity(ival));
}
else if(node->GetNodeType() == STRING_NODE)
{
Severity value;
if(Severity_FromString(node->AsString(), value))
SetSeverity(value);
}
}
}
AlertPtrNN makeNewAlert(const char *name,
const char *sip,
const char *tip,
const char *dns,
const double certainty)
{
const ::Persistency::Alert::Analyzers sa( makeNewAnalyzer() );
Alert::Hosts srcHosts;
Alert::Hosts tgtHosts;
if(sip!=NULL)
srcHosts.push_back( makeNewHost(sip, dns) );
if(tip!=NULL)
tgtHosts.push_back( makeNewHost(tip, dns) );
return AlertPtrNN( new Alert(name,
sa,
NULL,
Timestamp(12345),
Severity(SeverityLevel::INFO),
Certainty(certainty),
"some test alert",
srcHosts,
tgtHosts) );
}
AlertPtrNN makeNewAlertWithHosts(const char *hostSrc1,
const char *hostSrc2,
const char *hostDst1,
const char *hostDst2,
const Timestamp &createTime)
{
const Alert::Analyzers sa( makeNewAnalyzer() );
Alert::Hosts hostsSrc;
Alert::Hosts hostsDst;
if(hostSrc1!=NULL)
hostsSrc.push_back( makeNewHost(hostSrc1) );
if(hostSrc2!=NULL)
hostsSrc.push_back( makeNewHost(hostSrc2) );
if(hostDst1!=NULL)
hostsDst.push_back( makeNewHost(hostDst1) );
if(hostDst2!=NULL)
hostsDst.push_back( makeNewHost(hostDst2) );
return AlertPtrNN( new Alert("alert 123",
sa,
NULL,
createTime,
Severity(SeverityLevel::INFO),
Certainty(0.42),
"some test alert",
hostsSrc,
hostsDst) );
}
/// Construct an error object.
///\return Nothing.
XsError::XsError(
ErrorSeverityType const severity, ///< Severity of error.
ErrorMsgType const &rMsg ///< Error message.
)
{
Severity( severity );
mMsg = rMsg;
mNumErrors = 0;
}
QString NodeT::toThresholdsString(void) const
{
QString result = "";
if (sev_crule == CalcRules::WeightedAverageWithThresholds) {
Q_FOREACH(const ThresholdT& th, thresholdLimits) {
result.append(QString("%1\% of %2 => %3; ").arg(QString::number(100 * th.weight),
Severity(th.sev_in).toString(),
Severity(th.sev_out).toString()));
}
bool BuiltinOutputBehavior::open(void)
{
if (csmTroll == mSchemeEcc)
{
QVariant varWarning = mpFork->urlOption( "WarningSeverity");
QVariant varCritical = mpFork->urlOption("CriticalSeverity");
if ( ! varWarning.isNull())
mWarningSeverity = Severity(varWarning.toInt());
if ( ! varCritical.isNull())
mCriticalSeverity = Severity(varCritical.toInt());
// handle QtDebug
return true;
}
if (csmTxtFile == mSchemeEcc)
{
QString filePath = mUrl.path();
mpFile = new QFile(filePath);
if (mpFile)
if ( ! mpFile->open(QIODevice::WriteOnly))
return mpFork->setError("Unable to open file: "+filePath);
mpStream = new QTextStream((QIODevice *)mpFile);
}
else if (csmStderr == mSchemeEcc)
{
mpStream = new QTextStream(stderr, QIODevice::WriteOnly);
}
else if (csmStdout == mSchemeEcc)
{
mpStream = new QTextStream(stdout, QIODevice::WriteOnly);
}
else
{
qWarning(qPrintable("Invalid SchemeEcc in"
" BuiltinOutputBehavior::open(): "
+ mSchemeEcc));
return false;
}
if (mpStream && QTextStream::Ok != mpStream->status())
return mpFork->setStarted();
else
return mpFork->setError("Unable to open text stream");
}
/**
*
* General logging function for test suites, with severity.
*
* @param "TInt aSeverity"
* Severity level required to log
*
* @param "TRefByValue<const TDesC16> aFmt"
* Printf-style format.
*
* @param "..."
* Variable print parameters
*
* @xxxx
*
*/
EXPORT_C void CTestSuite::Log(TInt aSeverity, TRefByValue<const TDesC16> aFmt, ...)
{
VA_LIST aList;
VA_START(aList, aFmt);
if(LogSeverity::IsActive(aSeverity, Severity()))
{
if(iLogger)
iLogger->Log(aFmt, aList);
}
VA_END(aList);
}
Severity Severity::operator / (Severity& st) const
{
if(m_sev == st.m_sev)
return st;
if(m_sev == ngrt4n::Critical ||
st.m_sev == ngrt4n::Critical)
return Severity(ngrt4n::Critical);
if(m_sev == ngrt4n::Unknown ||
st.m_sev == ngrt4n::Unknown)
return Severity(ngrt4n::Unknown);
if(m_sev == ngrt4n::Major ||
st.m_sev == ngrt4n::Major)
return Severity(ngrt4n::Major);
if(m_sev == ngrt4n::Minor ||
st.m_sev == ngrt4n::Minor)
return Severity(ngrt4n::Minor);
return Severity(ngrt4n::Normal);
}
/**
*
* Traceable logging function for test suites.
*
* @param "const TText8* aFile"
* Source code file name
*
* @param "TInt aLine"
* Source code line
*
* @param "TInt aSeverity"
* Severity level required to log
*
* @param "TRefByValue<const TDesC16> aFmt"
* Printf-style format.
*
* @param "..."
* Variable print parameters
*
* @xxxx
*
*/
EXPORT_C void CTestSuite::LogExtra(const TText8* aFile, TInt aLine, TInt aSeverity,
TRefByValue<const TDesC16> aFmt,...)
{
VA_LIST aList;
VA_START(aList, aFmt);
if(LogSeverity::IsActive(aSeverity, Severity()))
{
if(iLogger)
{
iLogger->LogExtra(aFile, aLine, aSeverity, aFmt, aList);
}
}
VA_END(aList);
}
void testObj::test<8>(void)
{
// making timestamp for all calls prevents timing issues.
const Timestamp now=Timestamp(123456);
Persistency::MetaAlertPtrNN maPtrNode( new Persistency::MetaAlert( Persistency::MetaAlert::Name("meta alert node"),
0.1, 0.2,
makeNewReferenceURL().shared_ptr(),
now,
1410u ) );
Persistency::IO::Postgres::MetaAlert malertNode(maPtrNode, t_, dbh_);
Persistency::Alert::Analyzers sa( AnalyzerPtrNN( new Analyzer(42u, "analyzer name", NULL, NULL, NULL) ) );
Persistency::AlertPtrNN alertPtr(new Persistency::Alert("abc",
sa,
NULL,
now,
Severity(SeverityLevel::INFO),
Certainty(0.42),
"some description",
Persistency::Alert::Hosts(),
Persistency::Alert::Hosts()) );
Persistency::IO::Postgres::Alert alert(alertPtr, t_, dbh_);
malertNode.save();
alert.save();
malertNode.associateWithAlert( alertPtr );
const DataBaseID malertNodeID=dbh_->getIDCache()->get( maPtrNode );
const DataBaseID alertID =dbh_->getIDCache()->get( alertPtr );
stringstream ss;
ss << "SELECT * FROM alert_to_meta_alert_map WHERE id_alert = " << alertID << ";";
const result r = t_.getAPI<TransactionAPI>().exec(ss);
ensure_equals("invalid size",r.size(), 1u);
ensure_equals("invalid Alert ID", ReaderHelper<DataBaseID>::readAsNotNull(r[0]["id_meta_alert"]), malertNodeID);
ensure_equals("invalid MetaAlert ID", ReaderHelper<DataBaseID>::readAsNotNull(r[0]["id_alert"]), alertID);
t_.commit();
}
void CSsmDeferrableCommand::CompleteDeferredExecuteRequest(TInt aReason)
{
if (iCompletionObserver)
{
// notify observer of command completion
CompleteRequest(*iCompletionObserver, KErrNone); // observer is expected to call CompletionCode() to get the error code
iCompletionObserver = NULL;
}
if (Severity()==ECmdIgnoreFailure && aReason!=KErrCancel)
{
iCompletionStatus = KErrNone;
}
else
{
iCompletionStatus = aReason;
}
DEBUGVERBOSE2A("iCompletionStatus set to %d", iCompletionStatus);
if (iExecutionBehaviour != ESsmDeferredWaitForSignal)
{
CompleteExecuteRequest(aReason);
}
}
/// Append a string to the message in this error object.
///\return A new error object with the concatenated message.
XsError XsError::operator + ( ErrorMsgType const &s ///< String to concatenate to error message.
) const
{
// Return new error object with concatenated error message strings.
return XsError( Severity(), this->mMsg + s );
}
void displayWeight(void) { Q_FOREACH(int sev, m_severityWeightsMap.keys()) qDebug()<<Severity(sev).toString() << m_statusRatios[sev]; }
//! Returns \p true, if a message with level \p severity can be logged.
bool canLog(Severity severity) const noexcept
{
auto config = m_configuration.load();
return (config & 0x80) != 0 && severity >= Severity(config & 0x7F);
}
int CCgiApplication::Run(void)
{
// Value to return from this method Run()
int result;
// Try to run as a Fast-CGI loop
if ( x_RunFastCGI(&result) ) {
return result;
}
/// Run as a plain CGI application
// Make sure to restore old diagnostic state after the Run()
CDiagRestorer diag_restorer;
#if defined(NCBI_OS_UNIX)
// Disable SIGPIPE if not allowed.
if ( !TParamAllowSigpipe::GetDefault() ) {
signal(SIGPIPE, SIG_IGN);
struct sigaction sigterm, sigtermold;
memset(&sigterm, 0, sizeof(sigterm));
sigterm.sa_handler = SigTermHandler;
sigterm.sa_flags = SA_RESETHAND;
if (sigaction(SIGTERM, &sigterm, &sigtermold) == 0
&& sigtermold.sa_handler != SIG_DFL) {
sigaction(SIGTERM, &sigtermold, 0);
}
}
// Compose diagnostics prefix
PushDiagPostPrefix(NStr::IntToString(getpid()).c_str());
#endif
PushDiagPostPrefix(GetEnvironment().Get(m_DiagPrefixEnv).c_str());
// Timing
CTime start_time(CTime::eCurrent);
// Logging for statistics
bool is_stat_log = GetConfig().GetBool("CGI", "StatLog", false,
0, CNcbiRegistry::eReturn);
bool skip_stat_log = false;
auto_ptr<CCgiStatistics> stat(is_stat_log ? CreateStat() : 0);
CNcbiOstream* orig_stream = NULL;
//int orig_fd = -1;
CNcbiStrstream result_copy;
auto_ptr<CNcbiOstream> new_stream;
try {
_TRACE("(CGI) CCgiApplication::Run: calling ProcessRequest");
GetDiagContext().SetAppState(eDiagAppState_RequestBegin);
m_Context.reset( CreateContext() );
_ASSERT(m_Context.get());
m_Context->CheckStatus();
ConfigureDiagnostics(*m_Context);
x_AddLBCookie();
try {
// Print request start message
x_OnEvent(eStartRequest, 0);
VerifyCgiContext(*m_Context);
ProcessHttpReferer();
LogRequest();
try {
m_Cache.reset( GetCacheStorage() );
} catch( exception& ex ) {
ERR_POST_X(1, "Couldn't create cache : " << ex.what());
}
bool skip_process_request = false;
bool caching_needed = IsCachingNeeded(m_Context->GetRequest());
if (m_Cache.get() && caching_needed) {
skip_process_request = GetResultFromCache(m_Context->GetRequest(),
m_Context->GetResponse().out());
}
if (!skip_process_request) {
if( m_Cache.get() ) {
list<CNcbiOstream*> slist;
orig_stream = m_Context->GetResponse().GetOutput();
slist.push_back(orig_stream);
slist.push_back(&result_copy);
new_stream.reset(new CWStream(new CMultiWriter(slist), 0,0,
CRWStreambuf::fOwnWriter));
m_Context->GetResponse().SetOutput(new_stream.get());
}
GetDiagContext().SetAppState(eDiagAppState_Request);
result = CCgiContext::ProcessCORSRequest(
m_Context->GetRequest(), m_Context->GetResponse()) ?
0 : ProcessRequest(*m_Context);
GetDiagContext().SetAppState(eDiagAppState_RequestEnd);
m_Context->GetResponse().Finalize();
if (result != 0) {
SetHTTPStatus(500);
m_ErrorStatus = true;
} else {
if (m_Cache.get()) {
m_Context->GetResponse().Flush();
if (m_IsResultReady) {
if(caching_needed)
SaveResultToCache(m_Context->GetRequest(), result_copy);
else {
auto_ptr<CCgiRequest> request(GetSavedRequest(m_RID));
if (request.get())
SaveResultToCache(*request, result_copy);
}
} else if (caching_needed) {
SaveRequest(m_RID, m_Context->GetRequest());
}
}
}
}
}
catch (CCgiException& e) {
if ( x_DoneHeadRequest() ) {
// Ignore errors after HEAD request has been finished.
GetDiagContext().SetAppState(eDiagAppState_RequestEnd);
}
else {
if ( e.GetStatusCode() < CCgiException::e200_Ok ||
e.GetStatusCode() >= CCgiException::e400_BadRequest ) {
throw;
}
GetDiagContext().SetAppState(eDiagAppState_RequestEnd);
// If for some reason exception with status 2xx was thrown,
// set the result to 0, update HTTP status and continue.
m_Context->GetResponse().SetStatus(e.GetStatusCode(),
e.GetStatusMessage());
}
result = 0;
}
#ifdef NCBI_OS_MSWIN
// Logging - on MSWin this must be done before flushing the output.
if ( is_stat_log && !skip_stat_log ) {
stat->Reset(start_time, result);
stat->Submit(stat->Compose());
}
is_stat_log = false;
#endif
_TRACE("CCgiApplication::Run: flushing");
m_Context->GetResponse().Flush();
_TRACE("CCgiApplication::Run: return " << result);
x_OnEvent(result == 0 ? eSuccess : eError, result);
x_OnEvent(eExit, result);
}
catch (exception& e) {
GetDiagContext().SetAppState(eDiagAppState_RequestEnd);
if ( x_DoneHeadRequest() ) {
// Ignore errors after HEAD request has been finished.
result = 0;
x_OnEvent(eSuccess, result);
}
else {
// Call the exception handler and set the CGI exit code
result = OnException(e, NcbiCout);
x_OnEvent(eException, result);
// Logging
{{
string msg = "(CGI) CCgiApplication::ProcessRequest() failed: ";
msg += e.what();
if ( is_stat_log ) {
stat->Reset(start_time, result, &e);
msg = stat->Compose();
stat->Submit(msg);
skip_stat_log = true; // Don't print the same message again
}
}}
// Exception reporting. Use different severity for broken connection.
ios_base::failure* fex = dynamic_cast<ios_base::failure*>(&e);
CNcbiOstream* os = m_Context.get() ? m_Context->GetResponse().GetOutput() : NULL;
if ((fex && os && !os->good()) || m_OutputBroken) {
if ( !TClientConnIntOk::GetDefault() ) {
ERR_POST_X(13, Severity(TClientConnIntSeverity::GetDefault()) <<
"Connection interrupted");
}
}
else {
NCBI_REPORT_EXCEPTION_X(13, "(CGI) CCgiApplication::Run", e);
}
}
}
#ifndef NCBI_OS_MSWIN
// Logging
if ( is_stat_log && !skip_stat_log ) {
stat->Reset(start_time, result);
stat->Submit(stat->Compose());
}
#endif
x_OnEvent(eEndRequest, 120);
x_OnEvent(eExit, result);
if (m_Context.get()) {
m_Context->GetResponse().SetOutput(NULL);
}
return result;
}
/// Append a char string to the message in this error object.
///\return A new error object with the concatenated message.
XsError XsError::operator + ( char const *pCharString ///< String to concatenate to error message.
) const
{
return XsError( Severity(), mMsg + ErrorMsgType( pCharString ) );
}
/// Determine if an error has been recorded.
///\return True if any error has been recorded.
bool XsError::IsError( void ) const
{
return Severity() == NO_XS_ERROR ? false : true;
}
/// Set the severity of the error object.
///\return Error object.
XsError &XsError::operator = ( ErrorSeverityType const errorSeverity ) ///< Severity of the error.
{
Severity( errorSeverity );
return *this;
}
MessageAttributes::Severity
MessageAttributes::GetSeverity() const
{
return Severity(severity);
}
/**
The start of code.
*/
LOCAL_C void doConsoleMainL()
{
// console is initialised
// now start the Log system
TInt severity = ESevrAll;
pLogSystem = CLog::NewL( console );
CleanupStack::PushL(pLogSystem);
// initialise the CTestUtils
pTestUtils = CTestUtils::NewL( pLogSystem );
CleanupStack::PushL(pTestUtils);
// read the command line into cmd
TBuf<MAX_LEN_CMD_LINE> cmd;
User::CommandLine(cmd);
cmd.UpperCase();
// use Tlex to decode the cmd line
TLex lex(cmd);
TPtrC token=lex.NextToken();
// if there is no input filename on the cmd line Panic!
if (token.Length()==0)
Usage();
else
{
// Process any options
TBool unitTest = EFalse;
while(token.Length() > 1 && token[0] == '-')
{
switch(token[1])
{
case 'U':
case 'u':
unitTest = ETrue;
break;
case 'S':
case 's':
{
if( token.Length() == 3 )
{
TLex Severity(token);
Severity.Inc(2);
if((Severity.Peek()).IsDigit())
{
Severity.Val(severity);
// wrong severity level
if( (severity < 0) || (severity > 7 ))
severity = 7;
}
}
break;
}
case 'A':
case 'a':
automatedMode = ETrue;
break;
default:
Usage();
return;
}
token.Set(lex.NextToken());
}
if(unitTest)
{
// get suite name
TFileName suitFileName;
if (token.Length()!=0)
suitFileName = token;
else
{
Usage();
User::Leave(KErrArgument);
}
pLogSystem->OpenLogFileL(suitFileName);
pLogSystem->LogExtra(((TText8*)(__FILE__)), (__LINE__), ESevrErr,
_L("%S %S %S %S starting...."), &KTxtExampleCode(), &KTxtTarget(), &KTxtPlatform(), &KTxtBuild() );
// get ini file
token.Set(lex.NextToken());
TFileName configFileName;
if (token.Length()!=0)
{
if(token.Find(_L("-S")) == KErrNotFound )
configFileName = token;
}
// do unit test
doUnitTestL(severity, suitFileName, configFileName);
if(!automatedMode)
{
console->Printf(KTxtPressAnyKey);
console->Getch(); // get and ignore character
}
}
else
{
// there is a script file so lets do it!
// save the input filename
TFileName scriptFileName=token;
// make the log file name from the script file name
TFileName LogFileName = token;
// open the log file
pLogSystem->OpenLogFileL( LogFileName);
pLogSystem->LogExtra(((TText8*)(__FILE__)), (__LINE__), ESevrErr,
_L("%S %S %S %S starting...."),
&KTxtExampleCode(), &KTxtTarget(), &KTxtPlatform(), &KTxtBuild() );
// create a ParseScript object
CScript* parseScript=CScript::NewL();
CleanupStack::PushL(parseScript);
// parse all scripts
do
{
// get the next file
scriptFileName=token;
// read in the script file
if ( parseScript->OpenScriptFile( scriptFileName ))
{
// process it
parseScript->ExecuteScriptL( );
// display results summary
parseScript->DisplayResults( );
}
// get the next
token.Set(lex.NextToken());
} while ( token.Length()!=0 );
CleanupStack::PopAndDestroy(parseScript);
// close the logging system
pLogSystem->CloseLogFile();
}
}
// delete the test utils object
CleanupStack::PopAndDestroy(pTestUtils);
// delete pTestUtils;
// close the log file
CleanupStack::PopAndDestroy(pLogSystem);
// delete pLogSystem;
}
