intermediate changes

ref:cde9a383711a11544ce7e107a78147fb96cc4029

8 files changed, 834 insertions, 0 deletions

diff --git a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventDecoderStream.cpp b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventDecoderStream.cpp
new file mode 100644
index 0000000000..5ecd2d0444
--- /dev/null
+++ b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventDecoderStream.cpp
@@ -0,0 +1,22 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+#include <aws/core/utils/event/EventDecoderStream.h>
+#include <iostream>
+
+namespace Aws
+{
+    namespace Utils
+    {
+        namespace Event
+        {
+            EventDecoderStream::EventDecoderStream(EventStreamDecoder& decoder, size_t bufferSize) :
+                Aws::IOStream(&m_eventStreamBuf),
+                m_eventStreamBuf(decoder, bufferSize)
+
+            {
+            }
+        }
+    }
+}
diff --git a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventEncoderStream.cpp b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventEncoderStream.cpp
new file mode 100644
index 0000000000..f8640f0e8c
--- /dev/null
+++ b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventEncoderStream.cpp
@@ -0,0 +1,28 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+#include <aws/core/utils/event/EventEncoderStream.h>
+#include <iostream>
+
+namespace Aws
+{
+    namespace Utils
+    {
+        namespace Event
+        {
+            EventEncoderStream::EventEncoderStream(size_t bufferSize) :
+                Aws::IOStream(&m_streambuf),
+                m_streambuf(bufferSize)
+            {
+            }
+
+            EventEncoderStream& EventEncoderStream::WriteEvent(const Aws::Utils::Event::Message& msg)
+            {
+                auto bits = m_encoder.EncodeAndSign(msg);
+                write(reinterpret_cast<char*>(bits.data()), bits.size());
+                return *this;
+            }
+        }
+    }
+}
diff --git a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventHeader.cpp b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventHeader.cpp
new file mode 100644
index 0000000000..c3c989bedb
--- /dev/null
+++ b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventHeader.cpp
@@ -0,0 +1,107 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/core/utils/event/EventHeader.h>
+#include <aws/core/utils/HashingUtils.h>
+
+namespace Aws
+{
+    namespace Utils
+    {
+        namespace Event
+        {
+            static const int HASH_BOOL_TRUE = HashingUtils::HashString("BOOL_TRUE");
+            static const int HASH_BOOL_FALSE = HashingUtils::HashString("BOOL_FALSE");
+            static const int HASH_BYTE = HashingUtils::HashString("BYTE");
+            static const int HASH_INT16 = HashingUtils::HashString("INT16");
+            static const int HASH_INT32 = HashingUtils::HashString("INT32");
+            static const int HASH_INT64 = HashingUtils::HashString("INT64");
+            static const int HASH_BYTE_BUF = HashingUtils::HashString("BYTE_BUFFER");
+            static const int HASH_STRING = HashingUtils::HashString("STRING");
+            static const int HASH_TIMESTAMP = HashingUtils::HashString("TIMESTAMP");
+            static const int HASH_UUID = HashingUtils::HashString("UUID");
+
+            EventHeaderValue::EventHeaderType EventHeaderValue::GetEventHeaderTypeForName(const Aws::String& name)
+            {
+                int hashCode = Aws::Utils::HashingUtils::HashString(name.c_str());
+                if (hashCode == HASH_BOOL_TRUE)
+                {
+                    return EventHeaderType::BOOL_TRUE;
+                }
+                else if (hashCode == HASH_BOOL_FALSE)
+                {
+                    return EventHeaderType::BOOL_FALSE;
+                }
+                else if (hashCode == HASH_BYTE)
+                {
+                    return EventHeaderType::BYTE;
+                }
+                else if (hashCode == HASH_INT16)
+                {
+                    return EventHeaderType::INT16;
+                }
+                else if (hashCode == HASH_INT32)
+                {
+                    return EventHeaderType::INT32;
+                }
+                else if (hashCode == HASH_INT64)
+                {
+                    return EventHeaderType::INT64;
+                }
+                else if (hashCode == HASH_BYTE_BUF)
+                {
+                    return EventHeaderType::BYTE_BUF;
+                }
+                else if (hashCode == HASH_STRING)
+                {
+                    return EventHeaderType::STRING;
+                }
+                else if (hashCode == HASH_TIMESTAMP)
+                {
+                    return EventHeaderType::TIMESTAMP;
+                }
+                else if (hashCode == HASH_UUID)
+                {
+                    return EventHeaderType::UUID;
+                }
+                else
+                {
+                    return EventHeaderType::UNKNOWN;
+                }
+            }
+
+            Aws::String EventHeaderValue::GetNameForEventHeaderType(EventHeaderType value)
+            {
+                switch (value)
+                {
+                case EventHeaderType::BOOL_TRUE:
+                    return "BOOL_TRUE";
+                case EventHeaderType::BOOL_FALSE:
+                    return "BOOL_FALSE";
+                case EventHeaderType::BYTE:
+                    return "BYTE";
+                case EventHeaderType::INT16:
+                    return "INT16";
+                case EventHeaderType::INT32:
+                    return "INT32";
+                case EventHeaderType::INT64:
+                    return "INT64";
+                case EventHeaderType::BYTE_BUF:
+                    return "BYTE_BUF";
+                case EventHeaderType::STRING:
+                    return "STRING";
+                case EventHeaderType::TIMESTAMP:
+                    return "TIMESTAMP";
+                case EventHeaderType::UUID:
+                    return "UUID";
+                default:
+                    return "UNKNOWN";
+                }
+            }
+
+        }
+    }
+}
+
diff --git a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventMessage.cpp b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventMessage.cpp
new file mode 100644
index 0000000000..de8b904775
--- /dev/null
+++ b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventMessage.cpp
@@ -0,0 +1,132 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/core/utils/event/EventMessage.h>
+#include <aws/core/utils/HashingUtils.h>
+#include <algorithm>
+#include <iterator>
+
+namespace Aws
+{
+    namespace Utils
+    {
+        namespace Event
+        {
+            const char EVENT_TYPE_HEADER[] = ":event-type";
+            const char CONTENT_TYPE_HEADER[] = ":content-type";
+            const char MESSAGE_TYPE_HEADER[] = ":message-type";
+            const char ERROR_CODE_HEADER[] = ":error-code";
+            const char ERROR_MESSAGE_HEADER[] = ":error-message";
+            const char EXCEPTION_TYPE_HEADER[] = ":exception-type";
+
+            static const int EVENT_HASH = HashingUtils::HashString("event");
+            static const int ERROR_HASH = HashingUtils::HashString("error");
+            static const int EXCEPTION_HASH = HashingUtils::HashString("exception");
+
+            static const int CONTENT_TYPE_APPLICATION_OCTET_STREAM_HASH = HashingUtils::HashString("application/octet-stream");
+            static const int CONTENT_TYPE_APPLICATION_JSON_HASH = HashingUtils::HashString("application/json");
+            static const int CONTENT_TYPE_TEXT_PLAIN_HASH = HashingUtils::HashString("text/plain");
+
+            Message::MessageType Message::GetMessageTypeForName(const Aws::String& name)
+            {
+                int hashCode = Aws::Utils::HashingUtils::HashString(name.c_str());
+                if (hashCode == EVENT_HASH)
+                {
+                    return MessageType::EVENT;
+                }
+                else if (hashCode == ERROR_HASH)
+                {
+                    return MessageType::REQUEST_LEVEL_ERROR;
+                }
+                else if (hashCode == EXCEPTION_HASH)
+                {
+                    return MessageType::REQUEST_LEVEL_EXCEPTION;
+                }
+                else
+                {
+                    return MessageType::UNKNOWN;
+                }
+            }
+
+            Aws::String Message::GetNameForMessageType(MessageType value)
+            {
+                switch (value)
+                {
+                case MessageType::EVENT:
+                    return "event";
+                case MessageType::REQUEST_LEVEL_ERROR:
+                    return "error";
+                case MessageType::REQUEST_LEVEL_EXCEPTION:
+                    return "exception";
+                default:
+                    return "unknown";
+                }
+            }
+
+            Message::ContentType Message::GetContentTypeForName(const Aws::String& name)
+            {
+                int hashCode = Aws::Utils::HashingUtils::HashString(name.c_str());
+                if (hashCode == CONTENT_TYPE_APPLICATION_OCTET_STREAM_HASH)
+                {
+                    return ContentType::APPLICATION_OCTET_STREAM;
+                }
+                else if (hashCode == CONTENT_TYPE_APPLICATION_JSON_HASH)
+                {
+                    return ContentType::APPLICATION_JSON;
+                }
+                else if (hashCode == CONTENT_TYPE_TEXT_PLAIN_HASH)
+                {
+                    return ContentType::TEXT_PLAIN;
+                }
+                else
+                {
+                    return ContentType::UNKNOWN;
+                }
+            }
+
+            Aws::String Message::GetNameForContentType(ContentType value)
+            {
+                switch (value)
+                {
+                case ContentType::APPLICATION_OCTET_STREAM:
+                    return "application/octet-stream";
+                case ContentType::APPLICATION_JSON:
+                    return "application/json";
+                case ContentType::TEXT_PLAIN:
+                    return "text/plain";
+                default:
+                    return "unknown";
+                }
+            }
+
+            void Message::Reset()
+            {
+                m_totalLength = 0;
+                m_headersLength = 0;
+                m_payloadLength = 0;
+
+                m_eventHeaders.clear();
+                m_eventPayload.clear();
+            }
+
+            void Message::WriteEventPayload(const unsigned char* data, size_t length)
+            {
+                std::copy(data, data + length, std::back_inserter(m_eventPayload));
+            }
+
+            void Message::WriteEventPayload(const Aws::Vector<unsigned char>& bits)
+            {
+                std::copy(bits.cbegin(), bits.cend(), std::back_inserter(m_eventPayload));
+            }
+
+            void Message::WriteEventPayload(const Aws::String& bits)
+            {
+                std::copy(bits.cbegin(), bits.cend(), std::back_inserter(m_eventPayload));
+            }
+
+        } // namespace Event
+    } // namespace Utils
+} // namespace Aws
+
diff --git a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventStreamBuf.cpp b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventStreamBuf.cpp
new file mode 100644
index 0000000000..6a1766bb9f
--- /dev/null
+++ b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventStreamBuf.cpp
@@ -0,0 +1,147 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+#include <aws/core/utils/event/EventStreamBuf.h>
+#include <cassert>
+
+namespace Aws
+{
+    namespace Utils
+    {
+        namespace Event
+        {
+            const size_t DEFAULT_BUF_SIZE = 1024;
+
+            EventStreamBuf::EventStreamBuf(EventStreamDecoder& decoder, size_t bufferLength) :
+                m_byteBuffer(bufferLength),
+                m_bufferLength(bufferLength),
+                m_decoder(decoder)
+            {
+                assert(decoder);
+                char* begin = reinterpret_cast<char*>(m_byteBuffer.GetUnderlyingData());
+                char* end = begin + bufferLength - 1;
+
+                setp(begin, end);
+                setg(begin, begin, begin);
+            }
+
+            EventStreamBuf::~EventStreamBuf()
+            {
+                if (m_decoder)
+                {
+                    writeToDecoder();
+                }
+            }
+
+            void EventStreamBuf::writeToDecoder()
+            {
+                if (pptr() > pbase())
+                {
+                    size_t length = static_cast<size_t>(pptr() - pbase());
+                    m_decoder.Pump(m_byteBuffer, length);
+
+                    if (!m_decoder)
+                    {
+                        m_err.write(reinterpret_cast<char*>(m_byteBuffer.GetUnderlyingData()), length);
+                    }
+                    else
+                    {
+                        pbump(-static_cast<int>(length));
+                    }
+                }
+            }
+
+            std::streampos EventStreamBuf::seekoff(std::streamoff off, std::ios_base::seekdir dir, std::ios_base::openmode which)
+            {
+                if (dir == std::ios_base::beg)
+                {
+                    return seekpos(off, which);
+                }
+                else if (dir == std::ios_base::end)
+                {
+                    return seekpos(m_bufferLength - 1 - off, which);
+                }
+                else if (dir == std::ios_base::cur)
+                {
+                    if (which == std::ios_base::in)
+                    {
+                        return seekpos((gptr() - (char*)m_byteBuffer.GetUnderlyingData()) + off, which);
+                    }
+                    if (which == std::ios_base::out)
+                    {
+                        return seekpos((pptr() - (char*)m_byteBuffer.GetUnderlyingData()) + off, which);
+                    }
+                }
+
+                return std::streamoff(-1);
+            }
+
+            std::streampos EventStreamBuf::seekpos(std::streampos pos, std::ios_base::openmode which)
+            {
+                assert(static_cast<size_t>(pos) <= m_bufferLength);
+                if (static_cast<size_t>(pos) > m_bufferLength)
+                {
+                    return std::streampos(std::streamoff(-1));
+                }
+
+                if (which == std::ios_base::in)
+                {
+                    m_err.seekg(pos);
+                    return m_err.tellg();
+                }
+
+                if (which == std::ios_base::out)
+                {
+                    return pos;
+                }
+
+                return std::streampos(std::streamoff(-1));
+            }
+
+            int EventStreamBuf::underflow()
+            {
+                if (!m_err || m_err.eof() || m_decoder)
+                {
+                    return std::char_traits<char>::eof();
+                }
+
+                m_err.flush();
+                m_err.read(reinterpret_cast<char*>(m_byteBuffer.GetUnderlyingData()), m_byteBuffer.GetLength());
+
+                char* begin = reinterpret_cast<char*>(m_byteBuffer.GetUnderlyingData());
+                setg(begin, begin, begin + m_err.gcount());
+                return std::char_traits<char>::to_int_type(*gptr());
+            }
+
+            int EventStreamBuf::overflow(int ch)
+            {
+                auto eof = std::char_traits<char>::eof();
+
+                if (m_decoder)
+                {
+                    if (ch != eof)
+                    {
+                        *pptr() = (char)ch;
+                        pbump(1);
+                    }
+
+                    writeToDecoder();
+                    return ch;
+                }
+
+                return eof;
+            }
+
+            int EventStreamBuf::sync()
+            {
+                if (m_decoder)
+                {
+                    writeToDecoder();
+                }
+
+                return 0;
+            }
+        }
+    }
+}
diff --git a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventStreamDecoder.cpp b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventStreamDecoder.cpp
new file mode 100644
index 0000000000..f70a6c88f6
--- /dev/null
+++ b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventStreamDecoder.cpp
@@ -0,0 +1,170 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/common/common.h>
+#include <aws/core/utils/event/EventHeader.h>
+#include <aws/core/utils/event/EventMessage.h>
+#include <aws/core/utils/event/EventStreamDecoder.h>
+#include <aws/core/utils/logging/LogMacros.h>
+#include <aws/core/utils/UnreferencedParam.h>
+#include <aws/core/utils/memory/AWSMemory.h>
+
+namespace Aws
+{
+    namespace Utils
+    {
+        namespace Event
+        {
+            static const char EVENT_STREAM_DECODER_CLASS_TAG[] = "Aws::Utils::Event::EventStreamDecoder";
+
+            EventStreamDecoder::EventStreamDecoder(EventStreamHandler* handler) : m_eventStreamHandler(handler)
+            {
+                aws_event_stream_streaming_decoder_init(&m_decoder,
+                    get_aws_allocator(),
+                    onPayloadSegment,
+                    onPreludeReceived,
+                    onHeaderReceived,
+                    onError,
+                    (void*)handler);
+            }
+
+            EventStreamDecoder::~EventStreamDecoder()
+            {
+                aws_event_stream_streaming_decoder_clean_up(&m_decoder);
+            }
+
+            void EventStreamDecoder::Pump(const ByteBuffer& data)
+            {
+                Pump(data, data.GetLength());
+            }
+
+            void EventStreamDecoder::Pump(const ByteBuffer& data, size_t length)
+            {
+                aws_byte_buf dataBuf = aws_byte_buf_from_array(static_cast<uint8_t*>(data.GetUnderlyingData()), length);
+                aws_event_stream_streaming_decoder_pump(&m_decoder, &dataBuf);
+            }
+
+            void EventStreamDecoder::Reset()
+            {
+                m_eventStreamHandler->Reset();
+            }
+
+            void EventStreamDecoder::ResetEventStreamHandler(EventStreamHandler* handler)
+            {
+                aws_event_stream_streaming_decoder_init(&m_decoder, get_aws_allocator(),
+                    onPayloadSegment,
+                    onPreludeReceived,
+                    onHeaderReceived,
+                    onError,
+                    reinterpret_cast<void *>(handler));
+            }
+
+            void EventStreamDecoder::onPayloadSegment(
+                aws_event_stream_streaming_decoder* decoder,
+                aws_byte_buf* payload,
+                int8_t isFinalSegment,
+                void* context)
+            {
+                AWS_UNREFERENCED_PARAM(decoder);
+                auto handler = static_cast<EventStreamHandler*>(context);
+                assert(handler);
+                if (!handler)
+                {
+                    AWS_LOGSTREAM_ERROR(EVENT_STREAM_DECODER_CLASS_TAG, "Payload received, but decoder encountered internal errors before."
+                        "ErrorCode: " << EventStreamErrorsMapper::GetNameForError(handler->GetInternalError()) << ", "
+                        "ErrorMessage: " << handler->GetEventPayloadAsString());
+                    return;
+                }
+                handler->WriteMessageEventPayload(static_cast<unsigned char*>(payload->buffer), payload->len);
+
+                // Complete payload received
+                if (isFinalSegment == 1)
+                {
+                    assert(handler->IsMessageCompleted());
+                    handler->OnEvent();
+                    handler->Reset();
+                }
+            }
+
+            void EventStreamDecoder::onPreludeReceived(
+                aws_event_stream_streaming_decoder* decoder,
+                aws_event_stream_message_prelude* prelude,
+                void* context)
+            {
+                AWS_UNREFERENCED_PARAM(decoder);
+                auto handler = static_cast<EventStreamHandler*>(context);
+                handler->Reset();
+                
+                //Encounter internal error in prelude received.
+                //This error will be handled by OnError callback function later.
+                if (prelude->total_len < prelude->headers_len + 16)
+                {
+                    return;
+                }
+                handler->SetMessageMetadata(prelude->total_len, prelude->headers_len,
+                    prelude->total_len - prelude->headers_len - 4/*total byte-length*/ - 4/*headers byte-length*/ - 4/*prelude crc*/ - 4/*message crc*/);
+                AWS_LOGSTREAM_TRACE(EVENT_STREAM_DECODER_CLASS_TAG, "Message received, the expected length of the message is: " << prelude->total_len <<
+                                                                    " bytes, and the expected length of the header is: " << prelude->headers_len << " bytes");
+
+                //Handle empty message 
+                //if (handler->m_message.GetHeadersLength() == 0 && handler->m_message.GetPayloadLength() == 0)
+                if (handler->IsMessageCompleted())
+                {
+                    handler->OnEvent();
+                    handler->Reset();
+                }
+            }
+
+            void EventStreamDecoder::onHeaderReceived(
+                aws_event_stream_streaming_decoder* decoder,
+                aws_event_stream_message_prelude* prelude,
+                aws_event_stream_header_value_pair* header,
+                void* context)
+            {
+                AWS_UNREFERENCED_PARAM(decoder);
+                AWS_UNREFERENCED_PARAM(prelude);
+                auto handler = static_cast<EventStreamHandler*>(context);
+                assert(handler);
+                if (!handler)
+                {
+                    AWS_LOGSTREAM_ERROR(EVENT_STREAM_DECODER_CLASS_TAG, "Payload received, but decoder encountered internal errors before."
+                        "ErrorCode: " << EventStreamErrorsMapper::GetNameForError(handler->GetInternalError()) << ", "
+                        "ErrorMessage: " << handler->GetEventPayloadAsString());
+                    return;
+                }
+
+                // The length of a header = 1 byte (to represent the length of header name) + length of header name + 1 byte (to represent header type)
+                //                          + 2 bytes (to represent length of header value) + length of header value
+                handler->InsertMessageEventHeader(Aws::String(header->header_name, header->header_name_len),
+                    1 + header->header_name_len + 1 + 2 + header->header_value_len, EventHeaderValue(header));
+
+                // Handle messages only have headers, but without payload.
+                //if (handler->m_message.GetHeadersLength() == handler->m_headersBytesReceived() && handler->m_message.GetPayloadLength() == 0)
+                if (handler->IsMessageCompleted())
+                {
+                    handler->OnEvent();
+                    handler->Reset();
+                }
+            }
+
+            void EventStreamDecoder::onError(
+                aws_event_stream_streaming_decoder* decoder,
+                aws_event_stream_message_prelude* prelude,
+                int error_code,
+                const char* message,
+                void* context)
+            {
+                AWS_UNREFERENCED_PARAM(decoder);
+                AWS_UNREFERENCED_PARAM(prelude);
+                auto handler = static_cast<EventStreamHandler*>(context);
+                handler->SetFailure();
+                handler->SetInternalError(error_code);
+                handler->WriteMessageEventPayload(reinterpret_cast<const unsigned char*>(message), strlen(message));
+                handler->OnEvent();
+            }
+        } // namespace Event
+    } // namespace Utils
+} // namespace Aws
+
diff --git a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventStreamEncoder.cpp b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventStreamEncoder.cpp
new file mode 100644
index 0000000000..ef7104e839
--- /dev/null
+++ b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventStreamEncoder.cpp
@@ -0,0 +1,162 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/core/utils/event/EventHeader.h>
+#include <aws/core/utils/event/EventMessage.h>
+#include <aws/core/utils/event/EventStreamEncoder.h>
+#include <aws/core/utils/logging/LogMacros.h>
+#include <aws/core/auth/AWSAuthSigner.h>
+#include <aws/common/byte_order.h>
+#include <aws/core/utils/memory/AWSMemory.h>
+
+#include <cassert>
+
+namespace Aws
+{
+    namespace Utils
+    {
+        namespace Event
+        {
+            static const char TAG[] = "EventStreamEncoder";
+
+            static void EncodeHeaders(const Aws::Utils::Event::Message& msg, aws_array_list* headers)
+            {
+                aws_array_list_init_dynamic(headers, get_aws_allocator(), msg.GetEventHeaders().size(), sizeof(aws_event_stream_header_value_pair));
+                for (auto&& header : msg.GetEventHeaders())
+                {
+                    const uint8_t headerKeyLen = static_cast<uint8_t>(header.first.length());
+                    switch(header.second.GetType())
+                    {
+                        case EventHeaderValue::EventHeaderType::BOOL_TRUE:
+                        case EventHeaderValue::EventHeaderType::BOOL_FALSE:
+                            aws_event_stream_add_bool_header(headers, header.first.c_str(), headerKeyLen, header.second.GetEventHeaderValueAsBoolean());
+                            break;
+                        case EventHeaderValue::EventHeaderType::BYTE:
+                            aws_event_stream_add_bool_header(headers, header.first.c_str(), headerKeyLen, header.second.GetEventHeaderValueAsByte());
+                            break;
+                        case EventHeaderValue::EventHeaderType::INT16:
+                            aws_event_stream_add_int16_header(headers, header.first.c_str(), headerKeyLen, header.second.GetEventHeaderValueAsInt16());
+                            break;
+                        case EventHeaderValue::EventHeaderType::INT32:
+                            aws_event_stream_add_int32_header(headers, header.first.c_str(), headerKeyLen, header.second.GetEventHeaderValueAsInt32());
+                            break;
+                        case EventHeaderValue::EventHeaderType::INT64:
+                            aws_event_stream_add_int64_header(headers, header.first.c_str(), headerKeyLen, header.second.GetEventHeaderValueAsInt64());
+                            break;
+                        case EventHeaderValue::EventHeaderType::BYTE_BUF:
+                            {
+                                const auto& bytes = header.second.GetEventHeaderValueAsBytebuf();
+                                aws_event_stream_add_bytebuf_header(headers, header.first.c_str(), headerKeyLen, bytes.GetUnderlyingData(), static_cast<uint16_t>(bytes.GetLength()), 1 /*copy*/);
+                            }
+                            break;
+                        case EventHeaderValue::EventHeaderType::STRING:
+                            {
+                                const auto& bytes = header.second.GetUnderlyingBuffer();
+                                aws_event_stream_add_string_header(headers, header.first.c_str(), headerKeyLen, reinterpret_cast<char*>(bytes.GetUnderlyingData()), static_cast<uint16_t>(bytes.GetLength()), 0 /*copy*/);
+                            }
+                            break;
+                        case EventHeaderValue::EventHeaderType::TIMESTAMP:
+                            aws_event_stream_add_timestamp_header(headers, header.first.c_str(), headerKeyLen, header.second.GetEventHeaderValueAsTimestamp());
+                            break;
+                        case EventHeaderValue::EventHeaderType::UUID:
+                            {
+                                ByteBuffer uuidBytes = header.second.GetEventHeaderValueAsUuid();
+                                aws_event_stream_add_uuid_header(headers, header.first.c_str(), headerKeyLen, uuidBytes.GetUnderlyingData());
+                            }
+                            break;
+                        default:
+                            AWS_LOG_ERROR(TAG, "Encountered unknown type of header.");
+                            break;
+                    }
+                }
+            }
+
+            EventStreamEncoder::EventStreamEncoder(Client::AWSAuthSigner* signer) : m_signer(signer)
+            {
+            }
+
+
+            Aws::Vector<unsigned char> EventStreamEncoder::EncodeAndSign(const Aws::Utils::Event::Message& msg)
+            {
+                aws_event_stream_message encoded = Encode(msg);
+                aws_event_stream_message signedMessage = Sign(&encoded);
+
+                const auto signedMessageLength = signedMessage.message_buffer ? aws_event_stream_message_total_length(&signedMessage) : 0;
+
+                Aws::Vector<unsigned char> outputBits(signedMessage.message_buffer, signedMessage.message_buffer + signedMessageLength);
+                aws_event_stream_message_clean_up(&encoded);
+                aws_event_stream_message_clean_up(&signedMessage);
+                return outputBits;
+            }
+
+            aws_event_stream_message EventStreamEncoder::Encode(const Aws::Utils::Event::Message& msg)
+            {
+                aws_array_list headers;
+                EncodeHeaders(msg, &headers);
+
+                aws_byte_buf payload;
+                payload.len = msg.GetEventPayload().size();
+                // this const_cast is OK because aws_byte_buf will only be "read from" by the following functions.
+                payload.buffer = const_cast<uint8_t*>(msg.GetEventPayload().data());
+                payload.capacity = 0;
+                payload.allocator = nullptr;
+
+                aws_event_stream_message encoded;
+                if(aws_event_stream_message_init(&encoded, get_aws_allocator(), &headers, &payload) == AWS_OP_ERR)
+                {
+                    AWS_LOGSTREAM_ERROR(TAG, "Error creating event-stream message from payload.");
+                    aws_event_stream_headers_list_cleanup(&headers);
+                    // GCC 4.9.4 issues a warning with -Wextra if we simply do
+                    // return {};
+                    aws_event_stream_message empty{nullptr, nullptr, 0};
+                    return empty;
+                }
+                aws_event_stream_headers_list_cleanup(&headers);
+                return encoded;
+            }
+
+            aws_event_stream_message EventStreamEncoder::Sign(aws_event_stream_message* msg)
+            {
+                const auto msglen = msg->message_buffer ? aws_event_stream_message_total_length(msg) : 0;
+                Event::Message signedMessage;
+                signedMessage.WriteEventPayload(msg->message_buffer, msglen);
+
+                assert(m_signer);
+                if (!m_signer->SignEventMessage(signedMessage, m_signatureSeed))
+                {
+                    AWS_LOGSTREAM_ERROR(TAG, "Failed to sign event message frame.");
+                    // GCC 4.9.4 issues a warning with -Wextra if we simply do
+                    // return {};
+                    aws_event_stream_message empty{nullptr, nullptr, 0};
+                    return empty;
+                }
+
+                aws_array_list headers;
+                EncodeHeaders(signedMessage, &headers);
+
+                aws_byte_buf payload;
+                payload.len = signedMessage.GetEventPayload().size();
+                payload.buffer = signedMessage.GetEventPayload().data();
+                payload.capacity = 0;
+                payload.allocator = nullptr;
+
+                aws_event_stream_message signedmsg;
+                if(aws_event_stream_message_init(&signedmsg, get_aws_allocator(), &headers, &payload))
+                {
+                    AWS_LOGSTREAM_ERROR(TAG, "Error creating event-stream message from payload.");
+                    aws_event_stream_headers_list_cleanup(&headers);
+                    // GCC 4.9.4 issues a warning with -Wextra if we simply do
+                    // return {};
+                    aws_event_stream_message empty{nullptr, nullptr, 0};
+                    return empty;
+                }
+                aws_event_stream_headers_list_cleanup(&headers);
+                return signedmsg;
+            }
+
+        } // namespace Event
+    } // namespace Utils
+} // namespace Aws
+
diff --git a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventStreamErrors.cpp b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventStreamErrors.cpp
new file mode 100644
index 0000000000..836d0b47c5
--- /dev/null
+++ b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventStreamErrors.cpp
@@ -0,0 +1,66 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+#include <aws/core/client/AWSError.h>
+#include <aws/core/utils/HashingUtils.h>
+#include <aws/core/utils/event/EventStreamErrors.h>
+
+ using namespace Aws::Client;
+// using namespace Aws::S3;
+// using namespace Aws::Utils;
+
+namespace Aws
+{
+    namespace Utils
+    {
+        namespace Event
+        {
+            namespace EventStreamErrorsMapper
+            {
+                /*
+                static const int EVENT_STREAM_NO_ERROR_HASH = HashingUtils::HashString("EventStreamNoError");
+                static const int EVENT_STREAM_BUFFER_LENGTH_MISMATCH_HASH = HashingUtils::HashString("EventStreamBufferLengthMismatch");
+                static const int EVENT_STREAM_INSUFFICIENT_BUFFER_LEN_HASH = HashingUtils::HashString("EventStreamInsufficientBufferLen");
+                static const int EVENT_STREAM_MESSAGE_FIELD_SIZE_EXCEEDED_HASH = HashingUtils::HashString("EventStreamMessageFieldSizeExceeded");
+                static const int EVENT_STREAM_PRELUDE_CHECKSUM_FAILURE_HASH = HashingUtils::HashString("EventStreamPreludeChecksumFailure");
+                static const int EVENT_STREAM_MESSAGE_CHECKSUM_FAILURE_HASH = HashingUtils::HashString("EventStreamMessageChecksumFailure");
+                static const int EVENT_STREAM_MESSAGE_INVALID_HEADERS_LEN_HASH = HashingUtils::HashString("EventStreamMessageInvalidHeadersLen");
+                static const int EVENT_STREAM_MESSAGE_UNKNOWN_HEADER_TYPE_HASH = HashingUtils::HashString("EventStreamMessageUnknownHeaderType");
+                static const int EVENT_STREAM_MESSAGE_PARSER_ILLEGAL_STATE_HASH = HashingUtils::HashString("EventStreamMessageParserIllegalState");
+                */
+                const char* GetNameForError(EventStreamErrors error)
+                {
+                    switch (error)
+                    {
+                    case EventStreamErrors::EVENT_STREAM_NO_ERROR:
+                        return "EventStreamNoError";
+                    case EventStreamErrors::EVENT_STREAM_BUFFER_LENGTH_MISMATCH:
+                        return "EventStreamBufferLengthMismatch";
+                    case EventStreamErrors::EVENT_STREAM_INSUFFICIENT_BUFFER_LEN:
+                        return "EventStreamInsufficientBufferLen";
+                    case EventStreamErrors::EVENT_STREAM_MESSAGE_FIELD_SIZE_EXCEEDED:
+                        return "EventStreamMessageFieldSizeExceeded";
+                    case EventStreamErrors::EVENT_STREAM_PRELUDE_CHECKSUM_FAILURE:
+                        return "EventStreamPreludeChecksumFailure";
+                    case EventStreamErrors::EVENT_STREAM_MESSAGE_CHECKSUM_FAILURE:
+                        return "EventStreamMessageChecksumFailure";
+                    case EventStreamErrors::EVENT_STREAM_MESSAGE_INVALID_HEADERS_LEN:
+                        return "EventStreamMessageInvalidHeadersLen";
+                    case EventStreamErrors::EVENT_STREAM_MESSAGE_UNKNOWN_HEADER_TYPE:
+                        return "EventStreamMessageUnknownHeaderType";
+                    case EventStreamErrors::EVENT_STREAM_MESSAGE_PARSER_ILLEGAL_STATE:
+                        return "EventStreamMessageParserIllegalState";
+                    default:
+                        return "EventStreamUnknownError";
+                    }
+                }
+
+                AWSError<CoreErrors> GetAwsErrorForEventStreamError(EventStreamErrors error)
+                {
+                    return AWSError<CoreErrors>(CoreErrors::UNKNOWN, GetNameForError(error), "", false);
+                }
+            } // namespace EventStreamErrorsMapper
+        } // namespace Event
+    } // namespace Utils
+} // namespace Aws