diff options
Diffstat (limited to 'plugins/thresholds.cpp')
| -rw-r--r-- | plugins/thresholds.cpp | 276 |
1 files changed, 276 insertions, 0 deletions
diff --git a/plugins/thresholds.cpp b/plugins/thresholds.cpp new file mode 100644 index 0000000..bdd67ee --- /dev/null +++ b/plugins/thresholds.cpp @@ -0,0 +1,276 @@ +/* Icinga 2 | (c) 2012 Icinga GmbH | GPLv2+ */ + +#include "plugins/thresholds.hpp" +#include <boost/algorithm/string.hpp> +#include <boost/lexical_cast.hpp> +#include <iostream> + +using namespace boost::algorithm; + +threshold::threshold() + : set(false) +{} + +threshold::threshold(const double v, const double c, bool l , bool p ) { + lower = v; + upper = c; + legal = l; + perc = p; +} + +threshold::threshold(const std::wstring& stri) +{ + if (stri.empty()) + throw std::invalid_argument("Threshold must not be empty"); + + std::wstring str = stri; + + //kill whitespace + boost::algorithm::trim(str); + + bool low = (str.at(0) == L'!'); + if (low) + str = std::wstring(str.begin() + 1, str.end()); + + bool pc = false; + + if (str.at(0) == L'[' && str.at(str.length() - 1) == L']') {//is range + str = std::wstring(str.begin() + 1, str.end() - 1); + std::vector<std::wstring> svec; + boost::split(svec, str, boost::is_any_of(L"-")); + if (svec.size() != 2) + throw std::invalid_argument("Threshold range requires two arguments"); + std::wstring str1 = svec.at(0), str2 = svec.at(1); + + if (str1.at(str1.length() - 1) == L'%' && str2.at(str2.length() - 1) == L'%') { + pc = true; + str1 = std::wstring(str1.begin(), str1.end() - 1); + str2 = std::wstring(str2.begin(), str2.end() - 1); + } + + try { + boost::algorithm::trim(str1); + lower = boost::lexical_cast<DOUBLE>(str1); + boost::algorithm::trim(str2); + upper = boost::lexical_cast<DOUBLE>(str2); + legal = !low; perc = pc; set = true; + } catch (const boost::bad_lexical_cast&) { + throw std::invalid_argument("Unknown Threshold type"); + } + } else { //not range + if (str.at(str.length() - 1) == L'%') { + pc = true; + str = std::wstring(str.begin(), str.end() - 1); + } + try { + boost::algorithm::trim(str); + lower = upper = boost::lexical_cast<DOUBLE>(str); + legal = !low; perc = pc; set = true; + } catch (const boost::bad_lexical_cast&) { + throw std::invalid_argument("Unknown Threshold type"); + } + } +} + +//return TRUE if the threshold is broken +bool threshold::rend(const double val, const double max) +{ + double upperAbs = upper; + double lowerAbs = lower; + + if (perc) { + upperAbs = upper / 100.0 * max; + lowerAbs = lower / 100.0 * max; + } + + if (!set) + return set; + if (lowerAbs == upperAbs) + return val > upperAbs == legal; + else + return (val < lowerAbs || upperAbs < val) != legal; +} + +//returns a printable string of the threshold +std::wstring threshold::pString(const double max) +{ + if (!set) + return L""; + //transform percentages to abolute values + double lowerAbs = lower; + double upperAbs = upper; + if (perc) { + lowerAbs = lower / 100.0 * max; + upperAbs = upper / 100.0 * max; + } + + std::wstring s, lowerStr = removeZero(lowerAbs), + upperStr = removeZero(upperAbs); + + if (lower != upper) { + s.append(L"[").append(lowerStr).append(L"-") + .append(upperStr).append(L"]"); + } else + s.append(lowerStr); + + return s; +} + +threshold threshold::toSeconds(const Tunit& fromUnit) { + if (!set) + return *this; + + double lowerAbs = lower; + double upperAbs = upper; + + switch (fromUnit) { + case TunitMS: + lowerAbs = lowerAbs / 1000; + upperAbs = upperAbs / 1000; + break; + case TunitS: + lowerAbs = lowerAbs ; + upperAbs = upperAbs ; + break; + case TunitM: + lowerAbs = lowerAbs * 60; + upperAbs = upperAbs * 60; + break; + case TunitH: + lowerAbs = lowerAbs * 60 * 60; + upperAbs = upperAbs * 60 * 60; + break; + } + + return threshold(lowerAbs, upperAbs, legal, perc); +} + +std::wstring removeZero(double val) +{ + std::wstring ret = boost::lexical_cast<std::wstring>(val); + std::wstring::size_type pos = ret.length(); + if (ret.find_first_of(L".") == std::string::npos) + return ret; + for (std::wstring::reverse_iterator rit = ret.rbegin(); rit != ret.rend(); ++rit) { + if (*rit == L'.') { + return ret.substr(0, pos - 1); + } + if (*rit != L'0') { + return ret.substr(0, pos); + } + pos--; + } + return L"0"; +} + +std::vector<std::wstring> splitMultiOptions(const std::wstring& str) +{ + std::vector<std::wstring> sVec; + boost::split(sVec, str, boost::is_any_of(L",")); + return sVec; +} + +Bunit parseBUnit(const std::wstring& str) +{ + std::wstring wstr = to_upper_copy(str); + + if (wstr == L"B") + return BunitB; + if (wstr == L"KB") + return BunitkB; + if (wstr == L"MB") + return BunitMB; + if (wstr == L"GB") + return BunitGB; + if (wstr == L"TB") + return BunitTB; + + throw std::invalid_argument("Unknown unit type"); +} + +std::wstring BunitStr(const Bunit& unit) +{ + switch (unit) { + case BunitB: + return L"B"; + case BunitkB: + return L"kB"; + case BunitMB: + return L"MB"; + case BunitGB: + return L"GB"; + case BunitTB: + return L"TB"; + } + return NULL; +} + +Tunit parseTUnit(const std::wstring& str) { + std::wstring wstr = to_lower_copy(str); + + if (wstr == L"ms") + return TunitMS; + if (wstr == L"s") + return TunitS; + if (wstr == L"m") + return TunitM; + if (wstr == L"h") + return TunitH; + + throw std::invalid_argument("Unknown unit type"); +} + +std::wstring TunitStr(const Tunit& unit) +{ + switch (unit) { + case TunitMS: + return L"ms"; + case TunitS: + return L"s"; + case TunitM: + return L"m"; + case TunitH: + return L"h"; + } + return NULL; +} + +void printErrorInfo(unsigned long err) +{ + if (!err) + err = GetLastError(); + LPWSTR mBuf = NULL; + if (!FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, + NULL, err, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPWSTR)&mBuf, 0, NULL)) + std::wcout << "Failed to format error message, last error was: " << err << '\n'; + else { + boost::trim_right(std::wstring(mBuf)); + std::wcout << mBuf << std::endl; + } +} + +std::wstring formatErrorInfo(unsigned long err) { + std::wostringstream out; + if (!err) + err = GetLastError(); + LPWSTR mBuf = NULL; + if (!FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, + NULL, err, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPWSTR)&mBuf, 0, NULL)) + out << "Failed to format error message, last error was: " << err; + else { + std::wstring tempOut = std::wstring(mBuf); + boost::trim_right(tempOut); + out << tempOut; + } + + return out.str(); +} + +std::wstring stateToString(const state& state) { + switch (state) { + case OK: return L"OK"; + case WARNING: return L"WARNING"; + case CRITICAL: return L"CRITICAL"; + default: return L"UNKNOWN"; + } +}
\ No newline at end of file |