void SolverMRP::SolverMRPdata::solveSafetyStock(SolverMRP* solver)
{
OperatorDelete cleanup("sweeper", this);
safety_stock_planning = true;
if (getLogLevel()>0) logger << "Start safety stock replenishment pass " << solver->getConstraints() << endl;
vector< list<Buffer*> > bufs(HasLevel::getNumberOfLevels() + 1);
for (Buffer::iterator buf = Buffer::begin(); buf != Buffer::end(); ++buf)
if (buf->getCluster() == cluster
&& ( buf->getMinimum() || buf->getMinimumCalendar()
|| buf->getType() == *BufferProcure::metadata )
)
bufs[(buf->getLevel()>=0) ? buf->getLevel() : 0].push_back(&*buf);
for (vector< list<Buffer*> >::iterator b_list = bufs.begin(); b_list != bufs.end(); ++b_list)
for (list<Buffer*>::iterator b = b_list->begin(); b != b_list->end(); ++b)
{
state->curBuffer = NULL;
// A quantity of -1 is a flag for the buffer solver to solve safety stock.
state->q_qty = -1.0;
state->q_date = Date::infinitePast;
state->a_cost = 0.0;
state->a_penalty = 0.0;
planningDemand = NULL;
state->curDemand = NULL;
state->motive = *b;
state->curOwnerOpplan = NULL;
// Call the buffer solver
(*b)->solve(*solver, this);
// Check for excess
if ((*b)->getType() != *BufferProcure::metadata)
(*b)->solve(cleanup, this);
CommandManager::commit();
}
if (getLogLevel()>0) logger << "Finished safety stock replenishment pass" << endl;
safety_stock_planning = false;
}
void LoggerPlugin::openFile()
{
if (m_bFilter){
if ((getLogLevel() & L_EVENTS) == 0){
qApp->removeEventFilter(this);
m_bFilter = false;
}
}else{
if (getLogLevel() & L_EVENTS){
qApp->installEventFilter(this);
m_bFilter = true;
}
}
if (m_file){
delete m_file;
m_file = NULL;
}
const char *fname = getFile();
if ((fname == NULL) || (*fname == 0))
return;
m_file = new QFile(QFile::decodeName(fname));
if (!m_file->open(IO_Append | IO_ReadWrite)){
delete m_file;
m_file = NULL;
log(L_WARN, "Can't open %s", fname);
}
}
void *LoggerPlugin::processEvent(Event *e)
{
if (e->type() == EventLog){
LogInfo *li = (LogInfo*)e->param();
if (((li->packet_id == 0) && (li->log_level & getLogLevel())) ||
(li->packet_id && isLogType(li->packet_id))){
string s;
s = make_packet_string(li);
if (m_file){
#ifdef WIN32
s += "\r\n";
#else
s += "\n";
#endif
m_file->writeBlock(s.c_str(), s.length());
}
#ifdef QT_DLL
for (char *p = (char*)(s.c_str()); *p; ){
char *r = strchr(p, '\n');
if (r) *r = 0;
qWarning("%s", p);
if (r == NULL) break;
p = r + 1;
}
#else
fprintf(stderr, "%s", s.c_str());
fprintf(stderr, "\n");
#endif
}
}
return NULL;
}
DECLARE_EXPORT void SolverMRP::scanExcess(CommandList* l)
{
// Loop over all newly created operationplans found in the command stack
for(CommandList::iterator cmd = l->begin(); cmd != l->end(); ++cmd)
{
CommandCreateOperationPlan* createcmd = dynamic_cast<CommandCreateOperationPlan*>(&*cmd);
if (!createcmd)
{
// If the command is a list: recursively call this function
if (dynamic_cast<CommandList*>(&*cmd))
scanExcess(dynamic_cast<CommandList*>(&*cmd));
//else: Not a command creating an operationplan: move on
}
else
{
// Detect excess operationplans and undo them
if (createcmd->getOperationPlan() && createcmd->getOperationPlan()->isExcess())
{
if (getLogLevel()>1)
logger << "Denying creation of redundant operationplan "
<< createcmd->getOperationPlan()->getOperation() << " "
<< createcmd->getOperationPlan()->getDates() << " "
<< createcmd->getOperationPlan()->getQuantity() << endl;
createcmd->rollback();
}
}
}
}
void HTMLStyleElementImp::handleMutation(EventListenerImp* listener, events::Event event)
{
// TODO: update type, media, and scoped. Then check type.
events::MutationEvent mutation(interface_cast<events::MutationEvent>(event));
DocumentImp* document = getOwnerDocumentImp();
if (!document)
return;
if (mutation.getType() == u"DOMNodeRemoved" && event.getTarget().self() == this)
styleSheet = 0;
else {
std::u16string content;
for (Node node = getFirstChild(); node; node = node.getNextSibling()) {
if (TextImp* text = dynamic_cast<TextImp*>(node.self())) // TODO better to avoid imp call?
content += text->getData();
}
CSSParser parser;
styleSheet = parser.parse(document, content);
if (auto imp = dynamic_cast<CSSStyleSheetImp*>(styleSheet.self())) {
imp->setOwnerNode(this);
if (4 <= getLogLevel())
dumpStyleSheet(std::cerr, imp);
}
}
if (WindowImp* view = document->getDefaultWindow())
view->setFlags(Box::NEED_SELECTOR_REMATCHING);
document->resetStyleSheets();
}
void *LoggerPlugin::processEvent(Event *e)
{
if (e->type() == EventLog){
LogInfo *li = (LogInfo*)e->param();
if (((li->packet_id == 0) && (li->log_level & getLogLevel())) ||
(li->packet_id && ((getLogLevel() & L_PACKETS) || isLogType(li->packet_id)))){
string s;
s = make_packet_string(li);
if (m_file){
#ifdef WIN32
s += "\r\n";
#else
s += "\n";
#endif
m_file->writeBlock(s.c_str(), s.length());
}
#ifdef QT_DLL
for (char *p = (char*)(s.c_str()); *p; ){
char *r = strchr(p, '\n');
if (r) *r = 0;
if (strlen(p) > 256){
string s = p;
while (!s.empty()){
string l;
if (s.length() < 256){
l = s;
s = "";
}else{
l = s.substr(0, 256);
s = s.substr(256);
}
qWarning("%s", l.c_str());
}
}else{
qWarning("%s", p);
}
if (r == NULL) break;
p = r + 1;
}
#else
fprintf(stderr, "%s", s.c_str());
fprintf(stderr, "\n");
#endif
}
}
return NULL;
}
DECLARE_EXPORT PyObject* Solver::getattro(const Attribute& attr)
{
if (attr.isA(Tags::tag_name))
return PythonObject(getName());
if (attr.isA(Tags::tag_loglevel))
return PythonObject(getLogLevel());
return NULL;
}
DECLARE_EXPORT void SolverMRP::solve(void *v)
{
// Count how many clusters we have to plan
int cl = HasLevel::getNumberOfClusters() + 1;
// Categorize all demands in their cluster
demands_per_cluster.resize(cl);
for (Demand::iterator i = Demand::begin(); i != Demand::end(); ++i)
demands_per_cluster[i->getCluster()].push_back(&*i);
// Delete of operationplans of the affected clusters
// This deletion is not multi-threaded... But on the other hand we need to
// loop through the operations only once (rather than as many times as there
// are clusters)
if (getErasePreviousFirst())
{
if (getLogLevel()>0) logger << "Deleting previous plan" << endl;
for (Operation::iterator e=Operation::begin(); e!=Operation::end(); ++e)
e->deleteOperationPlans();
}
// Solve in parallel threads.
// When not solving in silent and autocommit mode, we only use a single
// solver thread.
// Otherwise we use as many worker threads as processor cores.
ThreadGroup threads;
if (getLogLevel()>0 || !getAutocommit())
threads.setMaxParallel(1);
// Register all clusters to be solved
for (int j = 0; j < cl; ++j)
threads.add(
SolverMRPdata::runme,
new SolverMRPdata(this, j, &(demands_per_cluster[j]))
);
// Run the planning command threads and wait for them to exit
threads.execute();
// @todo Check the resource setups that were broken - needs to be removed
for (Resource::iterator gres = Resource::begin(); gres != Resource::end(); ++gres)
if (gres->getSetupMatrix()) gres->updateSetups();
}
void vl::LoggerT<T>::add_prelude(std::string& out, LogLevel level)
{
if (!is_set(pimpl_->options, notimestamp))
safe_sprintf(out, "{0} ", createTimestamp());
if (!is_set(pimpl_->options, nologgername))
safe_sprintf(out, "[{0}] ", pimpl_->name);
if (!is_set(pimpl_->options, nothreadid))
safe_sprintf(out, "0x{0:x} ", std::this_thread::get_id());
if (!is_set(pimpl_->options, nologlevel))
safe_sprintf(out, "<{0}> ", getLogLevel(level));
}
void LoggerPlugin::openFile()
{
if (m_bFilter){
if ((getLogLevel() & L_EVENTS) == 0){
qApp->removeEventFilter(this);
m_bFilter = false;
}
}else{
if (getLogLevel() & L_EVENTS){
qApp->installEventFilter(this);
m_bFilter = true;
}
}
if (m_file){
delete m_file;
m_file = NULL;
}
const char *fname = getFile();
if ((fname == NULL) || (*fname == 0))
return;
// This si because sim crashes when a logfile is larger than 100MB ...
QFileInfo fileInfo(QFile::decodeName(fname));
if (fileInfo.size() > 1024 * 1024 * 50) { // 50MB ...
QString desiredFileName = fileInfo.fileName() + ".old";
#ifdef WIN32
fileInfo.dir().remove(desiredFileName);
#endif
if (!fileInfo.dir().rename(fileInfo.fileName(), desiredFileName)) {
// won't work --> simply delete...
fileInfo.dir().remove(fileInfo.fileName());
}
}
// now open file
m_file = new QFile(QFile::decodeName(fname));
if (!m_file->open(QIODevice::Append | QIODevice::ReadWrite)){
delete m_file;
m_file = NULL;
log(L_WARN, "Can't open %s", fname);
}
}
//! The constructor
itsEOInterface( eoPop< EOType > * _pop,
eoSelectOne<EOType> * _select,
eoQuadOp<EOType> * _cross, float _cross_rate,
eoMonOp<EOType> * _mutate, float _mutate_rate
)
: itsMetaheuristic(),
eoPopulation( _pop ),
eoSelect( _select ),
eoCross( _cross ), eoCrossRate( _cross_rate),
eoMutate( _mutate ), eoMutateRate( _mutate_rate )
{
clog << "itsEOInterface::itsEOInterface - getLogLevel:" << getLogLevel() << " - logLevel:" /* << logLevel */<< endl;
clog << "itsEOInterface::itsEOInterface - getLogKeys().size:" << getLogKeys().size() << " - logKeys.size:" /*<< logKeys.size()*/ << endl;
}
/**
* Throw a Java NullPointerException. Used when input parameters
* which should not be null are that.
*
* @param message the name of the parameter that is null
*/
void JNIUtil::throwNullPointerException(const char *message)
{
if (getLogLevel() >= errorLog)
logMessage("NullPointerException thrown");
JNIEnv *env = getEnv();
jclass clazz = env->FindClass("java/lang/NullPointerException");
if (isJavaExceptionThrown())
return;
env->ThrowNew(clazz, message);
setExceptionThrown();
env->DeleteLocalRef(clazz);
}
CRFileLogger(const char * fname, bool _autoFlush)
: f(fopen(fname, "wt")), autoClose(true), autoFlush(_autoFlush)
{
static unsigned char utf8sign[] = { 0xEF, 0xBB, 0xBF };
static const char * log_level_names[] = {
"FATAL",
"ERROR",
"WARN",
"INFO",
"DEBUG",
"TRACE",
};
fwrite(utf8sign, 3, 1, f);
info("Started logging. Level=%s", log_level_names[getLogLevel()]);
}
void PostgreSQLDatabase::noticeProcessor( void* this_void, const char * message)
{
PostgreSQLDatabase* this_ = (PostgreSQLDatabase*)this_void;
std::size_t ii=0;
for (; message[ii] && message[ii] != ':'; ++ii);
if (message[ii])
{
_Wolframe::log::LogLevel::Level lv = getLogLevel( std::string( message, ii));
if (lv != log::LogLevel::LOGLEVEL_UNDEFINED)
{
_Wolframe::log::Logger( _Wolframe::log::LogBackend::instance() ).Get( lv) << "PostgreSQL database '" << ((this_)?this_->ID():"") << "': " << (message + ii + 1);
return;
}
}
LOG_ERROR << "Unknown log message type from PostgreSQL database '" << ((this_)?this_->ID():"") << "': " << message;
}
struct execResult_t execGetReturnCode(const char **aArguments) {
struct execResult_t execResult;
char **argcopy = argCopy(aArguments);
pid_t pid;
int status;
memset(&execResult, 0, sizeof(execResult));
execResult.success = true;
pid = fork();
if (pid == -1) {
perror("fork");
execResult.success = false;
return execResult;
}
if (pid > 0) {
char commandLineBuffer[256];
convertCommandLine(commandLineBuffer, sizeof(commandLineBuffer), aArguments);
logmsg(LLVL_DEBUG, "Subprocess [PID %d]: Will execute '%s'\n", pid, commandLineBuffer);
}
if (pid == 0) {
/* Child */
if (getLogLevel() < LLVL_DEBUG) {
/* Shut up the child if user did not request debug output */
close(1);
close(2);
}
execvp(aArguments[0], argcopy);
perror("execvp");
logmsg(LLVL_ERROR, "Execution of %s in forked child process failed at execvp: %s\n", aArguments[0], strerror(errno));
/* Exec failed, terminate chExec failed, terminate child process
* (parent will catch this as the return code) */
exit(EXIT_FAILURE);
}
if (waitpid(pid, &status, 0) == (pid_t)-1) {
perror("waitpid");
execResult.success = false;
return execResult;
}
freeArgCopy(argcopy);
execResult.returnCode = WEXITSTATUS(status);
logmsg(LLVL_DEBUG, "Subprocess [PID %d]: %s returned %d\n", pid, aArguments[0], execResult.returnCode);
return execResult;
}
void JNIUtil::raiseThrowable(const char *name, const char *message)
{
if (getLogLevel() >= errorLog)
{
JNICriticalSection cs(*g_logMutex);
g_logStream << "Throwable raised <" << message << ">" << std::endl;
}
JNIEnv *env = getEnv();
jclass clazz = env->FindClass(name);
if (isJavaExceptionThrown())
return;
env->ThrowNew(clazz, message);
setExceptionThrown();
env->DeleteLocalRef(clazz);
}
//##############################################################################
//# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
//##############################################################################
//##############################################################################
//# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
//##############################################################################
void xLogger::publishRecord(xLogRecord& record)
{
synchronizeStart();
if(record.getLevel() <= getLogLevel())
{
xIterator* iter = m_handlers.iterator();
while(iter->hasNext())
{
xLogHandler* lh = dynamic_cast<xLogHandler*>(&(iter->next()));
if(lh != NULL)
lh->publish(record);
}
delete iter;
}
synchronizeEnd();
}
void
JNIUtil::throwNativeException(const char *className, const char *msg,
const char *source, int aprErr)
{
JNIEnv *env = getEnv();
jclass clazz = env->FindClass(className);
// Create a local frame for our references
env->PushLocalFrame(LOCAL_FRAME_SIZE);
if (JNIUtil::isJavaExceptionThrown())
return;
if (getLogLevel() >= exceptionLog)
{
JNICriticalSection cs(*g_logMutex);
g_logStream << "Subversion JavaHL exception thrown, message:<";
g_logStream << msg << ">";
if (source)
g_logStream << " source:<" << source << ">";
if (aprErr != -1)
g_logStream << " apr-err:<" << aprErr << ">";
g_logStream << std::endl;
}
if (isJavaExceptionThrown())
POP_AND_RETURN_NOTHING();
jstring jmessage = makeJString(msg);
if (isJavaExceptionThrown())
POP_AND_RETURN_NOTHING();
jstring jsource = makeJString(source);
if (isJavaExceptionThrown())
POP_AND_RETURN_NOTHING();
jmethodID mid = env->GetMethodID(clazz, "<init>",
"(Ljava/lang/String;Ljava/lang/String;I)V");
if (isJavaExceptionThrown())
POP_AND_RETURN_NOTHING();
jobject nativeException = env->NewObject(clazz, mid, jmessage, jsource,
static_cast<jint>(aprErr));
if (isJavaExceptionThrown())
POP_AND_RETURN_NOTHING();
env->Throw(static_cast<jthrowable>(env->PopLocalFrame(nativeException)));
}
void HttpServerConfigFacade::reloadConfiguration(std::string const &filePath) {
rapidxml::file<> xmlFile(filePath.c_str());
rapidxml::xml_document<> doc;
doc.parse<0>(xmlFile.data());
// TODO: reload some other configuration?
auto httpServer = doc.first_node("HttpServer");
std::map<std::string, std::string> loggerSettings;
auto logger = (*httpServer).first_node("Logger");
if (logger != nullptr) {
readXmlSettings(logger, loggerSettings);
if (loggerSettings.empty()) {
// TDOO: throw an exception?
return;
}
auto level = loggerSettings["Level"];
RAPID_LOG_TRACE() << "New logging level: " << level;
rapid::logging::setLogLevel(getLogLevel(level));
}
}
void OperatorDelete::solve(const Resource* r, void* v)
{
if (getLogLevel()>0)
logger << "Scanning " << r << " for excess" << endl;
// Loop over all operationplans on the resource
for (Resource::loadplanlist::const_iterator i = r->getLoadPlans().begin();
i != r->getLoadPlans().end(); ++i)
{
if (i->getEventType() == 1)
// Add all buffers into which material is produced to the stack
pushBuffers(static_cast<const LoadPlan*>(&*i)->getOperationPlan(), false);
}
// Process all buffers found, and their upstream colleagues
while(!buffersToScan.empty())
{
Buffer* curbuf = buffersToScan.back();
buffersToScan.pop_back();
solve(curbuf);
}
}
void OperatorDelete::solve(const Demand* d, void* v)
{
if (getLogLevel()>1)
logger << "Scanning " << d << " for excess" << endl;
// Delete all delivery operationplans.
// Note that an extra loop is used to assure that our iterator doesn't get
// invalidated during the deletion.
while (true)
{
// Find a candidate operationplan to delete
OperationPlan *candidate = nullptr;
const Demand::OperationPlanList& deli = d->getDelivery();
for (Demand::OperationPlanList::const_iterator i = deli.begin(); i != deli.end(); ++i)
if (!(*i)->getLocked())
{
candidate = *i;
break;
}
if (!candidate) break;
// Push the buffer on the stack in which the deletion creates excess inventory
pushBuffers(candidate, true);
// Delete only the delivery, immediately or through a delete command
if (cmds)
cmds->add(new CommandDeleteOperationPlan(candidate));
else
delete candidate;
}
// Propagate to all upstream buffers
while(!buffersToScan.empty())
{
Buffer* curbuf = buffersToScan.back();
buffersToScan.pop_back();
solve(curbuf);
}
}
//##############################################################################
//# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
//##############################################################################
void xLogHandlerFile::publish(xLogRecord& record)
{
if(record.getLevel() <= getLogLevel())
m_out->write(getFormatter().format(record));
}
S3Params InitConfig(const string& urlWithOptions) {
#ifdef S3_STANDALONE
s3ext_segid = 0;
s3ext_segnum = 1;
#else
s3ext_segid = GpIdentity.segindex;
s3ext_segnum = GpIdentity.numsegments;
#endif
if (s3ext_segid == -1 && s3ext_segnum > 0) {
s3ext_segid = 0;
s3ext_segnum = 1;
}
string sourceUrl = TruncateOptions(urlWithOptions);
S3_CHECK_OR_DIE(!sourceUrl.empty(), S3RuntimeError, "URL not found from location string");
string configPath = GetOptS3(urlWithOptions, "config");
if (configPath.empty()) {
S3WARN("The 'config' parameter is not provided, use default value 's3/s3.conf'.");
configPath = "s3/s3.conf";
}
string configSection = GetOptS3(urlWithOptions, "section");
if (configSection.empty()) {
configSection = "default";
}
// region could be empty
string urlRegion = GetOptS3(urlWithOptions, "region");
// read configurations from file
Config s3Cfg(configPath);
S3_CHECK_OR_DIE(s3Cfg.Handle() != NULL, S3RuntimeError,
"Failed to parse config file '" + configPath + "', or it doesn't exist");
S3_CHECK_OR_DIE(s3Cfg.SectionExist(configSection), S3ConfigError,
"Selected section '" + configSection +
"' does not exist, please check your configuration file",
configSection);
bool useHttps = s3Cfg.GetBool(configSection, "encryption", "true");
bool verifyCert = s3Cfg.GetBool(configSection, "verifycert", "true");
string version = s3Cfg.Get(configSection, "version", "");
S3Params params(sourceUrl, useHttps, version, urlRegion);
string content = s3Cfg.Get(configSection, "loglevel", "WARNING");
s3ext_loglevel = getLogLevel(content.c_str());
content = s3Cfg.Get(configSection, "logtype", "INTERNAL");
s3ext_logtype = getLogType(content.c_str());
params.setDebugCurl(s3Cfg.GetBool(configSection, "debug_curl", "false"));
params.setCred(s3Cfg.Get(configSection, "accessid", ""), s3Cfg.Get(configSection, "secret", ""),
s3Cfg.Get(configSection, "token", ""));
s3ext_logserverhost = s3Cfg.Get(configSection, "logserverhost", "127.0.0.1");
s3ext_logserverport = s3Cfg.SafeScan("logserverport", configSection, 1111, 1, 65535);
int64_t numOfChunks = s3Cfg.SafeScan("threadnum", configSection, 4, 1, 8);
params.setNumOfChunks(numOfChunks);
int64_t chunkSize = s3Cfg.SafeScan("chunksize", configSection, 64 * 1024 * 1024,
8 * 1024 * 1024, 128 * 1024 * 1024);
params.setChunkSize(chunkSize);
int64_t lowSpeedLimit = s3Cfg.SafeScan("low_speed_limit", configSection, 10240, 0, INT_MAX);
params.setLowSpeedLimit(lowSpeedLimit);
int64_t lowSpeedTime = s3Cfg.SafeScan("low_speed_time", configSection, 60, 0, INT_MAX);
params.setLowSpeedTime(lowSpeedTime);
params.setVerifyCert(verifyCert);
CheckEssentialConfig(params);
return params;
}
int main(int argc, char* argv[]) {
try {
parseArgs(argc, argv);
std::vector<std::string*> queries;
std::string connectStr=qsOptionValues["connectStr"];
std::string schema=qsOptionValues["schema"];
std::string queryList=qsOptionValues["query"];
std::string planList=qsOptionValues["plan"];
std::string api=qsOptionValues["api"];
std::string type_str=qsOptionValues["type"];
std::string logLevel=qsOptionValues["logLevel"];
std::string testCancel=qsOptionValues["testCancel"];
Drill::QueryType type;
if(!validate(type_str, queryList, planList)){
exit(1);
}
Drill::logLevel_t l=getLogLevel(logLevel.c_str());
std::vector<std::string> queryInputs;
if(type_str=="sql" ){
readQueries(queryList, queryInputs);
type=Drill::SQL;
}else if(type_str=="physical" ){
readPlans(planList, queryInputs);
type=Drill::PHYSICAL;
}else if(type_str == "logical"){
readPlans(planList, queryInputs);
type=Drill::LOGICAL;
}else{
readQueries(queryList, queryInputs);
type=Drill::SQL;
}
bTestCancel = !strcmp(testCancel.c_str(), "true")?true:false;
std::vector<std::string>::iterator queryInpIter;
std::vector<Drill::RecordIterator*> recordIterators;
std::vector<Drill::RecordIterator*>::iterator recordIterIter;
std::vector<Drill::QueryHandle_t*> queryHandles;
std::vector<Drill::QueryHandle_t*>::iterator queryHandleIter;
Drill::DrillClient client;
// To log to file
//DrillClient::initLogging("/var/log/drill/", l);
// To log to stderr
Drill::DrillClient::initLogging(NULL, l);
Drill::DrillClientConfig::setBufferLimit(2*1024*1024); // 2MB. Allows us to hold at least two record batches.
if(client.connect(connectStr.c_str(), schema.c_str())!=Drill::CONN_SUCCESS){
std::cerr<< "Failed to connect with error: "<< client.getError() << " (Using:"<<connectStr<<")"<<std::endl;
return -1;
}
std::cout<< "Connected!\n" << std::endl;
if(api=="sync"){
Drill::DrillClientError* err=NULL;
Drill::status_t ret;
for(queryInpIter = queryInputs.begin(); queryInpIter != queryInputs.end(); queryInpIter++) {
Drill::RecordIterator* pRecIter = client.submitQuery(type, *queryInpIter, err);
if(pRecIter!=NULL){
recordIterators.push_back(pRecIter);
}
}
size_t row=0;
for(recordIterIter = recordIterators.begin(); recordIterIter != recordIterators.end(); recordIterIter++) {
// get fields.
row=0;
Drill::RecordIterator* pRecIter=*recordIterIter;
Drill::FieldDefPtr fields= pRecIter->getColDefs();
while((ret=pRecIter->next()), ret==Drill::QRY_SUCCESS || ret==Drill::QRY_SUCCESS_WITH_INFO){
fields = pRecIter->getColDefs();
row++;
if( (ret==Drill::QRY_SUCCESS_WITH_INFO && pRecIter->hasSchemaChanged() )|| ( row%100==1)){
for(size_t i=0; i<fields->size(); i++){
std::string name= fields->at(i)->getName();
printf("%s\t", name.c_str());
}
printf("\n");
}
printf("ROW: %ld\t", row);
for(size_t i=0; i<fields->size(); i++){
void* pBuf; size_t sz;
pRecIter->getCol(i, &pBuf, &sz);
print(fields->at(i), pBuf, sz);
}
printf("\n");
if(bTestCancel && row%100==1){
pRecIter->cancel();
printf("Application canceled the query.\n");
}
}
if(ret!=Drill::QRY_NO_MORE_DATA && ret!=Drill::QRY_CANCEL){
std::cerr<< pRecIter->getError() << std::endl;
}
client.freeQueryIterator(&pRecIter);
}
}else{
for(queryInpIter = queryInputs.begin(); queryInpIter != queryInputs.end(); queryInpIter++) {
Drill::QueryHandle_t* qryHandle = new Drill::QueryHandle_t;
client.submitQuery(type, *queryInpIter, QueryResultsListener, NULL, qryHandle);
client.registerSchemaChangeListener(qryHandle, SchemaListener);
queryHandles.push_back(qryHandle);
}
client.waitForResults();
for(queryHandleIter = queryHandles.begin(); queryHandleIter != queryHandles.end(); queryHandleIter++) {
client.freeQueryResources(*queryHandleIter);
delete *queryHandleIter;
}
}
client.close();
} catch (std::exception& e) {
std::cerr << e.what() << std::endl;
}
return 0;
}
void WindowProxy::BackgroundTask::operator()()
{
if (!window)
return;
unsigned command;
while (!((command = sleep()) & Abort)) {
try {
if (!window->getWindowPtr()) {
state = Init;
continue;
}
//
// Restart
//
if (command & Restart) {
deleteView();
state = Init;
}
// A binding document does not need a view.
if (window->isBindingDocumentWindow()) {
state = Done;
continue;
}
//
// Cascade
//
if (!view || (command & Cascade)) {
state = Cascading;
recordTime("%*sselector matching begin", window->windowDepth * 2, "");
if (!view)
view = new(std::nothrow) ViewCSSImp(window->getWindowPtr());
if (view) {
view->constructComputedStyles();
state = Cascaded;
} else
state = Init;
recordTime("%*sselector matching end", window->windowDepth * 2, "");
continue;
}
//
// Layout
//
if (command & Layout) {
state = Layouting;
view->setSize(window->width, window->height); // TODO: sync with mainloop
recordTime("%*sstyle recalculation begin", window->windowDepth * 2, "");
view->calculateComputedStyles();
recordTime("%*sstyle recalculation end", window->windowDepth * 2, "");
recordTime("%*sreflow begin", window->windowDepth * 2, "");
view->layOut();
recordTime("%*sreflow end", window->windowDepth * 2, "");
// Even though every view flag should have been cleared now,
// check them here and clear all of them after dumping the tree.
if (view->gatherFlags() & ~Box::NEED_REPAINT) {
std::cerr << "warning: reflow flags are not fully cleared:\n";
int level = getLogLevel();
if (level < 3)
setLogLevel(3);
view->dump();
setLogLevel(level);
view->clearFlags();
}
view->setFlags(Box::NEED_REPAINT);
}
state = Done;
} catch (const std::exception& e) {
std::cerr << "WindowProxy::BackgroundTask: " << e.what() << "\n";
throw;
// TODO: Recover from exceptions
}
}
}
void setLogLevel(LogLevel logLevel)
{
getLogLevel() = logLevel;
}
Ufora::ScopedLoggingHandles& scopedLoggingHandlesSingleton()
{
static Ufora::ScopedLoggingHandles result(&getLogLevel());
return result;
}
int main(int argc, char* argv[]) {
try {
parseArgs(argc, argv);
std::vector<std::string*> queries;
std::string connectStr=qsOptionValues["connectStr"];
std::string schema=qsOptionValues["schema"];
std::string queryList=qsOptionValues["query"];
std::string planList=qsOptionValues["plan"];
std::string api=qsOptionValues["api"];
std::string type_str=qsOptionValues["type"];
std::string logLevel=qsOptionValues["logLevel"];
std::string testCancel=qsOptionValues["testCancel"];
std::string syncSend=qsOptionValues["syncSend"];
std::string hshakeTimeout=qsOptionValues["hshakeTimeout"];
std::string queryTimeout=qsOptionValues["queryTimeout"];
std::string heartbeatFrequency=qsOptionValues["heartbeatFrequency"];
std::string user=qsOptionValues["user"];
std::string password=qsOptionValues["password"];
std::string saslPluginPath=qsOptionValues["saslPluginPath"];
std::string sasl_encrypt=qsOptionValues["sasl_encrypt"];
std::string serviceHost=qsOptionValues["service_host"];
std::string serviceName=qsOptionValues["service_name"];
std::string auth=qsOptionValues["auth"];
std::string enableSSL=qsOptionValues["enableSSL"];
std::string tlsProtocol=qsOptionValues["TLSProtocol"];
std::string certFilePath=qsOptionValues["certFilePath"];
std::string disableHostnameVerification=qsOptionValues["disableHostnameVerification"];
std::string disableCertVerification=qsOptionValues["disableCertVerification"];
std::string useSystemTrustStore = qsOptionValues["useSystemTrustStore"];
Drill::QueryType type;
if(!validate(type_str, queryList, planList)){
exit(1);
}
Drill::logLevel_t l=getLogLevel(logLevel.c_str());
std::vector<std::string> queryInputs;
if(type_str=="sql" ){
readQueries(queryList, queryInputs);
type=Drill::SQL;
}else if(type_str=="physical" ){
readPlans(planList, queryInputs);
type=Drill::PHYSICAL;
}else if(type_str == "logical"){
readPlans(planList, queryInputs);
type=Drill::LOGICAL;
}else{
readQueries(queryList, queryInputs);
type=Drill::SQL;
}
bTestCancel = !strcmp(testCancel.c_str(), "true")?true:false;
bSyncSend = !strcmp(syncSend.c_str(), "true")?true:false;
std::vector<std::string>::iterator queryInpIter;
std::vector<Drill::RecordIterator*> recordIterators;
std::vector<Drill::RecordIterator*>::iterator recordIterIter;
std::vector<Drill::QueryHandle_t> queryHandles;
std::vector<Drill::QueryHandle_t>::iterator queryHandleIter;
Drill::DrillClient client;
#if defined _WIN32 || defined _WIN64
TCHAR tempPath[MAX_PATH];
GetTempPath(MAX_PATH, tempPath);
char logpathPrefix[MAX_PATH + 128];
strcpy(logpathPrefix,tempPath);
strcat(logpathPrefix, "\\drillclient");
#else
const char* logpathPrefix = "/var/log/drill/drillclient";
#endif
// To log to file
Drill::DrillClient::initLogging(logpathPrefix, l);
// To log to stderr
//Drill::DrillClient::initLogging(NULL, l);
int nQueries=queryInputs.size();
Drill::DrillClientConfig::setBufferLimit(nQueries*2*1024*1024); // 2MB per query. The size of a record batch may vary, but is unlikely to exceed the 256 MB which is the default.
if(!hshakeTimeout.empty()){
Drill::DrillClientConfig::setHandshakeTimeout(atoi(hshakeTimeout.c_str()));
}
if (!queryTimeout.empty()){
Drill::DrillClientConfig::setQueryTimeout(atoi(queryTimeout.c_str()));
}
if(!heartbeatFrequency.empty()) {
Drill::DrillClientConfig::setHeartbeatFrequency(atoi(heartbeatFrequency.c_str()));
}
if (!saslPluginPath.empty()){
Drill::DrillClientConfig::setSaslPluginPath(saslPluginPath.c_str());
}
Drill::DrillUserProperties props;
if(schema.length()>0){
props.setProperty(USERPROP_SCHEMA, schema);
}
if(user.length()>0){
props.setProperty(USERPROP_USERNAME, user);
}
if(password.length()>0){
props.setProperty(USERPROP_PASSWORD, password);
}
if(sasl_encrypt.length()>0){
props.setProperty(USERPROP_SASL_ENCRYPT, sasl_encrypt);
}
if(serviceHost.length()>0){
props.setProperty(USERPROP_SERVICE_HOST, serviceHost);
}
if(serviceName.length()>0){
props.setProperty(USERPROP_SERVICE_NAME, serviceName);
}
if(auth.length()>0){
props.setProperty(USERPROP_AUTH_MECHANISM, auth);
}
if(enableSSL.length()>0){
props.setProperty(USERPROP_USESSL, enableSSL);
if (enableSSL == "true" && certFilePath.length() <= 0 && useSystemTrustStore.length() <= 0){
std::cerr<< "SSL is enabled but no certificate or truststore provided. " << std::endl;
return -1;
}
props.setProperty(USERPROP_TLSPROTOCOL, tlsProtocol);
props.setProperty(USERPROP_CERTFILEPATH, certFilePath);
props.setProperty(USERPROP_DISABLE_HOSTVERIFICATION, disableHostnameVerification);
props.setProperty(USERPROP_DISABLE_CERTVERIFICATION, disableCertVerification);
if (useSystemTrustStore.length() > 0){
props.setProperty(USERPROP_USESYSTEMTRUSTSTORE, useSystemTrustStore);
}
}
if(client.connect(connectStr.c_str(), &props)!=Drill::CONN_SUCCESS){
std::cerr<< "Failed to connect with error: "<< client.getError() << " (Using:"<<connectStr<<")"<<std::endl;
return -1;
}
std::cout<< "Connected!\n" << std::endl;
if(api=="meta") {
Drill::Metadata* metadata = client.getMetadata();
if (metadata) {
std::cout << "Connector:" << std::endl;
std::cout << "\tname:" << metadata->getConnectorName() << std::endl;
std::cout << "\tversion:" << metadata->getConnectorVersion() << std::endl;
std::cout << std::endl;
std::cout << "Server:" << std::endl;
std::cout << "\tname:" << metadata->getServerName() << std::endl;
std::cout << "\tversion:" << metadata->getServerVersion() << std::endl;
std::cout << std::endl;
std::cout << "Metadata:" << std::endl;
std::cout << "\tall tables are selectable: " << metadata->areAllTableSelectable() << std::endl;
std::cout << "\tcatalog separator: " << metadata->getCatalogSeparator() << std::endl;
std::cout << "\tcatalog term: " << metadata->getCatalogTerm() << std::endl;
std::cout << "\tCOLLATE support: " << metadata->getCollateSupport() << std::endl;
std::cout << "\tcorrelation names: " << metadata->getCorrelationNames() << std::endl;
std::cout << "\tdate time functions: " << boost::algorithm::join(metadata->getDateTimeFunctions(), ", ") << std::endl;
std::cout << "\tdate time literals support: " << metadata->getDateTimeLiteralsSupport() << std::endl;
std::cout << "\tGROUP BY support: " << metadata->getGroupBySupport() << std::endl;
std::cout << "\tidentifier case: " << metadata->getIdentifierCase() << std::endl;
std::cout << "\tidentifier quote string: " << metadata->getIdentifierQuoteString() << std::endl;
std::cout << "\tmax binary literal length: " << metadata->getMaxBinaryLiteralLength() << std::endl;
std::cout << "\tmax catalog name length: " << metadata->getMaxCatalogNameLength() << std::endl;
std::cout << "\tmax char literal length: " << metadata->getMaxCharLiteralLength() << std::endl;
std::cout << "\tmax column name length: " << metadata->getMaxColumnNameLength() << std::endl;
std::cout << "\tmax columns in GROUP BY: " << metadata->getMaxColumnsInGroupBy() << std::endl;
std::cout << "\tmax columns in ORDER BY: " << metadata->getMaxColumnsInOrderBy() << std::endl;
std::cout << "\tmax columns in SELECT: " << metadata->getMaxColumnsInSelect() << std::endl;
std::cout << "\tmax cursor name length: " << metadata->getMaxCursorNameLength() << std::endl;
std::cout << "\tmax logical lob size: " << metadata->getMaxLogicalLobSize() << std::endl;
std::cout << "\tmax row size: " << metadata->getMaxRowSize() << std::endl;
std::cout << "\tmax schema name length: " << metadata->getMaxSchemaNameLength() << std::endl;
std::cout << "\tmax statement length: " << metadata->getMaxStatementLength() << std::endl;
std::cout << "\tmax statements: " << metadata->getMaxStatements() << std::endl;
std::cout << "\tmax table name length: " << metadata->getMaxTableNameLength() << std::endl;
std::cout << "\tmax tables in SELECT: " << metadata->getMaxTablesInSelect() << std::endl;
std::cout << "\tmax user name length: " << metadata->getMaxUserNameLength() << std::endl;
std::cout << "\tNULL collation: " << metadata->getNullCollation() << std::endl;
std::cout << "\tnumeric functions: " << boost::algorithm::join(metadata->getNumericFunctions(), ", ") << std::endl;
std::cout << "\tOUTER JOIN support: " << metadata->getOuterJoinSupport() << std::endl;
std::cout << "\tquoted identifier case: " << metadata->getQuotedIdentifierCase() << std::endl;
std::cout << "\tSQL keywords: " << boost::algorithm::join(metadata->getSQLKeywords(), ",") << std::endl;
std::cout << "\tschema term: " << metadata->getSchemaTerm() << std::endl;
std::cout << "\tsearch escape string: " << metadata->getSearchEscapeString() << std::endl;
std::cout << "\tspecial characters: " << metadata->getSpecialCharacters() << std::endl;
std::cout << "\tstring functions: " << boost::algorithm::join(metadata->getStringFunctions(), ",") << std::endl;
std::cout << "\tsub query support: " << metadata->getSubQuerySupport() << std::endl;
std::cout << "\tsystem functions: " << boost::algorithm::join(metadata->getSystemFunctions(), ",") << std::endl;
std::cout << "\ttable term: " << metadata->getTableTerm() << std::endl;
std::cout << "\tUNION support: " << metadata->getUnionSupport() << std::endl;
std::cout << "\tBLOB included in max row size: " << metadata->isBlobIncludedInMaxRowSize() << std::endl;
std::cout << "\tcatalog at start: " << metadata->isCatalogAtStart() << std::endl;
std::cout << "\tcolumn aliasing supported: " << metadata->isColumnAliasingSupported() << std::endl;
std::cout << "\tLIKE escape clause supported: " << metadata->isLikeEscapeClauseSupported() << std::endl;
std::cout << "\tNULL plus non NULL equals to NULL: " << metadata->isNullPlusNonNullNull() << std::endl;
std::cout << "\tread-only: " << metadata->isReadOnly() << std::endl;
std::cout << "\tSELECT FOR UPDATE supported: " << metadata->isSelectForUpdateSupported() << std::endl;
std::cout << "\ttransaction supported: " << metadata->isTransactionSupported() << std::endl;
std::cout << "\tunrelated columns in ORDER BY supported: " << metadata->isUnrelatedColumnsInOrderBySupported() << std::endl;
client.freeMetadata(&metadata);
} else {
std::cerr << "Cannot get metadata:" << client.getError() << std::endl;
}
} else if(api=="sync"){
Drill::DrillClientError* err=NULL;
Drill::status_t ret;
int nQueries=0;
for(queryInpIter = queryInputs.begin(); queryInpIter != queryInputs.end(); queryInpIter++) {
Drill::RecordIterator* pRecIter = client.submitQuery(type, *queryInpIter, err);
if(pRecIter!=NULL){
recordIterators.push_back(pRecIter);
nQueries++;
}
}
Drill::DrillClientConfig::setBufferLimit(nQueries*2*1024*1024); // 2MB per query. Allows us to hold at least two record batches.
size_t row=0;
for(recordIterIter = recordIterators.begin(); recordIterIter != recordIterators.end(); recordIterIter++) {
// get fields.
row=0;
Drill::RecordIterator* pRecIter=*recordIterIter;
Drill::FieldDefPtr fields= pRecIter->getColDefs();
while((ret=pRecIter->next()), (ret==Drill::QRY_SUCCESS || ret==Drill::QRY_SUCCESS_WITH_INFO) && !pRecIter->hasError()){
fields = pRecIter->getColDefs();
row++;
if( (ret==Drill::QRY_SUCCESS_WITH_INFO && pRecIter->hasSchemaChanged() )|| ( row%100==1)){
for(size_t i=0; i<fields->size(); i++){
std::string name= fields->at(i)->getName();
printf("%s\t", name.c_str());
}
printf("\n");
}
printf("ROW: %ld\t", row);
for(size_t i=0; i<fields->size(); i++){
void* pBuf; size_t sz;
pRecIter->getCol(i, &pBuf, &sz);
print(fields->at(i), pBuf, sz);
}
printf("\n");
if(bTestCancel && row%100==1){
pRecIter->cancel();
printf("Application cancelled the query.\n");
}
}
if(ret!=Drill::QRY_NO_MORE_DATA && ret!=Drill::QRY_CANCEL){
std::cerr<< pRecIter->getError() << std::endl;
}
client.freeQueryIterator(&pRecIter);
}
client.waitForResults();
}else{
if(bSyncSend){
for(queryInpIter = queryInputs.begin(); queryInpIter != queryInputs.end(); queryInpIter++) {
Drill::QueryHandle_t qryHandle;
client.submitQuery(type, *queryInpIter, QueryResultsListener, NULL, &qryHandle);
client.registerSchemaChangeListener(&qryHandle, SchemaListener);
if(bTestCancel) {
// Send cancellation request after 5seconds
boost::this_thread::sleep(boost::posix_time::milliseconds(1000));
std::cout<< "\n Cancelling query: " << *queryInpIter << "\n" << std::endl;
client.cancelQuery(qryHandle);
} else {
client.waitForResults();
}
client.freeQueryResources(&qryHandle);
}
}else{
for(queryInpIter = queryInputs.begin(); queryInpIter != queryInputs.end(); queryInpIter++) {
Drill::QueryHandle_t qryHandle;
client.submitQuery(type, *queryInpIter, QueryResultsListener, NULL, &qryHandle);
client.registerSchemaChangeListener(&qryHandle, SchemaListener);
queryHandles.push_back(qryHandle);
}
client.waitForResults();
for(queryHandleIter = queryHandles.begin(); queryHandleIter != queryHandles.end(); queryHandleIter++) {
client.freeQueryResources(&*queryHandleIter);
}
}
}
client.close();
} catch (std::exception& e) {
std::cerr << e.what() << std::endl;
}
return 0;
}
void HttpServerConfigFacade::loadConfiguration(std::string const &filePath) {
rapidxml::file<> xmlFile(filePath.c_str());
rapidxml::xml_document<> doc;
doc.parse<0>(xmlFile.data());
auto httpServer = doc.first_node("HttpServer");
std::map<std::string, std::string> tcpSettings;
auto server = (*httpServer).first_node("Server");
readXmlSettings(server, tcpSettings);
// Setting TCP config
{
listenPort_ = std::strtoul(tcpSettings["Port"].c_str(), nullptr, 10);
initialUserConnection_ = std::strtoul(tcpSettings["InitialUserConnection"].c_str(), nullptr, 10);
maxUserConnection_ = std::strtoul(tcpSettings["MaxUserConnection"].c_str(), nullptr, 10);
bufferSize_ = SIZE_128KB;
numaNode_ = std::strtoul(tcpSettings["NumaNode"].c_str(), nullptr, 10);
}
std::map<std::string, std::string> httpSettings;
auto http = (*httpServer).first_node("Http");
readXmlSettings(http, httpSettings);
// Setting HTTP config
{
host_ = httpSettings["Host"];
serverName_ = httpSettings["ServerName"];
enableSSLProto_ = httpSettings["EnableSSL"] == "true" ? true : false;
enableHttp2Proto_ = httpSettings["EnableHTTP2"] == "true" ? true : false;
tempFilePath_ = httpSettings["TempFilePath"];
rootPath_ = httpSettings["RootPath"];
indexFileName_ = httpSettings["IndexFileName"];
}
std::map<std::string, std::string> sslSettings;
auto ssl = (*httpServer).first_node("SSL");
if (ssl != nullptr) {
readXmlSettings(ssl, sslSettings);
// Setting SSL config
{
certificateFilePath_ = sslSettings["CertificateFilePath"];
privateKeyFilePath_ = sslSettings["PrivateKeyFilePath"];
}
}
std::map<std::string, std::string> loggerSettings;
auto logger = (*httpServer).first_node("Logger");
if (logger != nullptr) {
readXmlSettings(logger, loggerSettings);
if (loggerSettings.empty()) {
// TDOO: throw an exception?
return;
}
rapid::logging::startLogging(getLogLevel(loggerSettings["Level"]));
std::vector<std::shared_ptr<rapid::logging::LogAppender>> appenders;
std::map<std::string, rapidxml::xml_node<char> *> settings;
readAppenderSettring(logger, settings);
if (settings.empty()) {
// TDOO: throw an exception?
return;
}
createAppenderFromSetting(settings, appenders);
} else {
// TDOO: throw an exception?
return;
}
namespace FS = std::tr2::sys;
FS::path watchFilePath(filePath);
pFileWatcher_ = std::make_unique<rapid::platform::FileSystemWatcher>(watchFilePath.parent_path());
pFileWatchTimer_ = rapid::details::Timer::createTimer();
pFileWatchTimer_->start([this, filePath]() {
if (!pFileWatcher_->getChangedFile().empty()) {
RAPID_LOG_TRACE() << "File configuration changed!";
try {
reloadConfiguration(filePath);
} catch (std::exception const &e) {
RAPID_LOG_FATAL() << e.what();
}
}
}, 500);
}
void JNIUtil::wrappedHandleSVNError(svn_error_t *err)
{
std::string msg;
assembleErrorMessage(svn_error_purge_tracing(err), 0, APR_SUCCESS, msg);
const char *source = NULL;
#ifdef SVN_DEBUG
#ifndef SVN_ERR__TRACING
if (err->file)
{
std::ostringstream buf;
buf << err->file;
if (err->line > 0)
buf << ':' << err->line;
source = buf.str().c_str();
}
#endif
#endif
// Much of the following is stolen from throwNativeException(). As much as
// we'd like to call that function, we need to do some manual stack
// unrolling, so it isn't feasible.
JNIEnv *env = getEnv();
// Create a local frame for our references
env->PushLocalFrame(LOCAL_FRAME_SIZE);
if (JNIUtil::isJavaExceptionThrown())
return;
jclass clazz = env->FindClass(JAVA_PACKAGE "/ClientException");
if (isJavaExceptionThrown())
POP_AND_RETURN_NOTHING();
if (getLogLevel() >= exceptionLog)
{
JNICriticalSection cs(*g_logMutex);
g_logStream << "Subversion JavaHL exception thrown, message:<";
g_logStream << msg << ">";
if (source)
g_logStream << " source:<" << source << ">";
if (err->apr_err != -1)
g_logStream << " apr-err:<" << err->apr_err << ">";
g_logStream << std::endl;
}
if (isJavaExceptionThrown())
POP_AND_RETURN_NOTHING();
jstring jmessage = makeJString(msg.c_str());
if (isJavaExceptionThrown())
POP_AND_RETURN_NOTHING();
jstring jsource = makeJString(source);
if (isJavaExceptionThrown())
POP_AND_RETURN_NOTHING();
jmethodID mid = env->GetMethodID(clazz, "<init>",
"(Ljava/lang/String;Ljava/lang/String;I)V");
if (isJavaExceptionThrown())
POP_AND_RETURN_NOTHING();
jobject nativeException = env->NewObject(clazz, mid, jmessage, jsource,
static_cast<jint>(err->apr_err));
if (isJavaExceptionThrown())
POP_AND_RETURN_NOTHING();
#ifdef SVN_ERR__TRACING
// Add all the C error stack trace information to the Java Exception
// Get the standard stack trace, and vectorize it using the Array class.
static jmethodID mid_gst = 0;
if (mid_gst == 0)
{
mid_gst = env->GetMethodID(clazz, "getStackTrace",
"()[Ljava/lang/StackTraceElement;");
if (isJavaExceptionThrown())
POP_AND_RETURN_NOTHING();
}
Array stackTraceArray((jobjectArray) env->CallObjectMethod(nativeException,
mid_gst));
std::vector<jobject> oldStackTrace = stackTraceArray.vector();
// Build the new stack trace elements from the chained errors.
std::vector<jobject> newStackTrace;
putErrorsInTrace(err, newStackTrace);
// Join the new elements with the old ones
for (std::vector<jobject>::const_iterator it = oldStackTrace.begin();
it < oldStackTrace.end(); ++it)
{
newStackTrace.push_back(*it);
}
jclass stClazz = env->FindClass("java/lang/StackTraceElement");
if (isJavaExceptionThrown())
POP_AND_RETURN_NOTHING();
const jsize stSize = static_cast<jsize>(newStackTrace.size());
if (stSize != newStackTrace.size())
{
env->ThrowNew(env->FindClass("java.lang.ArithmeticException"),
"Overflow converting C size_t to JNI jsize");
POP_AND_RETURN_NOTHING();
}
jobjectArray jStackTrace = env->NewObjectArray(stSize, stClazz, NULL);
if (isJavaExceptionThrown())
POP_AND_RETURN_NOTHING();
int i = 0;
for (std::vector<jobject>::const_iterator it = newStackTrace.begin();
it < newStackTrace.end(); ++it)
{
env->SetObjectArrayElement(jStackTrace, i, *it);
++i;
}
// And put the entire trace back into the exception
static jmethodID mid_sst = 0;
if (mid_sst == 0)
{
mid_sst = env->GetMethodID(clazz, "setStackTrace",
"([Ljava/lang/StackTraceElement;)V");
if (isJavaExceptionThrown())
POP_AND_RETURN_NOTHING();
}
env->CallVoidMethod(nativeException, mid_sst, jStackTrace);
if (isJavaExceptionThrown())
POP_AND_RETURN_NOTHING();
#endif
env->Throw(static_cast<jthrowable>(env->PopLocalFrame(nativeException)));
}
