Aws::Map<Aws::String, DirectoryEntry> DirectoryTree::Diff(DirectoryTree& other)
{
Aws::Map<Aws::String, DirectoryEntry> thisEntries;
auto thisTraversal = [&thisEntries](const DirectoryTree*, const DirectoryEntry& entry)
{
thisEntries[entry.relativePath] = entry;
return true;
};
Aws::Map<Aws::String, DirectoryEntry> otherEntries;
auto otherTraversal = [&thisEntries, &otherEntries](const DirectoryTree*, const DirectoryEntry& entry)
{
auto thisEntry = thisEntries.find(entry.relativePath);
if (thisEntry != thisEntries.end())
{
thisEntries.erase(entry.relativePath);
}
else
{
otherEntries[entry.relativePath] = entry;
}
return true;
};
TraverseDepthFirst(thisTraversal);
other.TraverseDepthFirst(otherTraversal);
thisEntries.insert(otherEntries.begin(), otherEntries.end());
return thisEntries;
}
AttributeValue& AttributeValue::AddMEntry(const Aws::String& key, const std::shared_ptr<AttributeValue>& value)
{
if (!m_value)
{
Aws::Map<Aws::String, const std::shared_ptr<AttributeValue>> map;
auto kvp = std::pair<Aws::String, const std::shared_ptr<AttributeValue>>(key, value);
map.insert(map.begin(), kvp);
m_value = Aws::MakeShared<AttributeValueMap>("AttributeValue", map);
}
else
{
m_value->AddMEntry(key, value);
}
return *this;
}
void ProfileConfigFileAWSCredentialsProvider::RefreshIfExpired()
{
std::lock_guard<std::mutex> locker(m_reloadMutex);
if (!m_credentials || IsTimeToRefresh(m_loadFrequencyMs))
{
AWS_LOG_DEBUG(profileLogTag, "Refreshing credentials.");
Aws::Map<Aws::String, Aws::String> propertyValueMap = ParseProfileConfigFile(m_fileName);
Aws::String accessKey, secretKey, sessionToken;
auto accessKeyIter = propertyValueMap.find(m_profileToUse + ":" + AWS_ACCESS_KEY_ID);
auto secretKeyIter = propertyValueMap.find(m_profileToUse + ":" + AWS_SECRET_ACCESS_KEY);
auto sessionTokenIter = propertyValueMap.find(m_profileToUse + ":" + AWS_SESSION_TOKEN);
if (accessKeyIter != propertyValueMap.end())
accessKey = accessKeyIter->second;
else
AWS_LOG_INFO(profileLogTag, "Access key for profile not found.");
if (secretKeyIter != propertyValueMap.end())
secretKey = secretKeyIter->second;
else
AWS_LOG_INFO(profileLogTag, "Secret key for profile not found.");
if (sessionTokenIter != propertyValueMap.end())
sessionToken = sessionTokenIter->second;
else
AWS_LOG_INFO(profileLogTag, "Optional session token for profile not found.");
m_credentials = Aws::MakeShared<AWSCredentials>(profileLogTag, accessKey, secretKey, sessionToken);
}
}
void PersistLogins(const Aws::Map<Aws::String, LoginAccessTokens>& logins) override
{
SetLogins(logins);
m_loginsPersisted = !logins.empty();
if (m_loginsUpdatedCallback)
{
m_loginsUpdatedCallback(*this);
}
}
TEST_F(QueueOperationTest, TestSendReceiveDelete)
{
Aws::String queueName = BuildResourceName(BASE_SEND_RECEIVE_QUEUE_NAME);
Aws::String queueUrl = CreateDefaultQueue(queueName);
ASSERT_TRUE(queueUrl.find(queueName) != Aws::String::npos);
SendMessageRequest sendMessageRequest;
sendMessageRequest.SetMessageBody("TestMessageBody");
MessageAttributeValue stringAttributeValue;
stringAttributeValue.SetStringValue("TestString");
stringAttributeValue.SetDataType("String");
sendMessageRequest.AddMessageAttributes("TestStringAttribute", stringAttributeValue);
MessageAttributeValue binaryAttributeValue;
Aws::Utils::ByteBuffer byteBuffer(10);
for(unsigned i = 0; i < 10; ++i)
{
byteBuffer[i] = (unsigned char)i;
}
binaryAttributeValue.SetBinaryValue(byteBuffer);
binaryAttributeValue.SetDataType("Binary");
sendMessageRequest.AddMessageAttributes("TestBinaryAttribute", binaryAttributeValue);
sendMessageRequest.SetQueueUrl(queueUrl);
SendMessageOutcome sendMessageOutcome = sqsClient->SendMessage(sendMessageRequest);
ASSERT_TRUE(sendMessageOutcome.IsSuccess());
EXPECT_TRUE(sendMessageOutcome.GetResult().GetMessageId().length() > 0);
ReceiveMessageRequest receiveMessageRequest;
receiveMessageRequest.SetMaxNumberOfMessages(1);
receiveMessageRequest.SetQueueUrl(queueUrl);
receiveMessageRequest.AddMessageAttributeNames("All");
ReceiveMessageOutcome receiveMessageOutcome = sqsClient->ReceiveMessage(receiveMessageRequest);
ASSERT_TRUE(receiveMessageOutcome.IsSuccess());
ReceiveMessageResult receiveMessageResult = receiveMessageOutcome.GetResult();
ASSERT_EQ(1uL, receiveMessageResult.GetMessages().size());
EXPECT_EQ("TestMessageBody", receiveMessageResult.GetMessages()[0].GetBody());
Aws::Map<Aws::String, MessageAttributeValue> messageAttributes = receiveMessageResult.GetMessages()[0].GetMessageAttributes();
ASSERT_TRUE(messageAttributes.find("TestStringAttribute") != messageAttributes.end());
EXPECT_EQ(stringAttributeValue.GetStringValue(), messageAttributes["TestStringAttribute"].GetStringValue());
ASSERT_TRUE(messageAttributes.find("TestBinaryAttribute") != messageAttributes.end());
EXPECT_EQ(byteBuffer, messageAttributes["TestBinaryAttribute"].GetBinaryValue());
DeleteMessageRequest deleteMessageRequest;
deleteMessageRequest.SetQueueUrl(queueUrl);
deleteMessageRequest.SetReceiptHandle(receiveMessageResult.GetMessages()[0].GetReceiptHandle());
DeleteMessageOutcome deleteMessageOutcome = sqsClient->DeleteMessage(deleteMessageRequest);
ASSERT_TRUE(deleteMessageOutcome.IsSuccess());
receiveMessageOutcome = sqsClient->ReceiveMessage(receiveMessageRequest);
EXPECT_EQ(0uL, receiveMessageOutcome.GetResult().GetMessages().size());
DeleteQueueRequest deleteQueueRequest;
deleteQueueRequest.WithQueueUrl(queueUrl);
DeleteQueueOutcome deleteQueueOutcome = sqsClient->DeleteQueue(deleteQueueRequest);
ASSERT_TRUE(deleteQueueOutcome.IsSuccess());
}
