diff --git a/attachments/nano_attachment/CMakeLists.txt b/attachments/nano_attachment/CMakeLists.txt index fdd41ec..1bbbeb9 100644 --- a/attachments/nano_attachment/CMakeLists.txt +++ b/attachments/nano_attachment/CMakeLists.txt @@ -20,6 +20,8 @@ add_library( nano_attachment_thread.c nano_attachment_sender.c nano_attachment_sender_thread.c + nano_attachment_sender_async.c + nano_attachment_bucket.c nano_attachment_metric.c nano_compression.c ) diff --git a/attachments/nano_attachment/nano_attachment.c b/attachments/nano_attachment/nano_attachment.c index 7aa6746..1ccd63e 100755 --- a/attachments/nano_attachment/nano_attachment.c +++ b/attachments/nano_attachment/nano_attachment.c @@ -10,6 +10,7 @@ #include "nano_attachment_sender.h" #include "nano_attachment_metric.h" +#include "nano_attachment_bucket.h" #include "nano_initializer.h" #include "nano_configuration.h" #include "nano_utils.h" @@ -120,6 +121,15 @@ RestartAttachmentConfiguration(NanoAttachment *attachment) return reset_attachment_config(attachment); }; +int +GetCommSocket(NanoAttachment *attachment) +{ + if (attachment == NULL) { + return -1; + } + return attachment->comm_socket; +} + HttpSessionData * InitSessionData(NanoAttachment *attachment, SessionID session_id) { @@ -225,6 +235,74 @@ SendDataNanoAttachment(NanoAttachment *attachment, AttachmentData *data) return response; } +NanoCommunicationResult +SendDataNanoAttachmentAsync(NanoAttachment *attachment, AttachmentData *data) +{ + switch (data->chunk_type) { + case HTTP_REQUEST_FILTER: { + return SendRequestFilterAsync(attachment, data); + } + case HTTP_REQUEST_METADATA: { + return SendMetadataAsync(attachment, data); + } + case HTTP_REQUEST_HEADER: { + return SendRequestHeadersAsync(attachment, data); + } + case HTTP_REQUEST_BODY: { + return SendRequestBodyAsync(attachment, data); + } + case HTTP_REQUEST_END: { + return SendRequestEndAsync(attachment, data); + } + case HTTP_RESPONSE_HEADER: { + return SendResponseHeadersAsync(attachment, data); + } + case HTTP_RESPONSE_BODY: { + return SendResponseBodyAsync(attachment, data); + } + case HTTP_RESPONSE_END: { + return SendResponseEndAsync(attachment, data); + } + default: + break; + } + + return NANO_OK; +} + +// TODO: Implement +// Check if the queue is empty, return true if yes - otherwise false. +bool +isQueueEmpty(NanoAttachment *attachment) +{ + return false; +} + +// TODO: Implement +// [hash on session id] -> [verdict+modification] +// Updating the table, and then return the session ID to the caller +SessionID +PopFromQueue(NanoAttachment *attachment) +{ + + return session_id; +} + +// TODO: Implement +// given a sessionID return a verdict from the table. +AttachmentVerdictResponse +getAttachmentVerdictResponse(NanoAttachment *attachment, SessionID session_id) +{ + (void)attachment; + (void)session_id; + return (AttachmentVerdictResponse) { + .verdict = ATTACHMENT_VERDICT_INSPECT, + .session_id = session_id, + .modifications = NULL + }; +} + + /// /// @brief Connects to the keep-alive socket. /// diff --git a/attachments/nano_attachment/nano_attachment_bucket.c b/attachments/nano_attachment/nano_attachment_bucket.c new file mode 100644 index 0000000..21b0b40 --- /dev/null +++ b/attachments/nano_attachment/nano_attachment_bucket.c @@ -0,0 +1 @@ +#include "nano_attachment_bucket.h" diff --git a/attachments/nano_attachment/nano_attachment_bucket.h b/attachments/nano_attachment/nano_attachment_bucket.h new file mode 100644 index 0000000..6069899 --- /dev/null +++ b/attachments/nano_attachment/nano_attachment_bucket.h @@ -0,0 +1,8 @@ +/// @file nano_attachment_bucket.h +#ifndef __NANO_ATTACHMENT_BUCKET_H__ +#define __NANO_ATTACHMENT_BUCKET_H__ + +#include "nano_attachment_common.h" +#include "nano_initializer.h" + +#endif // __NANO_ATTACHMENT_BUCKET_H__ diff --git a/attachments/nano_attachment/nano_attachment_sender.c b/attachments/nano_attachment/nano_attachment_sender.c index f071674..c5a6716 100644 --- a/attachments/nano_attachment/nano_attachment_sender.c +++ b/attachments/nano_attachment/nano_attachment_sender.c @@ -4,6 +4,7 @@ #include #include "nano_attachment_sender_thread.h" +#include "nano_attachment_sender_async.h" #include "nano_attachment_thread.h" #include "nano_utils.h" #include "nano_attachment_metric.h" @@ -317,7 +318,7 @@ HandleDelayedVerdict( sleep(attachment->hold_verdict_polling_time); write_dbg(attachment, session_id, DBG_LEVEL_DEBUG, "spawn SendDelayedVerdictRequestThread"); res = NanoRunInThreadTimeout( - attachment, + attachment, data, SendDelayedVerdictRequestThread, (void *)ctx, @@ -783,6 +784,360 @@ SendResponseEnd(NanoAttachment *attachment, AttachmentData *data) return FinalizeSuccessfulResponse(attachment, session_id, &ctx); } +NanoCommunicationResult +SendRequestFilterAsync(NanoAttachment *attachment, AttachmentData *data) +{ + if (attachment == NULL || data == NULL) { + return NANO_ERROR; + } + + HttpSessionData *session_data_p = data->session_data; + if (session_data_p == NULL) { + return NANO_ERROR; + } + + SessionID session_id = session_data_p->session_id; + HttpRequestFilterData *start_data = (HttpRequestFilterData*)data->data; + if (start_data == NULL) { + write_dbg( + attachment, + session_id, + DBG_LEVEL_WARNING, + "NULL start_data in SendRequestFilterAsync for session ID: %d", + session_id + ); + return NANO_ERROR; + } + + write_dbg( + attachment, + session_id, + DBG_LEVEL_DEBUG, + "Request filter handling session ID: %d", + session_id + ); + + if (handle_shmem_corruption(attachment) == NANO_ERROR) { + write_dbg( + attachment, + session_id, + DBG_LEVEL_WARNING, + "Failed to handle shmem corruption in session ID: %d", + session_id + ); + return NANO_ERROR; + } + + return SendRequestFilterAsyncImpl(attachment, session_data_p, start_data); +} + +NanoCommunicationResult +SendMetadataAsync(NanoAttachment *attachment, AttachmentData *data) +{ + if (attachment == NULL || data == NULL) { + return NANO_ERROR; + } + + HttpSessionData *session_data_p = data->session_data; + if (session_data_p == NULL) { + return NANO_ERROR; + } + + SessionID session_id = session_data_p->session_id; + HttpMetaData *metadata = (HttpMetaData*)data->data; + if (metadata == NULL) { + write_dbg( + attachment, + session_id, + DBG_LEVEL_WARNING, + "NULL metadata in SendMetadataAsync for session ID: %d", + session_id + ); + return NANO_ERROR; + } + + write_dbg( + attachment, + session_id, + DBG_LEVEL_DEBUG, + "Metadata handling session ID: %d", + session_id + ); + + if (handle_shmem_corruption(attachment) == NANO_ERROR) { + write_dbg( + attachment, + session_id, + DBG_LEVEL_WARNING, + "Failed to handle shmem corruption in session ID: %d", + session_id + ); + return NANO_ERROR; + } + + return SendMetadataAsyncImpl(attachment, session_data_p, metadata); +} + +NanoCommunicationResult +SendRequestHeadersAsync(NanoAttachment *attachment, AttachmentData *data) +{ + if (attachment == NULL || data == NULL) { + return NANO_ERROR; + } + + HttpSessionData *session_data_p = data->session_data; + if (session_data_p == NULL) { + return NANO_ERROR; + } + + SessionID session_id = session_data_p->session_id; + HttpHeaders *headers = (HttpHeaders*)data->data; + if (headers == NULL) { + write_dbg( + attachment, + session_id, + DBG_LEVEL_WARNING, + "NULL headers in SendRequestHeadersAsync for session ID: %d", + session_id + ); + return NANO_ERROR; + } + + write_dbg( + attachment, + session_id, + DBG_LEVEL_DEBUG, + "Request headers handling session ID: %d", + session_id + ); + + if (handle_shmem_corruption(attachment) == NANO_ERROR) { + write_dbg( + attachment, + session_id, + DBG_LEVEL_WARNING, + "Failed to handle shmem corruption in session ID: %d", + session_id + ); + return NANO_ERROR; + } + + return SendRequestHeadersAsyncImpl(attachment, session_data_p, headers); +} + +NanoCommunicationResult +SendRequestBodyAsync(NanoAttachment *attachment, AttachmentData *data) +{ + if (attachment == NULL || data == NULL) { + return NANO_ERROR; + } + + HttpSessionData *session_data_p = data->session_data; + if (session_data_p == NULL) { + return NANO_ERROR; + } + + SessionID session_id = session_data_p->session_id; + NanoHttpBody *bodies = (NanoHttpBody*)data->data; + if (bodies == NULL) { + write_dbg( + attachment, + session_id, + DBG_LEVEL_WARNING, + "NULL bodies in SendRequestBodyAsync for session ID: %d", + session_id + ); + return NANO_ERROR; + } + + write_dbg( + attachment, + session_id, + DBG_LEVEL_DEBUG, + "Request body handling session ID: %d", + session_id + ); + + if (handle_shmem_corruption(attachment) == NANO_ERROR) { + write_dbg( + attachment, + session_id, + DBG_LEVEL_WARNING, + "Failed to handle shmem corruption in session ID: %d", + session_id + ); + return NANO_ERROR; + } + + return SendRequestBodyAsyncImpl(attachment, session_data_p, bodies); +} + +NanoCommunicationResult +SendRequestEndAsync(NanoAttachment *attachment, AttachmentData *data) +{ + if (attachment == NULL || data == NULL) { + return NANO_ERROR; + } + + HttpSessionData *session_data_p = data->session_data; + if (session_data_p == NULL) { + return NANO_ERROR; + } + + SessionID session_id = session_data_p->session_id; + + write_dbg( + attachment, + session_id, + DBG_LEVEL_DEBUG, + "Request end handling session ID: %d", + session_id + ); + + if (handle_shmem_corruption(attachment) == NANO_ERROR) { + write_dbg( + attachment, + session_id, + DBG_LEVEL_WARNING, + "Failed to handle shmem corruption in session ID: %d", + session_id + ); + return NANO_ERROR; + } + + return SendRequestEndAsyncImpl(attachment, session_data_p); +} + +NanoCommunicationResult +SendResponseHeadersAsync(NanoAttachment *attachment, AttachmentData *data) +{ + if (attachment == NULL || data == NULL) { + return NANO_ERROR; + } + + HttpSessionData *session_data_p = data->session_data; + if (session_data_p == NULL) { + return NANO_ERROR; + } + + SessionID session_id = session_data_p->session_id; + ResHttpHeaders *headers = (ResHttpHeaders*)data->data; + if (headers == NULL) { + write_dbg( + attachment, + session_id, + DBG_LEVEL_WARNING, + "NULL headers in SendResponseHeadersAsync for session ID: %d", + session_id + ); + return NANO_ERROR; + } + + write_dbg( + attachment, + session_id, + DBG_LEVEL_DEBUG, + "Response headers handling session ID: %d", + session_id + ); + + if (handle_shmem_corruption(attachment) == NANO_ERROR) { + write_dbg( + attachment, + session_id, + DBG_LEVEL_WARNING, + "Failed to handle shmem corruption in session ID: %d", + session_id + ); + return NANO_ERROR; + } + + return SendResponseHeadersAsyncImpl(attachment, session_data_p, headers); +} + +NanoCommunicationResult +SendResponseBodyAsync(NanoAttachment *attachment, AttachmentData *data) +{ + if (attachment == NULL || data == NULL) { + return NANO_ERROR; + } + + HttpSessionData *session_data_p = data->session_data; + if (session_data_p == NULL) { + return NANO_ERROR; + } + + SessionID session_id = session_data_p->session_id; + NanoHttpBody *bodies = (NanoHttpBody*)data->data; + if (bodies == NULL) { + write_dbg( + attachment, + session_id, + DBG_LEVEL_WARNING, + "NULL bodies in SendResponseBodyAsync for session ID: %d", + session_id + ); + return NANO_ERROR; + } + + write_dbg( + attachment, + session_id, + DBG_LEVEL_DEBUG, + "Response body handling session ID: %d", + session_id + ); + + if (handle_shmem_corruption(attachment) == NANO_ERROR) { + write_dbg( + attachment, + session_id, + DBG_LEVEL_WARNING, + "Failed to handle shmem corruption in session ID: %d", + session_id + ); + return NANO_ERROR; + } + + return SendResponseBodyAsyncImpl(attachment, session_data_p, bodies); +} + +NanoCommunicationResult +SendResponseEndAsync(NanoAttachment *attachment, AttachmentData *data) +{ + if (attachment == NULL || data == NULL) { + return NANO_ERROR; + } + + HttpSessionData *session_data_p = data->session_data; + if (session_data_p == NULL) { + return NANO_ERROR; + } + + SessionID session_id = session_data_p->session_id; + + write_dbg( + attachment, + session_id, + DBG_LEVEL_DEBUG, + "Response end handling session ID: %d", + session_id + ); + + if (handle_shmem_corruption(attachment) == NANO_ERROR) { + write_dbg( + attachment, + session_id, + DBG_LEVEL_WARNING, + "Failed to handle shmem corruption in session ID: %d", + session_id + ); + return NANO_ERROR; + } + + return SendResponseEndAsyncImpl(attachment, session_data_p); +} + NanoCommunicationResult SendMetricData(NanoAttachment *attachment) { diff --git a/attachments/nano_attachment/nano_attachment_sender.h b/attachments/nano_attachment/nano_attachment_sender.h index 5e0b68a..73f9617 100644 --- a/attachments/nano_attachment/nano_attachment_sender.h +++ b/attachments/nano_attachment/nano_attachment_sender.h @@ -124,6 +124,86 @@ AttachmentVerdictResponse SendRequestEnd(NanoAttachment *attachment, AttachmentD /// AttachmentVerdictResponse SendResponseEnd(NanoAttachment *attachment, AttachmentData *data); +/// +/// @brief Sends request filter data to the nano service asynchronously. +/// +/// @param attachment A pointer to the NanoAttachment structure. +/// @param data A pointer to AttachmentData structure containing the data to send and the session data. +/// +/// @return A NanoCommunicationResult indicating the outcome of the operation. +/// +NanoCommunicationResult SendRequestFilterAsync(NanoAttachment *attachment, AttachmentData *data); + +/// +/// @brief Sends start request data to the nano service asynchronously. +/// +/// @param attachment A pointer to the NanoAttachment structure. +/// @param data A pointer to AttachmentData structure containing the data to send and the session data. +/// +/// @return A NanoCommunicationResult indicating the outcome of the operation. +/// +NanoCommunicationResult SendMetadataAsync(NanoAttachment *attachment, AttachmentData *data); + +/// +/// @brief Sends request headers to the nano service asynchronously. +/// +/// @param attachment A pointer to the NanoAttachment structure. +/// @param data A pointer to AttachmentData structure containing the headers to send and the session data. +/// +/// @return A NanoCommunicationResult indicating the outcome of the operation. +/// +NanoCommunicationResult SendRequestHeadersAsync(NanoAttachment *attachment, AttachmentData *data); + +/// +/// @brief Sends response headers to the nano service asynchronously. +/// +/// @param attachment A pointer to the NanoAttachment structure. +/// @param data A pointer to AttachmentData structure containing the headers to send and the session data. +/// +/// @return A NanoCommunicationResult indicating the outcome of the operation. +/// +NanoCommunicationResult SendResponseHeadersAsync(NanoAttachment *attachment, AttachmentData *data); + +/// +/// @brief Sends request body to the nano service asynchronously. +/// +/// @param attachment A pointer to the NanoAttachment structure. +/// @param data A pointer to AttachmentData structure containing the body to send and the session data. +/// +/// @return A NanoCommunicationResult indicating the outcome of the operation. +/// +NanoCommunicationResult SendRequestBodyAsync(NanoAttachment *attachment, AttachmentData *data); + +/// +/// @brief Sends response body to the nano service asynchronously. +/// +/// @param attachment A pointer to the NanoAttachment structure. +/// @param data A pointer to AttachmentData structure containing the body to send and the session data. +/// +/// @return A NanoCommunicationResult indicating the outcome of the operation. +/// +NanoCommunicationResult SendResponseBodyAsync(NanoAttachment *attachment, AttachmentData *data); + +/// +/// @brief Sends end request signal to the nano service asynchronously. +/// +/// @param attachment A pointer to the NanoAttachment structure. +/// @param data A pointer to AttachmentData structure containing the necessery data to send and the session data. +/// +/// @return A NanoCommunicationResult indicating the outcome of the operation. +/// +NanoCommunicationResult SendRequestEndAsync(NanoAttachment *attachment, AttachmentData *data); + +/// +/// @brief Sends end response signal to the nano service asynchronously. +/// +/// @param attachment A pointer to the NanoAttachment structure. +/// @param data A pointer to AttachmentData structure containing the necessery data to send and the session data. +/// +/// @return A NanoCommunicationResult indicating the outcome of the operation. +/// +NanoCommunicationResult SendResponseEndAsync(NanoAttachment *attachment, AttachmentData *data); + /// /// @brief Sends metric data to the nano service and resets it on the attachment. /// diff --git a/attachments/nano_attachment/nano_attachment_sender_async.c b/attachments/nano_attachment/nano_attachment_sender_async.c new file mode 100644 index 0000000..73a69f5 --- /dev/null +++ b/attachments/nano_attachment/nano_attachment_sender_async.c @@ -0,0 +1,148 @@ +#include "nano_attachment_sender_async.h" + +#include "nano_attachment_common.h" +#include "nano_initializer.h" + +NanoCommunicationResult +RegistrationCommSocketAsyncImpl( + NanoAttachment *attachment, + HttpSessionData *session_data_p +) +{ + (void)attachment; + (void)session_data_p; + return NANO_OK; +} + +NanoCommunicationResult +RegistrationSocketAsyncImpl( + NanoAttachment *attachment, + HttpSessionData *session_data_p +) +{ + (void)attachment; + (void)session_data_p; + return NANO_OK; +} + +NanoCommunicationResult +SendRequestFilterAsyncImpl( + NanoAttachment *attachment, + HttpSessionData *session_data_p, + HttpRequestFilterData *start_data +) +{ + (void)attachment; + (void)session_data_p; + (void)start_data; + return NANO_OK; +} + +NanoCommunicationResult +SendMetadataAsyncImpl( + NanoAttachment *attachment, + HttpSessionData *session_data_p, + HttpMetaData *metadata +) +{ + (void)attachment; + (void)session_data_p; + (void)metadata; + return NANO_OK; +} + +NanoCommunicationResult +SendRequestHeadersAsyncImpl( + NanoAttachment *attachment, + HttpSessionData *session_data_p, + HttpHeaders *headers +) +{ + (void)attachment; + (void)session_data_p; + (void)headers; + return NANO_OK; +} + +NanoCommunicationResult +SendResponseHeadersAsyncImpl( + NanoAttachment *attachment, + HttpSessionData *session_data_p, + ResHttpHeaders *headers +) +{ + (void)attachment; + (void)session_data_p; + (void)headers; + return NANO_OK; +} + +NanoCommunicationResult +SendRequestBodyAsyncImpl( + NanoAttachment *attachment, + HttpSessionData *session_data_p, + NanoHttpBody *bodies +) +{ + (void)attachment; + (void)session_data_p; + (void)bodies; + return NANO_OK; +} + +NanoCommunicationResult +SendResponseBodyAsyncImpl( + NanoAttachment *attachment, + HttpSessionData *session_data_p, + NanoHttpBody *bodies +) +{ + (void)attachment; + (void)session_data_p; + (void)bodies; + return NANO_OK; +} + +NanoCommunicationResult +SendRequestEndAsyncImpl( + NanoAttachment *attachment, + HttpSessionData *session_data_p +) +{ + (void)attachment; + (void)session_data_p; + return NANO_OK; +} + +NanoCommunicationResult +SendResponseEndAsyncImpl( + NanoAttachment *attachment, + HttpSessionData *session_data_p +) +{ + (void)attachment; + (void)session_data_p; + return NANO_OK; +} + +NanoCommunicationResult +SendDelayedVerdictRequestAsyncImpl( + NanoAttachment *attachment, + HttpSessionData *session_data_p +) +{ + (void)attachment; + (void)session_data_p; + return NANO_OK; +} + +NanoCommunicationResult +SendMetricToServiceAsyncImpl( + NanoAttachment *attachment, + HttpSessionData *session_data_p +) +{ + (void)attachment; + (void)session_data_p; + return NANO_OK; +} diff --git a/attachments/nano_attachment/nano_attachment_sender_async.h b/attachments/nano_attachment/nano_attachment_sender_async.h new file mode 100644 index 0000000..ad27d82 --- /dev/null +++ b/attachments/nano_attachment/nano_attachment_sender_async.h @@ -0,0 +1,203 @@ +#ifndef __NANO_ATTACHMENT_SENDER_ASYNC_H__ +#define __NANO_ATTACHMENT_SENDER_ASYNC_H__ + +#include "nano_attachment_common.h" +#include "nano_initializer.h" + +/// +/// @brief Connect attachment communication socket to the nano service. +/// +/// @param attachment A pointer to a NanoAttachment structure. +/// @param session_data_p A pointer to HttpSessionData structure. +/// +/// @return #NANO_OK on success. +/// +NanoCommunicationResult RegistrationCommSocketAsyncImpl( + NanoAttachment *attachment, + HttpSessionData *session_data_p +); + +/// +/// @brief Connect attachment to registration socket to the nano service. +/// +/// @param attachment A pointer to a NanoAttachment structure. +/// @param session_data_p A pointer to HttpSessionData structure. +/// +/// @return #NANO_OK on success. +/// +NanoCommunicationResult RegistrationSocketAsyncImpl( + NanoAttachment *attachment, + HttpSessionData *session_data_p +); + +/// +/// @brief Sends request start data to the nano service. +/// +/// This async function sends metadata to start a request interaction with the nano service. +/// +/// @param attachment A pointer to a NanoAttachment structure. +/// @param session_data_p A pointer to HttpSessionData structure. +/// @param metadata A pointer to HttpMetaData structure. +/// +/// @return #NANO_OK on success. +/// +NanoCommunicationResult SendMetadataAsyncImpl( + NanoAttachment *attachment, + HttpSessionData *session_data_p, + HttpMetaData *metadata +); + +/// +/// @brief Sends request headers to the nano service. +/// +/// This async function sends request headers to the nano service. It updates the session data +/// and handles any errors that occur during the header sending process. +/// +/// @param attachment A pointer to a NanoAttachment structure. +/// @param session_data_p A pointer to HttpSessionData structure. +/// @param headers A pointer to HttpHeaders structure. +/// +/// @return #NANO_OK on success. +/// +NanoCommunicationResult SendRequestHeadersAsyncImpl( + NanoAttachment *attachment, + HttpSessionData *session_data_p, + HttpHeaders *headers +); + +/// +/// @brief Sends response headers to the nano service. +/// +/// This async function sends response headers to the nano service. It updates the session data +/// and handles any errors that occur during the header sending process. +/// +/// @param attachment A pointer to a NanoAttachment structure. +/// @param session_data_p A pointer to HttpSessionData structure. +/// @param headers A pointer to ResHttpHeaders structure. +/// +/// @return #NANO_OK on success. +/// +NanoCommunicationResult SendResponseHeadersAsyncImpl( + NanoAttachment *attachment, + HttpSessionData *session_data_p, + ResHttpHeaders *headers +); + +/// +/// @brief Sends request body to the nano service. +/// +/// This async function sends request body to the nano service. It updates the session data +/// and handles any errors that occur during the body sending process. +/// +/// @param attachment A pointer to a NanoAttachment structure. +/// @param session_data_p A pointer to HttpSessionData structure. +/// @param bodies A pointer to NanoHttpBody structure. +/// +/// @return #NANO_OK on success. +/// +NanoCommunicationResult SendRequestBodyAsyncImpl( + NanoAttachment *attachment, + HttpSessionData *session_data_p, + NanoHttpBody *bodies +); + +/// +/// @brief Sends response body to the nano service. +/// +/// This async function sends response body to the nano service. It updates the session data +/// and handles any errors that occur during the body sending process. +/// +/// @param attachment A pointer to a NanoAttachment structure. +/// @param session_data_p A pointer to HttpSessionData structure. +/// @param bodies A pointer to NanoHttpBody structure. +/// +/// @return #NANO_OK on success. +/// +NanoCommunicationResult SendResponseBodyAsyncImpl( + NanoAttachment *attachment, + HttpSessionData *session_data_p, + NanoHttpBody *bodies +); + +/// +/// @brief Sends request end data to the nano service. +/// +/// This async function sends signal to the nano service that the request has ended +/// and with it the whole session transaction. +/// +/// @param attachment A pointer to a NanoAttachment structure. +/// @param session_data_p A pointer to HttpSessionData structure. +/// +/// @return #NANO_OK on success. +/// +NanoCommunicationResult SendRequestEndAsyncImpl( + NanoAttachment *attachment, + HttpSessionData *session_data_p +); + +/// +/// @brief Sends response end data to the nano service. +/// +/// This async function sends signal to the nano service that the response has ended +/// and with it the whole session transaction. +/// +/// @param attachment A pointer to a NanoAttachment structure. +/// @param session_data_p A pointer to HttpSessionData structure. +/// +/// @return #NANO_OK on success. +/// +NanoCommunicationResult SendResponseEndAsyncImpl( + NanoAttachment *attachment, + HttpSessionData *session_data_p +); + +/// +/// @brief Async function to send request filters. +/// +/// This async function sends metadata, request headers and end request +/// to the nano service. It updates the session data and handles any errors +/// that occur during the header sending process. +/// +/// @param attachment A pointer to a NanoAttachment structure. +/// @param session_data_p A pointer to HttpSessionData structure. +/// @param start_data A pointer to HttpRequestFilterData structure. +/// +/// @return #NANO_OK on success. +/// +NanoCommunicationResult SendRequestFilterAsyncImpl( + NanoAttachment *attachment, + HttpSessionData *session_data_p, + HttpRequestFilterData *start_data +); + +/// +/// @brief Send query for requesting delayed data verdict. +/// +/// This async function sends a delayed data query to the service and waits for the response. +/// +/// @param attachment A pointer to a NanoAttachment structure. +/// @param session_data_p A pointer to HttpSessionData structure. +/// +/// @return #NANO_OK on success. +/// +NanoCommunicationResult SendDelayedVerdictRequestAsyncImpl( + NanoAttachment *attachment, + HttpSessionData *session_data_p +); + +/// +/// @brief Send data metric to the service. +/// +/// This async function sends data metric to the service and resets it. +/// +/// @param attachment A pointer to a NanoAttachment structure. +/// @param session_data_p A pointer to HttpSessionData structure. +/// +/// @return #NANO_OK on success. +/// +NanoCommunicationResult SendMetricToServiceAsyncImpl( + NanoAttachment *attachment, + HttpSessionData *session_data_p +); + +#endif // __NANO_ATTACHMENT_SENDER_ASYNC_H__ diff --git a/core/include/attachments/nano_attachment.h b/core/include/attachments/nano_attachment.h index bd1d710..f98d5ee 100755 --- a/core/include/attachments/nano_attachment.h +++ b/core/include/attachments/nano_attachment.h @@ -40,6 +40,15 @@ void FiniNanoAttachment(NanoAttachment *attachment); NanoCommunicationResult RestartAttachmentConfiguration(NanoAttachment *attachment); +/// +/// @brief Retrieves the communication socket from a NanoAttachment. +/// +/// @param attachment A pointer to the NanoAttachment structure. +/// +/// @return The communication socket file descriptor, or -1 if attachment is NULL. +/// +int GetCommSocket(NanoAttachment *attachment); + /// /// @brief Initializes a HttpSessionData structure with default values. /// @@ -100,6 +109,19 @@ void SendAccumulatedMetricData(NanoAttachment *attachment); /// AttachmentVerdictResponse SendDataNanoAttachment(NanoAttachment *attachment, AttachmentData *data); +/// +/// @brief Sends attachment data asynchronously to the appropriate handlers. +/// +/// This function processes the attachment data based on its chunk type and sends +/// it to the appropriate async handler functions. +/// +/// @param attachment A pointer to the NanoAttachment structure associated with the data. +/// @param data A pointer to the AttachmentData structure containing the data to be processed. +/// +/// @return A NanoCommunicationResult indicating the success or failure of the operation. +/// +NanoCommunicationResult SendDataNanoAttachmentAsync(NanoAttachment *attachment, AttachmentData *data); + /// /// @brief Sends a keep-alive signal using a socket connection. /// @@ -266,4 +288,32 @@ freeCompressedBody( NanoHttpBody *bodies ); +/// +/// @brief Checks if the queue is empty. +/// +/// @param attachment A pointer to the NanoAttachment structure. +/// +/// @return Returns true if the queue is empty, false otherwise. +/// +bool isQueueEmpty(NanoAttachment *attachment); + +/// +/// @brief Pops a session ID from the queue and updates the table. +/// +/// @param attachment A pointer to the NanoAttachment structure. +/// +/// @return The session ID that was popped from the queue. +/// +SessionID PopFromQueue(NanoAttachment *attachment); + +/// +/// @brief Retrieves a verdict response for a given session ID from the table. +/// +/// @param attachment A pointer to the NanoAttachment structure. +/// @param session_id The session ID to look up. +/// +/// @return An AttachmentVerdictResponse structure containing the verdict for the session. +/// +AttachmentVerdictResponse getAttachmentVerdictResponse(NanoAttachment *attachment, SessionID session_id); + #endif // __NANO_ATTACHMENT_H__