void CPage::loadContentError(ConnectionPtr connection)
{
Trace("loadContentError()", "", 0);
std::string strQuery;
try
{
Mutex::Lock lock(m_contentErrorListLock);
// get all of the pages for this customer to test
strQuery = Format(SQL_WTT_CONTENT_ERRORS);
if (ResultPtr result = connection->Query(strQuery))
{
while (result->Next())
{
RowPtr row = result->GetCurrentRow();
StringIDList::value_type contentError(row->GetFieldString(1), row->GetFieldLong(2));
contentError.first = " " + contentError.first + " ";
Trace("loadContentError() - loading string", contentError.first.c_str(), contentError.second);
m_contentError.push_back(contentError);
}
}
}
catch (const std::exception& e)
{
LogError("Exception Caught:", e.what(), 0);
}
}
void CPage::loadPhraseCheck(ConnectionPtr connection)
{
Trace("loadPhraseCheck()", "", 0);
std::string strQuery;
try
{
Mutex::Lock lock(m_phraseListLock);
strQuery = Format(SQL_WTT_PHRASE_WORDS, getPageID());
if (ResultPtr result = connection->Query(strQuery))
{
Trace("RowPtr s:","",result->GetRowCount());
while (result->Next())
{
RowPtr row = result->GetCurrentRow();
StringIDList::value_type phrase(row->GetFieldString(1), row->GetFieldLong(2));
Trace("loadPhraseCheck_LT(): pre", phrase.first.c_str(), phrase.second);
std::transform(phrase.first.begin(), phrase.first.end(), phrase.first.begin(), tolower);
Trace("loadPhraseCheck_LT(): post", phrase.first.c_str(), phrase.second);
m_phrase.push_back(phrase);
}
}
}
catch (const std::exception& e)
{
LogError("Exception Caught:", e.what(), 0);
}
}
// per page tests
void runWTTT(scriptid_t scriptID, unsigned int shardNumber, const char* runNo, long batchID, bool wait, bool debug)
{
// only do a sleep if the first run - not for manual or retests
if ((atoi(runNo) == 1) && wait)
{
TraceNoise("Sleeping for a bit", runNo, scriptID);
// sleep for an offset of seconds
sleep(scriptID % 60);
}
ConnectionPtr connection;
std::string strQuery;
bool download = true;
try
{
#ifdef SHARD_AWARE
TraceLogic("Connecting to db", CConfig::getShardDatabase(shardNumber).c_str(), shardNumber);
connection.reset(
new Connection(
CConfig::getShardServer(shardNumber),
CConfig::getShardDatabase(shardNumber),
CConfig::getShardUser(shardNumber),
CConfig::getShardPass(shardNumber),
CConfig::getDBRetryTime()));
#else
TraceLogic("Connecting to db", CConfig::getDBDatabase(), 0);
connection.reset(
new Connection(
CConfig::getDBServer(),
CConfig::getDBDatabase(),
CConfig::getDBUser(),
CConfig::getDBPass(),
CConfig::getDBRetryTime()));
#endif
}
catch (const std::exception &e)
{
LogError("Exception Caught:", e.what(), scriptID);
return;
}
// if the ScriptID == 0 - get it from the batch table
if (scriptID == 0)
{
strQuery = Format(SQL_WTTT_BATCH_SEL, batchID);
TraceSQL("Issuing", "", 0);
if (ResultPtr result = connection->Query(strQuery))
{
if (result->Next())
{
RowPtr row = result->GetCurrentRow();
scriptID = row->GetFieldLong(1);
TraceLogic("batchID", "", batchID);
TraceLogic("scriptID", "", scriptID);
}
}
}
// script and archive names
const std::string filename = Format("/home/sc/bin/monitor_scripts/%ld_%u", scriptID, shardNumber);
const std::string gzfilename = filename + ".gz";
// Get script details
long customerNo = 0;
SC_SCRIPT_LANGUAGE scriptlanguage = SC_SCRIPT_LANGUAGE_UNKNOWN;
std::string scriptversion;
strQuery = Format(SQL_WTTT_SCRIPTINFO_SEL, scriptID);
TraceSQL("Issuing", "", 0);
if (ResultPtr result = connection->Query(strQuery))
{
if (result->Next())
{
RowPtr row = result->GetCurrentRow();
customerNo = row->GetFieldLong(1);
scriptlanguage = static_cast<SC_SCRIPT_LANGUAGE>(row->GetFieldLong(2));
// Field can be NULL, so check before dereference
if (const char* str = row->GetField(3))
{
scriptversion = str;
}
TraceLogic("customerNo", "", customerNo);
TraceLogic("scriptlanguage", to_string(scriptlanguage).c_str(), int(scriptlanguage));
TraceLogic("scriptversion", scriptversion.c_str(), scriptversion.size());
}
}
switch (scriptlanguage)
{
case SC_SCRIPT_LANGUAGE_UNKNOWN:
//
// No recognised script or script language returned
//
LogError(
"Script not found",
Format("ScriptID=%d Shard=%d DB.name=%s DB.host=%s",
scriptID,
shardNumber,
CConfig::getShardDatabase(shardNumber).c_str(),
CConfig::getShardServer(shardNumber).c_str()).c_str(),
0);
exit(1);
break;
case SC_SCRIPT_LANGUAGE_PHP:
//
// Handle PHP script
//
strQuery = Format("select Code, length(Code) from Script where ScriptID=%ld", scriptID);
TraceSQL("Issuing", "", 0);
if (ResultPtr result = connection->Query(strQuery))
{
if (result->Next())
{
RowPtr row = result->GetCurrentRow();
int scriptLength = row->GetFieldInteger(2);
std::string scriptString(row->GetField(1), scriptLength);
TraceLogic("length(Code)", "", scriptLength);
umask(SC_WTTT_UMASK);
int filePtr = open(filename.c_str(), O_CREAT | O_TRUNC | O_WRONLY, S_IRWXU);
if (filePtr != -1)
{
// output the body to the file
int nbytes = write(filePtr, scriptString.c_str(), scriptLength);
if (nbytes != scriptLength)
{
LogError("Incomplete write of PHP executeable to disc", to_string(nbytes).c_str(), scriptLength);
}
close(filePtr);
}
else
{
LogError("Unable to write PHP executable to disc", "", scriptID);
}
}
}
break;
case SC_SCRIPT_LANGUAGE_CXX:
//
// Handle compiled C++ script
//
if (Exist(filename))
{
// Is the file out of date?
strQuery = Format(SQL_WTTT_SCRIPTAGE_SEL, scriptID);
TraceSQL("Issuing", "", 0);
if (ResultPtr result = connection->Query(strQuery))
{
if (result->Next())
{
RowPtr row = result->GetCurrentRow();
long dbage = row->GetFieldLong(1);
TraceLogic("dbage", "", dbage);
struct stat statbuf;
bzero(&statbuf, 0);
int ret = stat(filename.c_str(), &statbuf);
TraceLogic("stat", "download", ret);
download = ret == -1 || statbuf.st_mtime < dbage;
TraceLogic("Overwrite the existing %s?", "download", int(download));
TraceLogic("statbuf.st_mtime", "", statbuf.st_mtime);
}
}
}
//
// Extract script from database
//
if (download)
{
strQuery = Format(SQL_WTTT_SCRIPT_SEL, scriptID);
TraceSQL("Issuing", "", 0);
if (ResultPtr result = connection->Query(strQuery))
{
if (result->Next())
{
RowPtr row = result->GetCurrentRow();
int scriptLength = row->GetFieldInteger(2);
std::string scriptString(row->GetField(1), scriptLength);
// Field can be NULL, so check before dereference
int agentVersion = 0;
if (const char* str = row->GetField(3))
{
agentVersion = atoi(str);
}
TraceLogic("scriptLength", "", scriptLength);
TraceLogic("scriptString", scriptString.c_str(), scriptString.size());
TraceLogic("agentVersion", "", agentVersion);
umask(SC_WTTT_UMASK);
int filePtr = open(gzfilename.c_str(), O_CREAT | O_TRUNC | O_WRONLY, S_IRWXU);
if (filePtr != -1)
{
// output the body to the file
int nbytes = write(filePtr, scriptString.c_str(), scriptLength);
close(filePtr);
if (nbytes == scriptLength)
{
// unzip, set permissions and prelink
doUnzip(gzfilename);
chmod(filename.c_str(), 0775);
bool prelink = false;
if (!CConfig::getIMMode())
{
TraceLogic("Connecting to passport db", CConfig::getPassportDbDatabase().c_str(), 0);
ConnectionPtr connectionPassport(
new Connection(
CConfig::getPassportDbServer(),
CConfig::getPassportDbDatabase(),
CConfig::getPassportDbUser(),
CConfig::getPassportDbPass(),
CConfig::getDBRetryTime()));
strQuery = Format("select Prelink from LibraryVersions where Version=%d", agentVersion);
TraceSQL("Issuing", "", 0);
if (ResultPtr result = connectionPassport->Query(strQuery))
{
if (result->Next())
{
RowPtr row = result->GetCurrentRow();
prelink = row->GetFieldInteger(1) != 0;
TraceLogic("prelink", to_string(prelink).c_str(), int(prelink));
}
}
TraceLogic("prelink", "", int(prelink));
}
else
{
TraceLogic("prelink", "Don't prelink on IM node", 0);
}
if (prelink)
{
int ret = doPrelink(filename, SC_AGENT_VER_NUM);
if (ret != 0)
{
LogError("Prelink failed", filename.c_str(), ret);
}
}
}
else
{
LogError("Incomplete write of C++ executeable to disc", to_string(nbytes).c_str(), scriptLength);
return;
}
}
else
{
LogError("Unable to write C++ executable to disc", "", scriptID);
return;
}
}
else
{
LogError("C++ Executable not in database", gzfilename.c_str(), result->GetRowCount());
return;
}
}
else
{
LogError("Query for C++ executable failed", strQuery.c_str(), result->GetRowCount());
return;
}
}
break;
default:
LogError("Fatal: Unknown language", "", int(scriptlanguage));
return;
}
// close the db connection
Clear(connection);
//
// Build command line
//
std::string systemCmd;
#ifdef USE_SHARED
// For version 7
if (scriptlanguage == SC_SCRIPT_LANGUAGE_CXX &&
Exist("/home/sc/lib/libsiteconfidence.so." + scriptversion) &&
Exist("/home/sc/lib/libscparser.so." + scriptversion) &&
Exist("/home/sc/lib/libsiteconfidenceinterface.so." + scriptversion))
{
std::ostringstream os;
os << "export LD_PRELOAD=";
os << "/home/sc/lib/libsiteconfidence.so." << scriptversion << ":";
os << "/home/sc/lib/libscparser.so." << scriptversion << ":";
os << "/home/sc/lib/libsiteconfidenceinterface.so." << scriptversion << "; ";
systemCmd += os.str();
}
#endif
#ifdef SHARD_AWARE
// set environment variables for debug and shardNumber
{
std::ostringstream os;
os << "export SHARD_NUMBER=" << shardNumber << "; "
<< "export SC_DEBUG_MANUAL_MODE=" << (debug != 0) << "; ";
systemCmd += os.str();
}
#endif
// program command line
{
std::ostringstream os;
os << filename << " " << runNo << " " << batchID << " " << scriptID << " " << customerNo;
systemCmd += os.str();
}
//Print(Format("starting script:%s\n", systemCmd.c_str()));
// execute
TraceLogic("Starting script", systemCmd.c_str(), scriptID);
int sysVal = system(systemCmd.c_str());
int exitVal = WEXITSTATUS(sysVal);
TraceLogic("System call returned", systemCmd.c_str(), exitVal);
//Print(Format("script returned:%d\n", exitVal));
}
