std::string CCafMessagePayloadParser::bufferToStr(
const SmartPtrCDynamicByteArray& payload) {
CAF_CM_STATIC_FUNC_VALIDATE("CCafMessagePayloadParser", "bufferToStr");
CAF_CM_VALIDATE_SMARTPTR(payload);
return reinterpret_cast<const char*>(payload->getPtr());
}
std::string CPayloadContentRouterInstance::calcOutputChannel(
const SmartPtrCDynamicByteArray& payload) const {
CAF_CM_FUNCNAME_VALIDATE("calcOutputChannel");
std::string outputChannel;
CAF_CM_ENTER {
CAF_CM_PRECOND_ISINITIALIZED(_isInitialized);
CAF_CM_VALIDATE_SMARTPTR(payload);
const std::string payloadStr = reinterpret_cast<const char*>(payload->getPtr());
CAF_CM_VALIDATE_STRING(payloadStr);
for(TConstIterator<Cmapstrstr> valueToChannelIter(_valueToChannelMapping); valueToChannelIter; valueToChannelIter++) {
const std::string value = valueToChannelIter->first;
SmartPtrCCafRegex regex;
regex.CreateInstance();
regex->initialize(value);
if (regex->isMatched(payloadStr)) {
outputChannel = valueToChannelIter->second;
CAF_CM_LOG_DEBUG_VA2("Matched channel - regex: %s, channel: %s", value.c_str(), outputChannel.c_str());
break;
}
}
}
CAF_CM_EXIT;
return outputChannel;
}
void CCafMessagePayload::saveToFile(
const SmartPtrCDynamicByteArray& payload,
const std::string& payloadPath) {
CAF_CM_STATIC_FUNC_VALIDATE("CCafMessagePayload", "saveToFile");
CAF_CM_VALIDATE_SMARTPTR(payload);
CAF_CM_VALIDATE_STRING(payloadPath);
FileSystemUtils::saveByteFile(payloadPath,
payload->getPtr(), payload->getByteCount());
}
SmartPtrIIntMessage COutgoingMessageHandler::rehydrateMultiPartMessage(
const SmartPtrCMessageDeliveryRecord& deliveryRecord,
const IIntMessage::SmartPtrCHeaders& addlHeaders) {
CAF_CM_STATIC_FUNC_LOG("COutgoingMessageHandler", "rehydrateMultiPartMessage");
CAF_CM_VALIDATE_SMARTPTR(deliveryRecord);
// addlHeaders are optional
uint32 payloadSize = CMessagePartsHeader::BLOCK_SIZE;
const std::deque<SmartPtrCMessagePartDescriptorSourceRecord> sourceRecords = deliveryRecord->getMessagePartSources();
for (TConstIterator<std::deque<SmartPtrCMessagePartDescriptorSourceRecord> > sourceRecordIter(sourceRecords);
sourceRecordIter; sourceRecordIter++) {
const SmartPtrCMessagePartDescriptorSourceRecord sourceRecord = *sourceRecordIter;
payloadSize += CMessagePartDescriptor::BLOCK_SIZE + sourceRecord->getDataLength();
}
SmartPtrCDynamicByteArray payload;
payload.CreateInstance();
payload->allocateBytes(payloadSize);
const SmartPtrCDynamicByteArray partsHeader = CMessagePartsHeader::toArray(
deliveryRecord->getCorrelationId(), deliveryRecord->getNumberOfParts());
payload->memAppend(partsHeader->getPtr(), partsHeader->getByteCount());
uint32 partNumber = deliveryRecord->getStartingPartNumber();
if (CAF_CM_IS_LOG_DEBUG_ENABLED) {
CAF_CM_LOG_DEBUG_VA3("[# sourceRecords=%d][payloadSize=%d][startingPartNumber=%d]",
sourceRecords.size(), payloadSize, partNumber);
}
for (TConstIterator<std::deque<SmartPtrCMessagePartDescriptorSourceRecord> > sourceRecordIter(sourceRecords);
sourceRecordIter; sourceRecordIter++) {
const SmartPtrCMessagePartDescriptorSourceRecord sourceRecord = *sourceRecordIter;
const SmartPtrCDynamicByteArray partDescriptor = CMessagePartDescriptor::toArray(
sourceRecord->getAttachmentNumber(), partNumber++, sourceRecord->getDataLength(),
sourceRecord->getDataOffset());
payload->memAppend(partDescriptor->getPtr(), partDescriptor->getByteCount());
CAF_CM_LOG_DEBUG_VA3("Reading from file - file: %s, len: %d, offset: %d",
sourceRecord->getFilePath().c_str(), sourceRecord->getDataLength(),
sourceRecord->getDataOffset());
std::ifstream file(sourceRecord->getFilePath().c_str(), std::ios::binary);
try {
if (!file.is_open()) {
CAF_CM_EXCEPTION_VA1(ERROR_FILE_NOT_FOUND,
"Could not open binary file - %s", sourceRecord->getFilePath().c_str());
}
file.seekg(sourceRecord->getDataOffset(), std::ios::beg);
file.read(reinterpret_cast<char*>(payload->getNonConstPtrAtCurrentPos()),
sourceRecord->getDataLength());
payload->verify();
if (! file) {
CAF_CM_EXCEPTION_VA3(ERROR_BUFFER_OVERFLOW,
"Did not read full contents - file: %s, requested: %d, read: %d",
sourceRecord->getFilePath().c_str(), sourceRecord->getDataLength(),
file.gcount());
}
payload->incrementCurrentPos(sourceRecord->getDataLength());
}
CAF_CM_CATCH_ALL;
file.close();
CAF_CM_LOG_CRIT_CAFEXCEPTION;
CAF_CM_THROWEXCEPTION;
}
SmartPtrCIntMessage rc;
rc.CreateInstance();
rc->initialize(payload, deliveryRecord->getMessageHeaders(), addlHeaders);
return rc;
}
void CProviderExecutorRequestHandler::processRequest(
const SmartPtrCProviderExecutorRequest& request) const {
CAF_CM_FUNCNAME_VALIDATE("processRequest");
CAF_CM_VALIDATE_SMARTPTR(request);
const std::string outputDir = request->getOutputDirectory();
SmartPtrCLoggingSetter loggingSetter;
loggingSetter.CreateInstance();
loggingSetter->initialize(outputDir);
SmartPtrIIntMessage message = request->getInternalRequest();
const std::string providerRequestPath = FileSystemUtils::buildPath(outputDir, _sProviderRequestFilename);
const std::string stdoutPath = FileSystemUtils::buildPath(outputDir, _sStdoutFilename);
const std::string stderrPath = FileSystemUtils::buildPath(outputDir, _sStderrFilename);
std::string newProviderRequestPath = FileSystemUtils::normalizePathWithForward(
providerRequestPath);
// Create temporary request file for use by the provider
CCafMessagePayload::saveToFile(message->getPayload(), newProviderRequestPath);
Cdeqstr argv;
argv.push_back(_providerPath);
argv.push_back("-r");
argv.push_back(newProviderRequestPath);
CAF_CM_LOG_INFO_VA2("Running command - %s -r %s", _providerPath.c_str(),
newProviderRequestPath.c_str());
ProcessUtils::Priority priority = ProcessUtils::NORMAL;
std::string appConfigPriority = AppConfigUtils::getOptionalString(_sManagementAgentArea, "provider_process_priority");
if (!appConfigPriority.empty()) {
if (CStringUtils::isEqualIgnoreCase("LOW", appConfigPriority)) {
priority = ProcessUtils::LOW;
} else if (CStringUtils::isEqualIgnoreCase("IDLE", appConfigPriority)) {
priority = ProcessUtils::IDLE;
}
}
// Begin impersonation
if (!_beginImpersonationTransformer.IsNull()) {
message = _beginImpersonationTransformer->transformMessage(message);
if (message.IsNull()) {
CAF_CM_LOG_WARN_VA0("Begin impersonation transform did not return a message");
}
}
{
CAF_CM_UNLOCK_LOCK;
ProcessUtils::runSyncToFiles(argv, stdoutPath, stderrPath, priority);
}
// End impersonation
if (!_endImpersonationTransformer.IsNull()) {
message = _endImpersonationTransformer->transformMessage(message);
if (message.IsNull()) {
CAF_CM_LOG_WARN_VA0("End impersonation transform did not return a message");
}
}
// Delete temporary request file used by the provider
if (FileSystemUtils::doesFileExist(newProviderRequestPath)) {
CAF_CM_LOG_INFO_VA1("Removing handler produced request file - %s", newProviderRequestPath.c_str());
FileSystemUtils::removeFile(newProviderRequestPath);
}
// Delete original request
const std::string originalFile = message->findOptionalHeaderAsString(FileHeaders::_sORIGINAL_FILE);
if (!originalFile.empty()) {
if (FileSystemUtils::doesFileExist(originalFile)) {
CAF_CM_LOG_INFO_VA1("Removing original file - %s", originalFile.c_str());
FileSystemUtils::removeFile(originalFile);
}
}
// Package response in envelope and write to global response location
const SmartPtrCProviderRequestDoc providerRequest =
CCafMessagePayloadParser::getProviderRequest(message->getPayload());
const SmartPtrCResponseDoc response = CResponseFactory::createResponse(providerRequest, outputDir);
const std::string relFilename = CStringUtils::createRandomUuid() + "_" + _sResponseFilename;
SmartPtrIIntMessage responseMessage = CCafMessageCreator::createPayloadEnvelope(
response, relFilename, message->getHeaders());
const std::string directory = AppConfigUtils::getRequiredString("response_dir");
const std::string filePath = FileSystemUtils::buildPath(directory, relFilename);
const SmartPtrCDynamicByteArray payload = responseMessage->getPayload();
FileSystemUtils::saveByteFile(filePath, payload->getPtr(), payload->getByteCount(),
FileSystemUtils::FILE_MODE_REPLACE, ".writing");
}