/*
* TheUnhandledExceptionFilter
* Logs an unhandled exception
*/
static LONG CALLBACK TheUnhandledExceptionFilter(LPEXCEPTION_POINTERS pException)
{
// Logs exception into buffer and calls the callback
auto Log = [pException](char* buffer, size_t size, bool reg, bool stack, bool trace)
{
if(LogException(buffer, size, (LPEXCEPTION_POINTERS)pException, reg, stack, trace))
ExceptionCallback(buffer);
};
// Try to make a very descriptive exception, for that we need to malloc a huge buffer...
if(auto buffer = (char*) malloc(max_logsize_ever))
{
Log(buffer, max_logsize_ever, true, true, true);
free(buffer);
}
else
{
// Use a static buffer, no need for any allocation
static const auto size = max_logsize_basic + max_logsize_regs + max_logsize_stackdump;
static char static_buf[size];
static_assert(size <= max_static_buffer, "Static buffer is too big");
Log(buffer = static_buf, sizeof(static_buf), true, true, false);
}
// Continue exception propagation
return (PrevFilter? PrevFilter(pException) : EXCEPTION_CONTINUE_SEARCH); // I'm not really sure about this return
}
/**
* \fn void CheckLogDelete(Log *log)
* \brief Check to see if logs need to be removed due to old age
* \param log A log class variable
*/
void CheckLogDelete(Log *log)
{
Flux::string dir = binary_dir + "/logs/";
if(!TextFile::IsDirectory(dir))
{
Log(LOG_TERMINAL) << "Directory " << dir << " does not exist, making new directory.";
#ifndef _WIN32
if(mkdir(dir.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH) != 0)
throw LogException("Failed to create directory " + dir + ": " + Flux::string(strerror(errno)));
#else
if(!CreateDirectory(dir.c_str(), NULL))
throw LogException("Failed to create directory " + dir + ": " + Flux::string(strerror(errno)));
#endif
}
Flux::vector files = TextFile::DirectoryListing(dir);
if(log)
files.push_back(log->filename);
if(files.empty())
Log(LOG_TERMINAL) << "No Logs!";
for(Flux::vector::iterator it = files.begin(); it != files.end(); ++it)
{
Flux::string file = dir + (*it);
if(TextFile::IsFile(file))
{
Flux::string t = file.isolate('-', ' ').strip('-');
int timestamp = static_cast<int>(t);
if(timestamp > (time(NULL) - 86400 * Config->LogAge) && timestamp != starttime)
{
Delete(file.c_str());
Log(LOG_DEBUG) << "Deleted old logfile " << file;
}
}
}
}
void GLogicEngineCPP::HandleClockTick(DWORD64 clock_msec)
{
if (logic_base)
{
try
{
logic_base->on_clock_tick(clock_msec);
}
catch (std::exception & e)
{
LogException("{%s} HandleClockTick()", e.what());
}
catch (...)
{
LogException("HandleClockTick()");
}
}
}
void AdjacencyMatrix::removeEdge(Edge* edge)
{
Node* n1 = edge->getNode1();
Node* n2 = edge->getNode2();
if(!edge || !n1 || !n2)
throw LogException("invalid edge",__LINE__,__FILE__);
if(!getEdge(n1,n2))
throw LogException("edge is not in the matrix",__LINE__,__FILE__); //the edge is not in the matrix
int idx1 = getNodeIndex(n1);
int idx2 = getNodeIndex(n2);
if(idx1==-1 || idx2==-1)
throw LogException("an extremity is not in the matrix",__LINE__,__FILE__); //a node does not exist
this->SquareMatrix<Edge*>::set(idx1, idx2, nullptr);
if(!edge->isOriented())
this->SquareMatrix<Edge*>::set(idx2, idx1, nullptr);
}
void GLogicEngineCPP::HandleHTTPResponse(const char * location_ID, INT32 http_request_id, INT32 http_response_code, const std::string & http_response)
{
if (logic_base)
{
try
{
logic_base->on_http_response(location_ID, http_request_id, http_response_code, http_response);
}
catch (std::exception & e)
{
LogException("{%s} HandleHTTPResponse(\"%s\")", e.what(), location_ID);
}
catch (...)
{
LogException("HandleHTTPResponse(\"%s\")", location_ID);
}
}
}
void GLogicEngineCPP::HandleReplaceVulgarWords(const char * location_ID, const std::string & text, const std::string & params)
{
if (logic_base)
{
try
{
logic_base->on_replace_vulgar_words(CurrentSTime(), location_ID, text, params);
}
catch (std::exception & e)
{
LogException("{%s} HandleReplaceVulgarWords(\"%s\", \"%s\")", e.what(), location_ID, text.c_str());
}
catch (...)
{
LogException("HandleReplaceVulgarWords(\"%s\", \"%s\")", location_ID, text.c_str());
}
}
}
void GLogicEngineCPP::HandleGetLocationsIdsLike(const char * location_ID, INT32 request_id, const std::set<std::string> & locations_ids)
{
if (logic_base)
{
try
{
logic_base->on_get_locations_ids_like(location_ID, request_id, locations_ids);
}
catch (std::exception & e)
{
LogException("{%s} HandleGetLocationsIdsLike(\"%s\", %d)", e.what(), location_ID, request_id);
}
catch (...)
{
LogException("HandleGetLocationsIdsLike(\"%s\", %d)", location_ID, request_id);
}
}
}
void JniCallbackBase::CheckAndLogJavaException(JNIEnv* env) const
{
if (env->ExceptionCheck())
{
JniLocalReference<jthrowable> throwable(env, env->ExceptionOccurred());
env->ExceptionClear();
LogException(env, *throwable);
}
}
void GLogicEngineCPP::HandlePrintStatistics(strstream & s)
{
if (logic_base)
{
try
{
logic_base->on_print_statistics(s);
}
catch (std::exception & e)
{
LogException("{%s} HandlePrintStatistics()", e.what());
}
catch (...)
{
LogException("HandlePrintStatistics()");
}
}
}
void GLogicEngineCPP::HandleCreateLocationNotification(const char * location_ID, const char * new_location_ID, const char * new_location_data, bool creation_success)
{
if (logic_base)
{
try
{
logic_base->on_create_location(location_ID, new_location_ID, new_location_data, creation_success);
}
catch (std::exception & e)
{
LogException("{%s} HandleCreateLocationNotification(\"%s\", \"%s\")", e.what(), location_ID, new_location_ID);
}
catch (...)
{
LogException("HandleCreateLocationNotification(\"%s\", \"%s\")", location_ID, new_location_ID);
}
}
}
void GLogicEngineCPP::HandleFlushLocationNotification(const char * location_ID, const char * location_data, bool flush_success)
{
if (logic_base)
{
try
{
logic_base->on_flush_location(location_ID, location_data, flush_success);
}
catch (std::exception & e)
{
LogException("{%s} HandleFlushLocationNotification(\"%s\")", e.what(), location_ID);
}
catch (...)
{
LogException("HandleFlushLocationNotification(\"%s\")", location_ID);
}
}
}
void GLogicEngineCPP::HandleInitiateGentleClose()
{
if (logic_base)
{
try
{
logic_base->on_initiate_gentle_close();
}
catch (std::exception & e)
{
LogException("{%s} HandleInitiateGentleClose()", e.what());
}
catch (...)
{
LogException("HandleInitiateGentleClose()");
}
}
}
bool GLogicEngineCPP::HandleLogicMessage(INT32 user_id, const char * location_ID, INT32 access, DWORD64 msg_time, const std::string & command, const std::string & params)
{
try
{
INT32 gamestate_ID = gamestate_ID_from_location_ID(location_ID);
if (gamestate_ID == 0)
{
logic_base->handle_user_location_message(msg_time, user_id, location_ID, command, params);
return true;
}
if (access == EGS_PLAYER)
{
if (logic_base)
{
logic_base->handle_player_message(msg_time, user_id, gamestate_ID, command, params);
}
}
else if (access == EGS_FRIEND)
{
if (logic_base)
{
logic_base->handle_friend_message(msg_time, user_id, gamestate_ID, command, params);
}
}
else
{
if (logic_base)
{
logic_base->handle_stranger_message(msg_time, user_id, gamestate_ID, command, params);
}
}
}
catch (std::exception & e)
{
LogException("{%s} HandleLogicMessage(\"%s\", \"%s\", \"%s\")", e.what(), location_ID, command.c_str(), params.c_str());
}
catch (...)
{
LogException("HandleLogicMessage(\"%s\", \"%s\", \"%s\")", location_ID, command.c_str(), params.c_str());
}
return true;
}
bool GLogicEngineCPP::HandleInitScript(const std::string & config_str)
{
if (logic_base)
{
try
{
return logic_base->on_init_global_config(CurrentSTime(), config_str);
}
catch (std::exception & e)
{
LogException("{%s} HandleInitScript()", e.what());
}
catch (...)
{
LogException("HandleInitScript()");
}
}
return false;
}
bool GLogicEngineCPP::HandleGlobalMessage(const std::string & command, const std::string & params)
{
if (logic_base)
{
try
{
logic_base->handle_global_message(CurrentSTime(), command, params);
}
catch (std::exception & e)
{
LogException("{%s} HandleGlobalMessage(\"%s\", \"%s\")", e.what(), command.c_str(), params.c_str());
}
catch (...)
{
LogException("HandleGlobalMessage(\"%s\", \"%s\")", command.c_str(), params.c_str());
}
}
return true;
}
/*static*/ double MathExt::logb(const double base, const double x)
{
const double tol = MathConstant::EPS;
if (base <= 0.0 || (-tol <= base - 1.0 && base - 1.0 <= tol))
{
//std::ostringstream stream;
//stream << "swl::MathExt::logb() at " << __LINE__ << " in " << __FILE__;
//throw std::invalid_argument(stream.str().c_str());
throw LogException(LogException::L_ERROR, "invalid argument", __FILE__, __LINE__, __FUNCTION__);
}
if (x <= 0.0)
{
//std::ostringstream stream;
//stream << "swl::MathExt::logb() at " << __LINE__ << " in " << __FILE__;
//throw std::domain_error(stream.str().c_str());
throw LogException(LogException::L_ERROR, "domain error", __FILE__, __LINE__, __FUNCTION__);
}
return std::log(x) / std::log(base);
}
// ------------------------------------------------------------------------- //
// * HandleServerException( TDCLServer*, TDCLException* )
// ------------------------------------------------------------------------- //
void
TDCLLogApplication::HandleServerException(
TDCLServer* inServer,
TDCLException* inException )
{
(void) ::fprintf( mLogFile,
"Exception au niveau du serveur [%p]!\n",
inServer );
LogException( inException );
}
/*static*/ unsigned long MathExt::binomial(const unsigned long lhs, const unsigned long rhs)
{
if (lhs < rhs)
{
//std::ostringstream stream;
//stream << "swl::MathExt::binomial() at " << __LINE__ << " in " << __FILE__;
//throw std::invalid_argument(stream.str().c_str());
throw LogException(LogException::L_ERROR, "invalid argument", __FILE__, __LINE__, __FUNCTION__);
}
return factorial(lhs) / (factorial(lhs - rhs) * factorial(rhs));
}
// ------------------------------------------------------------------------- //
// * HandleLinkException( TDCLLink*, TDCLException* )
// ------------------------------------------------------------------------- //
void
TDCLLogApplication::HandleLinkException(
TDCLLink* inLink,
TDCLException* inException )
{
(void) ::fprintf( mLogFile,
"Exception au niveau du lien [%p]!\n",
inLink );
LogException( inException );
}
// ------------------------------------------------------------------------- //
// * HandleCommLayerException( TDCLCommLayer*, TDCLException* )
// ------------------------------------------------------------------------- //
void
TDCLLogApplication::HandleCommLayerException(
TDCLCommLayer* inCommLayer,
TDCLException* inException )
{
(void) ::fprintf( mLogFile,
"Exception au niveau de la couche de communication [%p]!\n",
inCommLayer );
LogException( inException );
}
// combination or binomial
/*static*/ double MathExt::binomial(const double lhs, const double rhs, const double& tol /*= MathConstant::EPS*/)
{
if (lhs < rhs)
{
//std::ostringstream stream;
//stream << "swl::MathExt::binomial() at " << __LINE__ << " in " << __FILE__;
//throw std::invalid_argument(stream.str().c_str());
throw LogException(LogException::L_ERROR, "invalid argument", __FILE__, __LINE__, __FUNCTION__);
}
return factorial(lhs, tol) / (factorial(lhs - rhs, tol) * factorial(rhs, tol));
}
/*static*/ double MathExt::atanh(const double x)
{
if (x <= -1.0 || x >= 1.0)
{
// when x <= -1.0 || x >= 1.0, a solution is a conmplex number
//std::ostringstream stream;
//stream << "swl::MathExt::atanh() at " << __LINE__ << " in " << __FILE__;
//throw std::domain_error(stream.str().c_str());
throw LogException(LogException::L_ERROR, "domain error", __FILE__, __LINE__, __FUNCTION__);
}
return std::log(std::sqrt((1.0 + x) / (1.0 - x)));
}
bool GdiPrintContext::resize(const int x1, const int y1, const int x2, const int y2)
{
/*
if (isActivated()) return false;
drawRegion_ = Region2<int>(x1, y1, x2, y2);
deleteOffScreenBitmap();
return createOffScreen();
*/
//throw std::runtime_error("GdiPrintContext::resize() must not to be called");
throw LogException(LogException::L_ERROR, "this function must not to be called", __FILE__, __LINE__, __FUNCTION__);
}
template <> acl::UserData Unserialize<acl::UserData>(const mongo::BSONObj& obj)
{
try
{
acl::UserData user;
user.id = obj["uid"].Int();
user.name = obj["name"].String();
UnserializeContainer(obj["ip masks"].Array(), user.ipMasks);
user.password = obj["password"].String();
user.salt = obj["salt"].String();
user.flags = obj["flags"].String();
user.primaryGid = obj["primary gid"].Int();
UnserializeContainer(obj["secondary gids"].Array(), user.secondaryGids);
UnserializeContainer(obj["gadmin gids"].Array(), user.gadminGids);
user.creator = obj["creator"].Int();
mongo::BSONElement oid;
obj.getObjectID(oid);
user.created = ToGregDate(oid.OID().asDateT());
user.homeDir = obj["home dir"].String();
user.startUpDir = obj["startup dir"].String();
user.idleTime = obj["idle time"].Int();
if (obj["expires"].type() != mongo::jstNULL)
user.expires.reset(ToGregDate(obj["expires"].Date()));
user.numLogins = obj["num logins"].Int();
user.comment = obj["comment"].String();
user.tagline = obj["tagline"].String();
user.maxDownSpeed = obj["max down speed"].Long();
user.maxUpSpeed = obj["max up speed"].Long();
user.maxSimDown = obj["max sim down"].Int();
user.maxSimUp = obj["max sim up"].Int();
user.loggedIn = obj["logged in"].Int();
if (obj["last login"].type() != mongo::jstNULL)
user.lastLogin.reset(ToPosixTime(obj["last login"].Date()));
UnserializeMap(obj["ratio"].Array(), "section", "value", user.ratio);
UnserializeMap(obj["credits"].Array(), "section", "value", user.credits);
UnserializeMap(obj["weekly allotment"].Array(), "section", "value", user.weeklyAllotment);
return user;
}
catch (const mongo::DBException& e)
{
LogException("Unserialize user", e, obj);
throw e;
}
}
void DebugBreakorAV(int val)
{
if (IsDebuggerPresent())
{
if (val == 0)
__debugbreak();
if (breakOnDebugBreakorAV)
__debugbreak();
}
int exception_code = EXCEPTIONCODE_DebugBreakorAV + val;
// assert((EXCEPTIONCODE_DebugBreakorAV <= exception_code) && (exception_code < EXCEPTIONCODE_DebugBreakorAV_MAX))
LogException(exception_code, "DebugBreak or AV Exception %d", val);
}
void terrama2::core::ProcessLogger::setDataSource(te::da::DataSource* dataSource)
{
isValid_ = false;
dataSource_.reset(dataSource);
try
{
dataSource_->open();
if(!dataSource_->isOpened())
{
throw LogException();
}
}
catch(std::exception& e)
{
QString errMsg = QObject::tr("Could not connect to database");
TERRAMA2_LOG_ERROR() << errMsg << ": " << e.what();
throw LogException() << ErrorDescription(errMsg);
}
isValid_ = true;
}
long long TransfersUser(acl::UserID uid, ::stats::Timeframe timeframe,
const std::string& section, ::stats::Direction direction)
{
mongo::BSONObjBuilder match;
match.append("direction", util::EnumToString(direction));
if (!section.empty())
match.append("section", section);
else
{
mongo::BSONArrayBuilder sections;
for (const auto& kv : cfg::Get().Sections())
sections.append(kv.first);
match.appendElements(BSON("section" << BSON("$nin" << sections.arr())));
}
match.appendElements(Serialize(timeframe));
mongo::BSONObj cmd = BSON("aggregate" << "transfers" << "pipeline" <<
BSON_ARRAY(
BSON("$match" << match.obj()) <<
BSON("$group" <<
BSON("_id" << (uid == -1 ? "" : "$uid") <<
"total" << BSON("$sum" << "$kbytes")
))));
mongo::BSONObj result;
NoErrorConnection conn;
if (conn.RunCommand(cmd, result))
{
try
{
auto elems = result["result"].Array();
if (!elems.empty())
{
return elems[0]["total"].Long();
}
}
catch (const mongo::DBException& e)
{
LogException("Unserialize transfers total", e, result);
}
}
return 0;
}
/*static*/ unsigned long MathExt::factorial(const unsigned long n)
{
unsigned long ulFactorial = 1ul;
if (n == 0ul || n == 1ul) return 1ul;
for (unsigned long k = n; k > 1ul; --k)
{
if (std::numeric_limits<unsigned long>::max() / ulFactorial < k)
{
//std::ostringstream stream;
//stream << "swl::MathExt::factorial() at " << __LINE__ << " in " << __FILE__;
//throw std::overflow_error(stream.str().c_str());
throw LogException(LogException::L_ERROR, "overflow error", __FILE__, __LINE__, __FUNCTION__);
}
ulFactorial *= k;
}
return ulFactorial;
}
/*static*/ double MathExt::factorial(const double n, const double& tol /*= MathConstant::EPS*/)
{
double dFactorial = 1.0;
if ((-tol <= n && n <= tol) || (-tol <= n - 1.0 && n - 1.0 <= tol)) return 1.0;
for (unsigned long k = (unsigned long)round(n); k > 1ul; --k)
{
if (std::numeric_limits<double>::max() / dFactorial < k)
{
//std::ostringstream stream;
//stream << "swl::MathExt::factorial() at " << __LINE__ << " in " << __FILE__;
//throw std::overflow_error(stream.str().c_str());
throw LogException(LogException::L_ERROR, "overflow error", __FILE__, __LINE__, __FUNCTION__);
}
dFactorial *= k;
}
return dFactorial;
}
long long XfertimeCorrection(acl::UserID uid,
long long kBytes,
time_t modTime,
::stats::Direction direction)
{
long long xfertime = -1;
util::Time t(modTime);
auto cmd = BSON("aggregate" << "transfers" << "pipeline" <<
BSON_ARRAY(
BSON("$match" <<
BSON("year" << t.Year() << "month" << t.Month() <<
"week" << t.Week() << "day" << t.Day() <<
"direction" << util::EnumToString(direction))) <<
BSON("$group" <<
BSON("_id" << uid <<
"total kbytes" << BSON("$sum" << "$kbytes") <<
"total xfertime" << BSON("$sum" << "$xfertime")
))));
NoErrorConnection conn;
mongo::BSONObj result;
if (conn.RunCommand(cmd, result))
{
auto elems = result["result"].Array();
if (!elems.empty())
{
try
{
long long totalXfertime = elems[0]["total xfertime"].Long();
if (totalXfertime > 0)
xfertime = std::ceil(static_cast<double>(totalXfertime) / elems[0]["total kbytes"].Long() * kBytes);
else
xfertime = 0;
}
catch (const mongo::DBException& e)
{
LogException("Unserialize upload decr avg speed", e, result);
}
}
}
return xfertime;
}
