예제 #1
0
파일: page.cpp 프로젝트: tucci69/tcp_ssl
void CPage::LoadCache(ConnectionPtr connection)
{
	Trace("LoadCache", "",0);

    ResultPtr result;
	ncc::safe_array<char> strQuery(10240);

	try
	{
		// load from the database
		snprintf(strQuery, strQuery.size(), SQL_WTT_LOAD_CACHE, m_runID);

		Trace("Query for LoadCache", strQuery, 0);
		result = connection->Query(strQuery);

		while(result->Next())
		{
			RowPtr row = result->GetCurrentRow();
			// add it
			std::string urlStr;
			urlStr = row->GetFieldString(1);
			{ // scope for lock
				Mutex::Lock lock(sm_urlListLock);
				m_totalUrlList.push_back(urlStr);
			}
		}
	}
	catch (const std::exception& e)
	{
		LogError2("LoadCache() - Caught Exception", e.what(), 0, SC_ERR_GROUP_DB, SC_ERR_CODE_LOAD_CACHE);
	}
}
예제 #2
0
파일: page.cpp 프로젝트: tucci69/tcp_ssl
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);
	}
}
예제 #3
0
파일: page.cpp 프로젝트: tucci69/tcp_ssl
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);
	}
}
예제 #4
0
파일: page.cpp 프로젝트: tucci69/tcp_ssl
void CPage::checkErrorsAlertable(ConnectionPtr connection)
{
	Trace("checkErrorsAlertable", getURL().c_str(), getOverallResultCode());

    std::string strQuery;
	std::string colour;

	// if colour = red/black then go to downtime testing and send alert to alertable people
	try
	{
		// select Colour from Severity where ErrorCode = %d
		strQuery = Format(SQL_WTT_ERROR_COLOUR, (long int)getOverallResultCode());
		if (ResultPtr result = connection->Query(strQuery))
		{
			Trace("RowPtr s:","",result->GetRowCount());

			if (result->Next())
			{
				RowPtr row = result->GetCurrentRow();

				colour += row->GetFieldString(1);
			}
		}
	}
	catch (const std::exception& e)
	{
		LogError("Exception Caught:", e.what(), 0);
	}

	Trace("checkErrorsAlertable", colour.c_str(), getOverallResultCode());

	// only report an error if page failed and not a benchmark and IS a normal page
	if ((colour == SC_SEVERITY_BLACK) || (colour == SC_SEVERITY_RED))
	{
		sm_errorAlertable = true;
	}
}
예제 #5
0
파일: wtti.cpp 프로젝트: tucci69/tcp_ssl
resultid_t runWTTI(const char* url, std::string& dbName, unsigned int wttiRunID, unsigned int shardNumber, int webkitTimeout)
{
	std::string strQuery;
	sem_init( &(CWebPage::Instance()->sm_hostSemaphore), 0, 0 );
	sem_init( &(CWebPage::Instance()->sm_threadControlSemaphore), 0, 0 );

#ifdef SHARD_AWARE
	ConnectionPtr connection(
		new Connection(
			CConfig::getShardServer(shardNumber),
			CConfig::getShardDatabase(shardNumber),
			CConfig::getShardUser(shardNumber),
			CConfig::getShardPass(shardNumber),
			CConfig::getDBRetryTime()));
#else
	ConnectionPtr connection(
		new Connection(
			CConfig::getDBServer(),
			CConfig::getDBDatabase(),
			CConfig::getDBUser(),
			CConfig::getDBPass(),
			CConfig::getDBRetryTime()));
#endif

	std::string urlToTest;

	// Get URL from the WttiTests table.
	ResultPtr resultUrl;
	strQuery = Format(SQL_WTTI_SELECT_URL, wttiRunID);
	resultUrl = connection->Query(strQuery.c_str());
	if ( resultUrl->Next() )
	{
		RowPtr row = resultUrl->GetCurrentRow();
		urlToTest = row->GetFieldString(1);

		Trace("Rows:", "", resultUrl->GetRowCount());
	}

	resultid_t dailyResultID = 0;
	PackDiagStorage store;

	int pageID = 0;
	CResultSet resultSet;
	CTcp* pTcpConnection = new CTcp("", 0);

	// Turn CSS Parsing on permanently.
	CWebPage::Instance()->sm_doCssParsing = 1;
    
    //Turn SSL validation on permanently
    CWebPage::Instance()->sm_doSslValidation = 1;
    CTcp::setDoSslValidation(1);

	// create the new web page object
	CWebPage* pPage = new CWebPage(
		resultSet,
		pTcpConnection,
		0,
		SC_SERVICE_BENCHMARK,
		urlToTest, // url
		pageID, // page id
		SC_WEBPAGE_TYPE_IMED, // page type
		true, // reset cookies
		std::string(), // auth user
		std::string(), // auth pass
		DOWNLOAD_THRESHOLD_SECS, // download threshold
		true, // reset cache
		CConfig::getServerID(),
		SC_WEBPAGE_STATUS_OK, // bodge to be status live page
		HTTP_METHOD_GET, // bodge to get GET by default
		std::string(),
		std::vector<std::string>(),
		std::vector<char>(), // emptyVector,    // bodge - no form variables
		std::string() // fileStr  // bodge - no file variables
		);

	// reset the counters
	pPage->resetPage();

	// record when we started the test
	//pPage->setStartTime();

	// make sure we don't report a hacking / login failure
	// pPage->phraseWasFound();
	// Set that a connection exists to this host.
	//pPage->isHostConnectionsExceeded(static_cast<std::string>(url));
	// do the load of this page
	//pPage->load();

	// add the page just loaded to the list of those done so it doesn't get done again
	// via a redirect
	//CWebPage::AddURLDone(url);

	// reset the first byte count for the page
	//pPage->resetSpeedCounters();

	MultiThreadSetup();

	// ----------------------
	// --- THREAD MANAGER ---
	// ----------------------
	std::string protoAndHost;
	protoAndHost = urlToTest;

	// Calculate protocol type.
	if (strncasecmp (protoAndHost.c_str(), "http://", 7) == 0)
	{
		std::string::size_type hostLength = protoAndHost.find("/", 7);
		if (hostLength != std::string::npos)
			protoAndHost = protoAndHost.substr(0, hostLength);
	}
	else if (strncasecmp (protoAndHost.c_str(), "https://", 8) == 0)
	{
		std::string::size_type hostLength = protoAndHost.find("/", 8);
		if (hostLength != std::string::npos)
			protoAndHost = protoAndHost.substr(0, hostLength);
	}
	else
	{
		std::string::size_type hostLength = protoAndHost.find("/");
		if (hostLength != std::string::npos)
			protoAndHost = "http://" + protoAndHost.substr(0, hostLength);
		else
			protoAndHost = protoAndHost.insert(0, "http://");
	}


	// Add the host that we're about to connect to so it does not get added again.
	{
		Mutex::Lock lock(CWebPage::Instance()->sm_connectedHostsLock);
		CWebPage::Instance()->sm_connectedHosts.push_back(std::make_pair(true, protoAndHost));
	}


	std::vector<ThreadArgs*> threadArgsVector;

	// JYLS WEBKIT START

#ifndef SC_NON_WEBKIT
#ifdef SC_WEBKIT_V89

	curlwrapper_init(pPage, startThread);

	//Use the default value from the opt file for these
	ww_setMaxNumberOfThreadsPerHost(CConfig::getDefaultMaxThreadsPerHost());
	ww_setMaxTotalNumberOfThreads(CConfig::getDefaultMaxTotalThreads());
	ww_setScreenXDimension(CConfig::getScreenXDimension());
	ww_setScreenYDimension(CConfig::getScreenYDimension());
	ww_setJavascriptTimeout(CConfig::getJsExecutionTimeout());

	ww_loadPageByWebkit(pPage->getURL().c_str(), true, DOWNLOAD_THRESHOLD_SECS, webkitTimeout);

#else
	bool isJavascriptEnabled = true;

	soupwrapper_init(pPage, startThread);

	ww_setPageId(pageID);
	ww_setWebkitTimeout(webkitTimeout);
	ww_setWebkitTimeoutHard(CConfig::getWebkitHardTimeout());

	load_page_by_webkit(pPage->getURL(), isJavascriptEnabled);
#endif	// SC_WEBKIT_V89
#else
	std::vector<pthread_t> threadIds;
	pthread_t threadId;
	int res = 0;
	unsigned int maxThreadsPerHost = 0;

	if (maxThreadsPerHost == 0)
		maxThreadsPerHost = CConfig::getDefaultMaxThreadsPerHost();

	//Limit the value of maxThreadsPerHost
	if (maxThreadsPerHost > CConfig::getMaxThreadsPerHostLimit())
		maxThreadsPerHost = CConfig::getMaxThreadsPerHostLimit();

	unsigned int numThreads = maxThreadsPerHost;

	for (unsigned int a = 0; a < numThreads; ++a)
	{
		ThreadArgs* args1 = new ThreadArgs;
		args1->isFirstPage = (a == 0);
		args1->pPage       = pPage;
		args1->host        = protoAndHost;
		res = pthread_create(&(threadId), NULL, startThread, (void*)args1);
		if ( res != 0 )
		{
			LogError("Failed to start thread for", protoAndHost.c_str(), 0);
		}
		else
		{
			threadIds.push_back(threadId);
			threadArgsVector.push_back(args1);

			// Wait for the second thread to signal it has started.
			sem_wait(&(CWebPage::Instance()->sm_threadControlSemaphore));
		}
	}

	std::vector<CWebPage::HostPair>::const_iterator hostIt;

	Trace("before starting threads", "", 0);

	while ((CWebPage::getUrlListSize()) > 0 || (CWebPage::Instance()->sm_numWorkingThreads > 0))
	{
		{
			Mutex::Lock lock(CWebPage::Instance()->sm_connectedHostsLock);
			for ( hostIt = CWebPage::Instance()->sm_connectedHosts.begin(); hostIt != CWebPage::Instance()->sm_connectedHosts.end(); ++hostIt )
			{
				if ( !(hostIt->first) )
				{
					unsigned int numThreads = maxThreadsPerHost;

					for (unsigned int a = 0; a < numThreads; ++a)
					{
						bool errorOccured = false;
						std::string hostToConnect;
						hostToConnect.assign(hostIt->second);

						// Start threads per new host encountered.
						Trace("Starting threads for", hostIt->second.c_str(), 0);

						ThreadArgs* args2  = new ThreadArgs;
						args2->isFirstPage = false;
						args2->pPage       = pPage;
						args2->host        = hostToConnect;

						res = pthread_create(&(threadId), NULL, startThread, (void*)args2);
						if ( res != 0 )
						{
							LogError("Failed to start thread for", hostIt->second.c_str(), 2);
							errorOccured = true;
						}
						else
						{
							threadIds.push_back(threadId);
							threadArgsVector.push_back(args2);
							// Wait for thread to start.
							sem_wait(&(CWebPage::Instance()->sm_threadControlSemaphore));
						}

						// Connected ok.
						hostIt->first = true;
					}
				}
			}
		}

		// Wait for more hosts to be encountered.
		sem_wait(&(CWebPage::Instance()->sm_hostSemaphore));
	}

#endif	// SC_NON_WEBKIT
	// JYLS WEBKIT END

	Trace("Deleting semaphore", "", 0);
	sem_destroy(&(CWebPage::Instance()->sm_hostSemaphore));
	sem_destroy(&(CWebPage::Instance()->sm_threadControlSemaphore));
#ifdef SC_NON_WEBKIT
	// Write debug information if components remain.
	if (CWebPage::getUrlListSize() > 0)
	{
		CWebPage::writeThreadsDebug();

		int count = 0;
		std::vector<ThreadArgs*>::const_iterator threadsIt;
		for (threadsIt = threadArgsVector.begin(); threadsIt != threadArgsVector.end(); ++threadsIt)
		{
			LogInfo("Threads started=", (*threadsIt)->host.c_str(), count);
			++count;
		}
	}
#endif	// SC_NON_WEBKIT

#ifndef SC_NON_WEBKIT
	// Sleep to allow for extra components from eg javascript
	usleep(1000000);

	//Actually check how many threads are running, go ahead if 0
	while (CWebPage::Instance()->sm_numWorkingThreads)
	{
		usleep(10000);
	}
#else
	void* threadResult;

	// Join started threads.
	for (unsigned int i = 0; i < threadIds.size(); ++i)
	{
		res = pthread_join(threadIds[i], &threadResult);
		if (res != 0)
		{
			LogError("Unable to join thread", "", res);
		}
		else
		{
			Trace("Joined thread", "", res);
		}
	}
#endif	// SC_NON_WEBKIT

	// Delete all ThreadArgs used.
	while ( !threadArgsVector.empty() )
	{
		delete threadArgsVector.back();
		threadArgsVector.pop_back();
	}

	setResultCode(pPage, CWebPage::Instance()->sm_firstPageResultCode);

	try
	{
		Trace("Connecting to db", "", 0);

		std::string requestStr;
		std::string headerStr;
		std::string htmlStr;
		std::string extraInfoStr;

		// extra info for ResultHeader
		if (!resultSet.getResultDetails().empty())
		{
			const CResultDetail* pResultDetail = resultSet.getFirstResultDetail();

			requestStr = pResultDetail->getRequest();
			headerStr = pResultDetail->getHeaders();
			htmlStr = pResultDetail->getPageText();
			extraInfoStr = pResultDetail->getExtraInfo();
		}

		const bool pageInError = pPage->getOverallResultCode() != SC_HEADER_RESULT_SUCCESS && pPage->getOverallResultCode() != SC_HEADER_RESULT_DUMMY_TRANSACTION;

		// 3.0.0 Daily ResultHeader tables
		StoreHeaderDaily(
			connection,
			resultSet,
			pPage->getPageID(),
			CConfig::getServerID(),
			pPage->getStartTimeStr(),
			pPage->getOverallResultCode(),
			pPage->getDNSTimeOffsetMs(),
			pPage->getConnectTimeOffsetMs(),
			pPage->getTotalLastByteTimeOffsetMs(),
			pPage->getTotalBytes(),
			&dailyResultID,
			pPage->getFirstDataTimeOffsetMs(),
			pPage->getDailyTableName(),
			PackDiagOverride(),
			store,
			pageInError,
			false,
			SC_TEST_TYPE_WTTI,
			0,
			0,
			0,
			CSCGlobal::gAgentVersion,
			pPage->getTotalGzipBytes(),
			false, //diagstored
			pPage->getSslConnectTimeOffsetMs(),
			pPage->getRequestSentTimeOffsetMs(),
			pPage->getRequestHeaderSize(),
			pPage->getRequestContentSize(),
			pPage->getResponseHeaderSize());

		// now store all the detail - always do this for wtti
		int ComponentNo = 1;
		for (CResultSet::ResultList::const_iterator p = resultSet.getResultDetails().begin(); p != resultSet.getResultDetails().end(); ++p, ++ComponentNo)
		{
			// now go and get the rest of the files - with threads
			if (const CResultDetail* pResultDetail = p->pResultDetail)
			{
				pResultDetail->setComponentNo(ComponentNo);

				// 3.0.0 Daily ResultDetail tables
				StoreResultDaily(
					connection,
					resultSet,
					ComponentNo,
					pResultDetail,
					dailyResultID,
					pPage->getDailyTableName());
			}
		}
	}
	catch (const std::exception &e)
	{
		Trace("Exception caught", e.what(), 0);
		LogError2("Exception Caught:", e.what(), 0, SC_ERR_GROUP_AGENT, SC_ERR_CODE_WTTI);
		return 0;
	}
	
#ifdef SHARD_AWARE
	// Write the result ID back to the transient table so the website can pick it up.
	strQuery = Format(SQL_WTTI_INSERT_RESULTID, dailyResultID, wttiRunID);
	Trace("Issuing query", strQuery.c_str(), dailyResultID);
	connection->Query(strQuery);
#endif

	//
	dbName = pPage->getDailyTableName();

	// complete it
	delete pPage;
	pPage = NULL;

	MultiThreadCleanup();

	// Remove /tmp/session_id.<pid>p.host files
	long int uniqueId = getpid();
	std::string identifier = WTTP_SESSION_ID_IDENTIFIER;
	strQuery = Format("rm -f /tmp/session_id.%ld%s.*", uniqueId, identifier.c_str());
	int ret = system(strQuery.c_str());
	Trace("System call returned", strQuery.c_str(), ret);

	return dailyResultID;
}
예제 #6
0
bool checkConnectivity(ConnectionPtr connection)
{
	// checks to see if this server has connectivity
	// it does so by finding two servers (from the TestServer table) in other groups, and hence on other carriers
	// if both of these pings fail then we can assume that it is our connectivity
	// we can then re-schedule the job

	// now also used to see if we are down before the end of the check

	std::string	testHost;
	std::string	externalTestHost;
	std::string	externalTestHost1;
	std::string	externalTestHost2;
	int			ourGroup = 0;
	int			testGroup = 0;
	ResultPtr 	result;
	ncc::safe_array<char> selectQuery(1024);
	bool		retVal = true;
	std::string site;
	std::string clusterGroup;

	Trace("checkConnectivity", "CConfig::getServerID()", CConfig::getServerID());

	try
	{
#ifdef SHARD_AWARE
		ConnectionPtr passportShardConnection(
			new Connection(
					CConfig::getPassportDbServer(),
					CConfig::getPassportDbDatabase(),
					CConfig::getPassportDbUser(),
					CConfig::getPassportDbPass(),
					CConfig::getDBRetryTime()));

		// get the group of this test server
		snprintf(selectQuery, selectQuery.size(), SQL_SCS_TEST_GROUP_CG3, CConfig::getServerID());
		Trace("Issuing query",selectQuery,0);
		result = passportShardConnection->Query(selectQuery);
		Trace("Rows:","",result->GetRowCount());

		if (result->GetRowCount() > 0)
		{
			result->Next();
			RowPtr row = result->GetCurrentRow();

			ourGroup = row->GetFieldInteger(1);
		}

		snprintf(selectQuery, selectQuery.size(), SQL_SCS_RETEST_SERVERS_GROUP_RAND_CG3,
							SC_SERVER_STATUS_LIVE, ourGroup, 0);

		Trace("Issuing query",selectQuery,0);
		result = passportShardConnection->Query(selectQuery);
		Trace("Rows:","",result->GetRowCount());

#else
		// get the group of this test server
		snprintf(selectQuery, selectQuery.size(), SQL_SCS_TEST_GROUP, CConfig::getServerID());
		Trace("Issuing query",selectQuery,0);
		result = connection->Query(selectQuery);
		Trace("Rows:","",result->GetRowCount());

		if (result->GetRowCount() > 0)
		{
			result->Next();
			RowPtr row = result->GetCurrentRow();

			ourGroup = row->GetFieldInteger(1);
			site = row->GetFieldString(2);
			clusterGroup = row->GetFieldString(3);
		}

		snprintf(selectQuery, selectQuery.size(), SQL_SCS_RETEST_SERVERS_GROUP_RAND, SC_SERVER_STATUS_LIVE, ourGroup, site.c_str(), clusterGroup.c_str());
		Trace("Issuing query",selectQuery,0);
		result = connection->Query(selectQuery);
		Trace("Rows:","",result->GetRowCount());
#endif
		int testGroup1 = 0;
		int testGroup2 = 0;
		std::string externalTestHost1;
		std::string externalTestHost2;

		if (result->GetRowCount() > 0)
		{
			while(result->Next())
			{
				RowPtr row = result->GetCurrentRow();

				testHost = row->GetFieldString(2);
				testGroup = row->GetFieldInteger(3);
				externalTestHost = row->GetFieldString(4);

				Trace("externalHost",externalTestHost.c_str(),testGroup);
				if (testGroup1 == 0)
				{
					// set this to be the first group to test
					testGroup1 = testGroup;
					externalTestHost1 = externalTestHost;
				}
				else if (testGroup1 != testGroup)
				{
					// different group - use for the second test
					testGroup2 = testGroup;
					externalTestHost2 = externalTestHost;

					// all done now
					break;
				}
				// else must be same group as testGroup1 - ignore it
			}

			bool ping1OK = true;
			bool ping2OK = true;

			if ((testGroup1 != 0) && (externalTestHost1 != ""))
			{
				Trace("Tesing against group 1",externalTestHost1.c_str(),testGroup1);
				ping1OK = pingSiteAvailable(externalTestHost1);
			}
			else
			{
				// nothing to test - assume it worked ?
				Trace("Tesing against group 1","n/a",testGroup1);
			}

			if ((testGroup2 != 0) && (externalTestHost2 != ""))
			{
				Trace("Tesing against group 2",externalTestHost2.c_str(),testGroup2);
				ping2OK = pingSiteAvailable(externalTestHost2);
			}
			else if ((testGroup1 != 0) && (externalTestHost1 != ""))
			{
				// we tested a 'real' #1 - test the one from sc.opt
				Trace("Tesing against group 2 - sc.opt",CConfig::getPing1Name().c_str(),testGroup2);
				ping2OK = pingSiteAvailable(CConfig::getPing1Name());
			}
			else
			{
				// else nothing to test - assume it worked ?
				Trace("Tesing against group 2","n/a",testGroup2);
			}

			if (!ping1OK && !ping2OK)
			{
				// first two have failed
				// check yahoo
				if (!pingSiteAvailable(CConfig::getPing1Name()))
				{
					retVal = false;
				}
			}
		}
	}
	catch (const std::exception& e)
	{
		Trace("Exception caught", e.what(), 0);
		printf("Error: %s\n", e.what());
	}

	return retVal;
}
예제 #7
0
void schedSecondTest(ConnectionPtr connection, long idNo, int portNo, SC_TEST_TYPE testType, unsigned int shardNumber)
{
	Trace("schedSecondTest", "", idNo);

	std::string	strQuery;

	// find a server to send the test to
	try
	{
#ifdef SHARD_AWARE
		ConnectionPtr passportShardConnection(
			new Connection(
					CConfig::getPassportDbServer(),
					CConfig::getPassportDbDatabase(),
					CConfig::getPassportDbUser(),
					CConfig::getPassportDbPass(),
					CConfig::getDBRetryTime()));

		// get the group of this test server
		strQuery = Format(SQL_SCS_TEST_GROUP_CG3, CConfig::getServerID());
		TraceSQL("Issuing query", "", 0);

		int	testGroup = 0;
		if (ResultPtr result = passportShardConnection->Query(strQuery))
		{
			TraceSQL("Rows:","",result->GetRowCount());
			if (result->GetRowCount() > 0)
			{
				result->Next();
				RowPtr row = result->GetCurrentRow();

				testGroup = row->GetFieldInteger(1);
			}
		}

		// get the carrier to exclude
		if (portNo == TCP_PORT_WTTGD)
		{
			strQuery = Format(SQL_SCS_TEST_GROUP_EXCLUDE_SCRIPT, idNo);
		}
		else if (portNo == TCP_PORT_ETTD)
		{
			strQuery = Format(SQL_SCS_TEST_GROUP_EXCLUDE_ISP, idNo);
		}
		else
		{
			strQuery = Format(SQL_SCS_TEST_GROUP_EXCLUDE_WEBPAGE, idNo);
		}
		TraceSQL("Issuing query", "", 0);

		unsigned int carrierToExclude = 0;
		if (ResultPtr result = connection->Query(strQuery))
		{
			TraceSQL("Rows:","",result->GetRowCount());
			if (result->GetRowCount() > 0)
			{
				result->Next();
				RowPtr row = result->GetCurrentRow();

				// make it the customer one
				carrierToExclude = row->GetFieldInteger(1);

				// override with Script or WebPage one
				if (row->GetFieldInteger(2) != 0)
					carrierToExclude = row->GetFieldInteger(2);
			}
		}

#ifdef SC_NON_WEBKIT
		strQuery = Format(SQL_SCS_RETEST_SERVERS_GROUP_RAND_CG3, SC_SERVER_STATUS_LIVE, testGroup, carrierToExclude);
#else
#ifdef SC_WEBKIT_V89
		strQuery = Format(SQL_SCS_RETEST_SERVERS_GROUP_RAND_CG3, SC_SERVER_JACK_STATUS_LIVE_89, testGroup, carrierToExclude);
#else
		strQuery = Format(SQL_SCS_RETEST_SERVERS_GROUP_RAND_CG3, SC_SERVER_JACK_STATUS_LIVE, testGroup, carrierToExclude);
#endif	// SC_WEBKIT_V89
#endif	// SC_NON_WEBKIT
		TraceSQL("Issuing query", "", 0);

		if (ResultPtr result = passportShardConnection->Query(strQuery))
		{
			TraceSQL("Rows:","",result->GetRowCount());

#else
		// get the group of this test server
		strQuery = Format(SQL_SCS_TEST_GROUP, CConfig::getServerID());
		TraceSQL("Issuing query", "", 0);

		if (ResultPtr result = connection->Query(strQuery))
		{
			std::string site;
			std::string clusterGroup;

			TraceSQL("Rows:","",result->GetRowCount());
			if (result->GetRowCount() > 0)
			{
				result->Next();
				RowPtr row = result->GetCurrentRow();

				testGroup = row->GetFieldInteger(1);
				site = row->GetFieldString(2);
				clusterGroup = row->GetFieldString(3);
			}
		
			// first work out the minute
			//time_t timeNow = time(NULL);
			//struct tm* timeStruct;
			//timeStruct = localtime( &timeNow );
			strQuery = Format(SQL_SCS_RETEST_SERVERS_GROUP_RAND, SC_SERVER_STATUS_LIVE, testGroup, site.c_str(), clusterGroup.c_str());
		}
		TraceSQL("Issuing query", "", 0);

		if (ResultPtr result = connection->Query(strQuery))
		{
			TraceSQL("Rows:","",result->GetRowCount());
#endif
			if (result->GetRowCount() > 0)
			{
				std::string	testHost;

				while (result->Next())
				{
					RowPtr row = result->GetCurrentRow();

					testHost = row->GetFieldString(2);

					// try to send the job

					// send the test request
					CTcp tcpConnection(testHost, portNo);
					int fd = tcpConnection.tcp_connect(WTT_WTTD_TIMEOUT_SECS);
					if (fd > 0)
					{
#ifdef SHARD_AWARE
						// send the info to the testing tool
						if (testType == SC_TEST_TYPE_UNKNOWN)
						{
							strQuery = Format("%ld %d", idNo, shardNumber);
						}
						else
						{
							strQuery = Format("%ld %d %d", idNo, shardNumber, int(testType));
						}
#else
						// send the info to the testing tool
						if (testType == SC_TEST_TYPE_UNKNOWN)
						{
							strQuery = Format("%ld", idNo);
						}
						else
						{
							strQuery = Format("%ld %d", idNo, int(testType));
						}
#endif
						TraceLogic("tcpConnection.writen", strQuery.c_str(), strQuery.size())
						if (tcpConnection.writen(strQuery.c_str(), strQuery.size()) > 0)
						{
							Trace("Job sent to test server", strQuery.c_str(), fd);
							return;
						}
						else
						{
							LogError("Error sending job to test server", strQuery.c_str(), idNo);
						}
					}
					else
					{
						LogError("Timed out sending job to test server", "", idNo);
					}
				}
			}
예제 #8
0
파일: page.cpp 프로젝트: tucci69/tcp_ssl
void CPage::loadJavaScriptCheck(ConnectionPtr connection)
{
	Trace("loadJavaScriptCheck()", "",0);

	std::string strQuery;

	// need to change all to lower case
	std::string	lowerCaseBody;

	try
	{
		Mutex::Lock lock(m_javascriptListLock);

		strQuery = Format(SQL_WTT_JAVASCRIPT1);
		if (ResultPtr result = connection->Query(strQuery))
		{
			Trace("RowPtr s:","",result->GetRowCount());

			while(result->Next())
			{
				RowPtr row = result->GetCurrentRow();

				// add to the list
				Trace("loadJavaScriptCheck() - search", row->GetField(1),0);
				Trace("loadJavaScriptCheck() - replace", row->GetField(2),0);
				m_javascriptSearchList.push_back(row->GetFieldString(1));
				m_javascriptReplaceList.push_back(row->GetFieldString(2));
			}
		}

		strQuery = Format(SQL_WTT_JAVASCRIPT2, getPageID());
		if (ResultPtr result = connection->Query(strQuery))
		{
			Trace("RowPtr s:","",result->GetRowCount());

			while(result->Next())
			{
				RowPtr row = result->GetCurrentRow();

				// add to the list
				Trace("loadJavaScriptCheck() - search", row->GetField(1),0);
				Trace("loadJavaScriptCheck() - replace", row->GetField(2),0);
				m_javascriptSearchList.push_back(row->GetFieldString(1));
				m_javascriptReplaceList.push_back(row->GetFieldString(2));
			}
		}
	}
	catch (const std::exception& e)
	{
		LogError("Exception Caught:", e.what(), 0);
	}

	try
	{
		Mutex::Lock lock(m_javascriptExtractListLock);

		strQuery = Format(SQL_WTT_JAVASCRIPT3, getPageID());
		if (ResultPtr result = connection->Query(strQuery))
		{
			Trace("RowPtr s:","",result->GetRowCount());

			while(result->Next())
			{
				RowPtr row = result->GetCurrentRow();

				// add to the list
				Trace("loadJavaScriptCheck() - start", row->GetField(1),0);
				Trace("loadJavaScriptCheck() - end", row->GetField(2),0);
				m_javascriptStartList.push_back(row->GetFieldString(1));
				m_javascriptEndList.push_back(row->GetFieldString(2));
			}
		}
	}
	catch (const std::exception& e)
	{
		LogError("Exception Caught:", e.what(), 0);
	}
}