C++ Context::GetTmpStore方法代码示例

bool DummyDAImpl::DoExec(Context &context, ParameterMapper *in, ResultMapper *out) {
	StartTrace(DummyDAImpl.DoExecRecordOrTest);
	DAAccessTimer("DummyDAImpl.Exec", "DummyDAImpl.Exec writing", context);

	Anything tmpStore = context.GetTmpStore();

	// open test config file
	Anything recording;
	String str("Recording");
	Recording::ReadinRecording(str, recording);

	Trace("name: " << fName);

	String request;
	if (!BuildRequest(request, context, in)) {
		return false;
	}

	String theReply = GetReplyMatchingRequest(recording, context, request);
	if (TriggerEnabled(DummyDAImpl.DoExecRecordOrTest)) {
		String infoMsg = "\r\nReply from server ";
		infoMsg << theReply;
		SystemLog::Info(infoMsg); // perhaps enable this line with an entry in RequestLineRenderer.any.... future
	}
	if (!RenderReply(theReply, context, out)) {
		return false;
	}
	return true;
}

void FlowController::DoCleanupAfterStep(Context &ctx, ROAnything roaStepConfig) {
	StartTrace(FlowController.DoCleanupAfterStep);
	Anything tmpStore(ctx.GetTmpStore());
	SubTraceAny(TmpStore, ctx.GetTmpStore(), "TmpStore before");
	if (!roaStepConfig.IsNull()) {
		long sz = roaStepConfig.GetSize();
		for (long i = 0; i < sz; i++) {
			String slotName = roaStepConfig.SlotName(i);
			if (slotName) {
				Trace("Slotname to remove : " << slotName);
				tmpStore.Remove(slotName);
			}
		}
	}
	SubTraceAny(TmpStore, tmpStore, "TmpStore after");
}

String DummyDAImpl::GetReplyMatchingRequest(Anything &recording, Context &context, String &request) {
	long testStepNo = 0;
	Anything tmpStore(context.GetTmpStore());

	if (tmpStore.IsDefined("TestStepNo")) {
		testStepNo = tmpStore["TestStepNo"].AsLong(-1L);
		++testStepNo;
	}
	tmpStore["TestStepNo"] = testStepNo;

	Anything conv = Anything(testStepNo);
	String index = conv.AsString();

	if (recording[index].IsDefined("Request")) {
		String recordedRequest = recording[index]["Request"].AsString("");

		if (!recordedRequest.IsEqual(request)) {
			String eMsg = "Error: at index ";
			eMsg << index << " request did not match recorded request:" << request;
			SystemLog::Warning("Error: request did not match recorded request");
		}

		String eMsg = "Reply not found, index:";
		eMsg << index << " Request:" << request;
		// done this way because you don't write to any if you check first... which might be important in future...not now..
		if (!recording[index].IsDefined("Reply")) {
			return eMsg;
		}
		return recording[index]["Reply"].AsString(eMsg);
	} else {
		String eMsg = "Request not found, index:";
		eMsg << index << " Request:" << request;
		return eMsg;
	}
}

bool FlowController::PrepareRequest(Context &ctx) {
	StartTrace(FlowController.PrepareRequest);

	long reqNr = GetRequestNr(ctx);

	// number of runs of pre depends on number of slots in anything
	long nrOfPreRunRequests = fConfig["PreRun"].GetSize();

	Anything tmpStore = ctx.GetTmpStore();
	Anything flowState = tmpStore["FlowState"];
	if (!flowState["PreRunDone"].AsBool(1)) {
		Trace("PRE RUN NOT DONE ");

		if (reqNr < nrOfPreRunRequests) {
			DoPrepare(tmpStore, fConfig["PreRun"][reqNr]);
			flowState["RequestNr"] = ++reqNr;
			TraceAny(tmpStore["FlowState"], "Flow State on exit");
			return true;
		} else {
			// PreRun done , reset for normal run
			reqNr = 0;
			flowState["RunNr"] = 0L;
			flowState["PreRunDone"] = true;
		}
	}

	long nrOfRuns = 0;
	String appName;
	Application *application = Application::GetGlobalApplication(appName);
	if (application) {
		nrOfRuns = application->Lookup("NumberOfRuns", fConfig["NumberOfRuns"].AsLong(1));
		Trace(appName << " application found" );
	} else {
		nrOfRuns = fConfig["NumberOfRuns"].AsLong(1);
	}

	long runNr = flowState["RunNr"].AsLong(0);
	Trace("INIT Number of Run: " << runNr << " of " << nrOfRuns);

	while (runNr < nrOfRuns) { // loop thru steps and incr. runNr after each batch has been processed
		Trace("Number of Run: " << runNr << " of " << nrOfRuns);
		TraceAny(fConfig["Run"], "Config Run");
		long nrOfRequests = fConfig["Run"].GetSize();
		if (reqNr < nrOfRequests) {
			DoPrepare(tmpStore, fConfig["Run"][reqNr]);
			flowState["RequestNr"] = ++reqNr;
			TraceAny(tmpStore, "tmpStore on exit");
			TraceAny(tmpStore["FlowState"], "Flow State on exit");
			return true;
		}
		reqNr = 0; // reset request number
		flowState["RunNr"] = ++runNr;
	}

	TraceAny(tmpStore["FlowState"], "Flow State on exit with false");
	return false;
}

void FileAccessControllerTests::FileUDACTest() {
	StartTrace(FileAccessControllerTests.FileUDACTest);

	// create test file
	t_assertm(FileCreator::CreateFile("WriteUserData", GetConfig()["InitData"]["UDACTest"]), "Creation of test file failed");

	// do generic tests
	UserDataAccessController *fudac = UserDataAccessController::FindUserDataAccessController("UserDataFile");
	doTestUDAC(fudac);

	// check results
	Context c;
	t_assert(DataAccess("ReadUserData").StdExec(c));
	TraceAny(c.GetTmpStore()["FileContent"], "FileContentAfterTest");
	assertAnyEqual(GetConfig()["FileContent"]["UDACTest"], c.GetTmpStore()["FileContent"]);

	// clean up
	coast::system::io::unlink("config/FileTestUserDB.any");
}

void ConfiguredActionTest::DoTestWithContext(Anything testCase, const String &testCaseName, Context &ctx) {
	StartTrace(ConfiguredActionTest.DoTestWithContext);
	TraceAny(testCase, "Config of " << testCaseName);

	AlterTestStoreHook(testCase);
	coast::testframework::PutInStore(testCase["SessionStore"], ctx.GetSessionStore());
	coast::testframework::PutInStore(testCase["RoleStore"], ctx.GetRoleStoreGlobal());
	// Can not use real Session Store because Lookup does not find it ! - fix me
	TraceAny(ctx.GetRoleStoreGlobal(), "SessionStore");
	coast::testframework::PutInStore(testCase["TmpStore"], ctx.GetTmpStore());
	coast::testframework::PutInStore(testCase["Query"], ctx.GetQuery());
	coast::testframework::PutInStore(testCase["Env"], ctx.GetEnvStore());

	if (!testCase.IsDefined("Server") && GetConfig().IsDefined("Server")) {
		testCase["Server"] = GetConfig()["Server"].DeepClone();
	}
	if (testCase.IsDefined("Server")) {
		Server *s = Server::FindServer(testCase["Server"].AsCharPtr("Server"));
		ctx.SetServer(s);
	}
	if (testCase.IsDefined("Page")) {
		ctx.Push(testCase["Page"].AsCharPtr("Page"), Page::FindPage(testCase["Page"].AsCharPtr("Page")));
	}
	if (testCase.IsDefined("Role")) {
		ctx.Push(testCase["Role"].AsCharPtr("Role"), Role::FindRole(testCase["Role"].AsCharPtr("Role")));
	}
	TraceAny(testCase["TmpStore"], "Language");
	if (testCase["TmpStore"].IsDefined("Language")) {
		ctx.SetLanguage(testCase["TmpStore"]["Language"].AsCharPtr("D"));
	}

	bool expected = testCase["ExpectedResult"].AsBool(true);

	String token = testCase["StartToken"].AsString("TheAction");
	t_assertm(expected == Action::ExecAction(token, ctx, testCase["TheAction"]), (const char *)testCaseName);
	TraceAny(ctx.GetTmpStore(), "tmp store after action");
	String expectedToken = testCase["ExpectedToken"].AsString("TheAction");
	assertEqualm(expectedToken, token, (const char *)testCaseName);
}

void HTTPResponseMapperTest::TestBadResponseLine() {
	StartTrace(HTTPResponseMapperTest.TestBadResponseLine);
	String strIn("HTTP/1.1 ");
	IStringStream is(strIn);
	HTTPResponseMapper m("HTTPResponseMapper");
	m.Initialize("ResultMapper");
	Context ctx;
	t_assert(!m.Put("", is, ctx));
	Anything result(ctx.GetTmpStore()["Mapper"]["HTTPResponse"]);
	assertEqual(-1L, result[coast::http::constants::protocolCodeSlotname].AsLong(-1));
	assertEqual("undefined", result[coast::http::constants::protocolMsgSlotname].AsCharPtr("undefined"));
	assertEqual("HTTP/1.1", result[coast::http::constants::protocolVersionSlotname].AsCharPtr());
}

bool DummyDAImpl::BuildRequest(String &request, Context &context, ParameterMapper *in) {
	Anything tmpStore(context.GetTmpStore());
	StartTrace(DummyDAImpl.BuildRequest);
	{
		OStringStream os(&request);
		if (!in->Get("Input", os, context)) {
			return HandleError("Input Collection of ", context);
		}
	}
	if (TriggerEnabled(DummyDAImpl.BuildRequest)) {
		tmpStore["ParameterMapper"]["RequestMade"] = request;
	}
	return true; // request built successfully
}

void CookieToServerRenderer::RenderAll(std::ostream &reply, Context &c, const ROAnything &config) {
	StartTrace(CookieToServerRenderer.Render);
	//TraceAny(config, "config");
	// config not so interesting - does this renderer even have one??
	TraceAny( c.GetTmpStore(), "<<- Overall TMP Store" );

	String explicitDomainName = c.Lookup("CurrentServer.ServerName", "");
	explicitDomainName.ToUpper();
	// without Port part
	OutputCookies(explicitDomainName, reply, c);

	explicitDomainName << ":" << c.Lookup("CurrentServer.Port", "");

	// with Port part
	OutputCookies(explicitDomainName, reply, c);
}

void DataAccess::HandleError(Context &context, String mapperName, const char *file, long line, String msg)
{
	StartTrace(DataAccess.HandleError);
	// cut off path in file string (only output file)
	String filePath(file);
	long pos = filePath.StrRChr('\\');			// windows path?
	if (pos < 0) {
		pos = filePath.StrRChr('/');    // unix path?
	}

	String logMsg = (pos < 0) ? filePath : filePath.SubString(pos + 1);
	logMsg << ":" << line << " " << msg << " for [" << mapperName << "]";
	SystemLog::Error(logMsg);
	Trace(logMsg);
	context.GetTmpStore()["DataAccess"][mapperName]["Error"].Append(logMsg);
}

bool CallLDAPDAICacheAction::DoExecAction(String &action, Context &ctx, const ROAnything &config)
{
	// this is the new method that also gets a config ( similar to Renderer::RenderAll )
	// write the action code here - you don't have to override DoAction anymore
	StartTrace(CallLDAPDAICacheAction.DoExecAction);
	TraceAny(config, "config");

	ROAnything result;
	String key(config["Key"].AsString());
	String daName(config["Da"].AsString());
	bool ret = true;
	if (key == "*") {
		result = LDAPDAICacheGetter::GetAll(daName);
	} else {
		ret = LDAPDAICacheGetter::Get(result, daName, key);
	}
	ctx.GetTmpStore() = result.DeepClone();
	return ret;
}

bool HTTPHeaderParameterMapper::DoGetStream(const char *key, std::ostream &os, Context &ctx, ROAnything info) {
	StartTrace1(HTTPHeaderParameterMapper.DoGetStream, "Key:<" << NotNull(key) << ">");
	bool mapSuccess = true;
	ROAnything headerfields(ctx.Lookup(key));
	TraceAny(headerfields, "Headerfields available for key " << key);
	if (!headerfields.IsNull()) {
		String strFieldName;
		ROAnything roaValue;
		AnyExtensions::Iterator<ROAnything> headerIterator(headerfields);
		while (headerIterator.Next(roaValue)) {
			if (headerIterator.SlotName(strFieldName)) {
				strFieldName.ToUpper();
				String strKey(constants::suppressName);
				strKey.Append('.').Append(strFieldName);
				Trace("trying to Lookup [" << strKey << "] in own or config");
				// map non suppressed headerfields
				if (Lookup(strKey).AsLong(0L) == 0L) {
					Anything value;
					ROAnything rvalue;
					Trace("slot: " << strFieldName);
					if (!Get(strFieldName, value, ctx)) {
						rvalue = roaValue;
					} else {
						rvalue = value;
					}
					coast::http::putHeaderFieldToStream(os, ctx, strFieldName, rvalue);
				}
			}
		}
	} else {
		TraceAny(ctx.GetTmpStore(), "no headers, get ReqHeader in tmp store:");
		String strHeaderfields;
		if ((mapSuccess = Get("ReqHeader", strHeaderfields, ctx))) {
			os << strHeaderfields;
		}
	}
	Trace("retval: " << mapSuccess);
	return mapSuccess;
}

long FlowController::GetRequestNr(Context &ctx) {
	StartTrace(FlowController.GetRequestNr);
	// retrieve state from tempStore -- this is done to be thread safe
	// State contains
	// {
	//	/PreRunDone		True if prerun has run
	//	/RunNr			Number of the actual run
	//	/RequestNr		Number of the next request
	// }
	Anything tmpStore = ctx.GetTmpStore();

	// default built in tmpStore if no tmpStore built by previous step
	if (!tmpStore.IsDefined("FlowState")) {
		tmpStore["FlowState"]["RequestNr"] = 0L;
		tmpStore["FlowState"]["PreRunDone"] = false;
		tmpStore["FlowState"]["RunNr"] = 0L;
		//TraceAny(tmpStore["FlowState"],"Flow State initialized");
	}
	Anything flowState = tmpStore["FlowState"];

	// Check PreRun
	return flowState["RequestNr"].AsLong(0);

}

void LogTimerTest::MethodTimerTest() {
	StartTrace(LogTimerTest.MethodTimerTest);
	Context ctx;
	TimeLoggingModule::fgDoTiming = true;
	String msg("Test MethodTimer");
	{
		Anything expected = Anything(Anything::ArrayMarker());
		MethodTimer(NoResult, msg, ctx);
		assertAnyEqual(expected, ctx.GetTmpStore());
	}
	{
		Anything setup;
		setup["EnabledValues"]["Method"]["Test"] = true;
		setup["SimulatedValues"]["Method"]["Test"] = 10;
		Context::PushPopEntry<Anything> aEntry(ctx, "setup", setup);
		Anything expected;
		Anything data;
		data[TimeLogger::eSection] = "Method";
		data[TimeLogger::eKey] = "Test";
		data[TimeLogger::eTime] = 10L;
		data[TimeLogger::eMsg] = "Test MethodTimer";
		data[TimeLogger::eUnit] = "ms";
		data[TimeLogger::eNestingLevel] = 0L;
		expected["Log"]["Times"].Append(data);

		{
			// trigger the destructor by defining its own scope
			MethodTimer(Test, msg, ctx)
			;
		}
		assertAnyEqual(expected, ctx.GetTmpStore());
		TraceAny(ctx.GetTmpStore(), "TmpStore");
	}
	{
		ctx.GetTmpStore() = Anything(Anything::ArrayMarker());
		Anything setup;
		setup["EnabledValues"]["Method"]["Test"] = true;
		setup["SimulatedValues"]["Method"]["Test"] = 10;
		Context::PushPopEntry<Anything> aEntry(ctx, "setup", setup);
		Anything expected;
		Anything data;
		data[TimeLogger::eSection] = "Method";
		data[TimeLogger::eKey] = "Test";
		data[TimeLogger::eTime] = 10L;
		data[TimeLogger::eMsg] = "Test MethodTimer";
		data[TimeLogger::eUnit] = "ms";
		data[TimeLogger::eNestingLevel] = 0L;
		expected["Log"]["Times"].Append(data.DeepClone());
		expected["Log"]["Times"].Append(data.DeepClone());

		//call a method twice
		{
			// trigger the destructor by defining its own scope
			MethodTimer(Test, msg, ctx)
			;
		}
		{
			// trigger the destructor by defining its own scope
			MethodTimer(Test, msg, ctx)
			;
		}
		TraceAny(ctx.GetTmpStore(), "TmpStore");
		assertAnyEqual(expected, ctx.GetTmpStore());
	}
	{
		ctx.GetTmpStore() = Anything(Anything::ArrayMarker());
		Anything setup;
		setup["EnabledValues"]["Method"]["Test"]["SubA"] = true;
		setup["EnabledValues"]["Method"]["Test"]["SubB"] = true;
		setup["SimulatedValues"]["Method"]["Test"]["SubA"] = 10;
		setup["SimulatedValues"]["Method"]["Test"]["SubB"] = 10;
		Context::PushPopEntry<Anything> aEntry(ctx, "setup", setup);
		Anything expected;
		Anything dataA;
		dataA[TimeLogger::eSection] = "Method";
		dataA[TimeLogger::eKey] = "Test.SubA";
		dataA[TimeLogger::eTime] = 10L;
		dataA[TimeLogger::eMsg] = "Test MethodTimer";
		dataA[TimeLogger::eUnit] = "ms";
		dataA[TimeLogger::eNestingLevel] = 0L;
		Anything dataB(dataA.DeepClone());
		dataB[TimeLogger::eKey] = "Test.SubB";
		expected["Log"]["Times"].Append(dataA.DeepClone());
		expected["Log"]["Times"].Append(dataB.DeepClone());

		//call different methods of a class
		{
			// trigger the destructor by defining its own scope
			MethodTimer(Test.SubA, msg, ctx)
			;
		}
		{
			// trigger the destructor by defining its own scope
			MethodTimer(Test.SubB, msg, ctx)
			;
		}
		TraceAny(ctx.GetTmpStore(), "TmpStore");
		assertAnyEqual(expected, ctx.GetTmpStore());
	}
}

bool FileCreator::CreateFile(String dataAccessName, ROAnything data) {
	Context c;
	c.GetTmpStore()["FileContent"] = data.DeepClone();
	return DataAccess(dataAccessName).StdExec(c);
}