Merge branch 'main' into iam-role-log-ingestor

Author: hoophalab

components/core/CMakeLists.txt

@@ -500,8 +500,8 @@ set(SOURCE_FILES_unitTest
         src/clp/ffi/ir_stream/decoding_methods.inc
         src/clp/ffi/ir_stream/encoding_methods.cpp
         src/clp/ffi/ir_stream/encoding_methods.hpp
-        src/clp/ffi/ir_stream/IrErrorCode.cpp
-        src/clp/ffi/ir_stream/IrErrorCode.hpp
+        src/clp/ffi/ir_stream/IrDeserializationError.cpp
+        src/clp/ffi/ir_stream/IrDeserializationError.hpp
         src/clp/ffi/ir_stream/IrSerializationError.cpp
         src/clp/ffi/ir_stream/IrSerializationError.hpp
         src/clp/ffi/ir_stream/IrUnitHandlerReq.hpp

components/core/src/clp/clg/CMakeLists.txt

@@ -21,6 +21,8 @@ set(
         ../ffi/ir_stream/decoding_methods.cpp
         ../ffi/ir_stream/decoding_methods.hpp
         ../ffi/ir_stream/decoding_methods.inc
+        ../ffi/ir_stream/IrDeserializationError.cpp
+        ../ffi/ir_stream/IrDeserializationError.hpp
         ../ffi/ir_stream/IrSerializationError.cpp
         ../ffi/ir_stream/IrSerializationError.hpp
         ../ffi/StringBlob.hpp

components/core/src/clp/clo/CMakeLists.txt

@@ -27,6 +27,8 @@ set(
         ../ffi/ir_stream/decoding_methods.inc
         ../ffi/ir_stream/encoding_methods.cpp
         ../ffi/ir_stream/encoding_methods.hpp
+        ../ffi/ir_stream/IrDeserializationError.cpp
+        ../ffi/ir_stream/IrDeserializationError.hpp
         ../ffi/ir_stream/IrSerializationError.cpp
         ../ffi/ir_stream/IrSerializationError.hpp
         ../ffi/ir_stream/utils.cpp

components/core/src/clp/clp/CMakeLists.txt

@@ -28,8 +28,8 @@ set(
         ../ffi/ir_stream/decoding_methods.inc
         ../ffi/ir_stream/encoding_methods.cpp
         ../ffi/ir_stream/encoding_methods.hpp
-        ../ffi/ir_stream/IrErrorCode.cpp
-        ../ffi/ir_stream/IrErrorCode.hpp
+        ../ffi/ir_stream/IrDeserializationError.cpp
+        ../ffi/ir_stream/IrDeserializationError.hpp
         ../ffi/ir_stream/IrSerializationError.cpp
         ../ffi/ir_stream/IrSerializationError.hpp
         ../ffi/ir_stream/utils.cpp

components/core/src/clp/ffi/ir_stream/Deserializer.hpp

@@ -101,7 +101,6 @@ class Deserializer {
      *
      * NOTE: If the deserialized IR unit is `IrUnitType::LogEvent` and the query handler is not
      * `search::EmptyQueryHandler`, `handle_log_event` will only be invoked if the query handler
-
      * returns `search::AstEvaluationResult::True`.
      *
      * @param reader
@@ -375,7 +374,7 @@ auto Deserializer<IrUnitHandler, QueryHandlerType>::deserialize_next_ir_unit(
 
         case IrUnitType::UtcOffsetChange: {
             auto const new_utc_offset{
-                    YSTDLIB_ERROR_HANDLING_TRYX(deserialize_ir_unit_utc_offset_change(reader))
+                    YSTDLIB_ERROR_HANDLING_TRYX(deserialize_utc_offset_change(reader))
             };
             if (auto const err{
                         m_ir_unit_handler.handle_utc_offset_change(m_utc_offset, new_utc_offset)

components/core/src/clp/ffi/ir_stream/IrDeserializationError.cpp

@@ -0,0 +1,41 @@
+#include "IrDeserializationError.hpp"
+
+#include <string>
+
+#include <ystdlib/error_handling/ErrorCode.hpp>
+
+using clp::ffi::ir_stream::IrDeserializationErrorEnum;
+using IrErrorCategory = ystdlib::error_handling::ErrorCategory<IrDeserializationErrorEnum>;
+
+template <>
+auto IrErrorCategory::name() const noexcept -> char const* {
+    return "clp::ffi::ir_stream::IrDeserializationError";
+}
+
+template <>
+auto IrErrorCategory::message(IrDeserializationErrorEnum error_enum) const -> std::string {
+    switch (error_enum) {
+        case IrDeserializationErrorEnum::DuplicateKey:
+            return "duplicated keys are found in the same kv-pair log event";
+        case IrDeserializationErrorEnum::EncodedTextAstDeserializationFailure:
+            return "failed to deserialize an encoded text AST";
+        case IrDeserializationErrorEnum::EndOfStream:
+            return "reached end-of-stream IR unit";
+        case IrDeserializationErrorEnum::IncompleteStream:
+            return "incomplete IR stream";
+        case IrDeserializationErrorEnum::InvalidKeyGroupOrdering:
+            return "invalid key-ID-group ordering";
+        case IrDeserializationErrorEnum::InvalidTag:
+            return "invalid tag";
+        case IrDeserializationErrorEnum::UnsupportedMetadataFormat:
+            return "IR stream metadata format unsupported";
+        case IrDeserializationErrorEnum::UnsupportedVersion:
+            return "IR stream version unsupported";
+        case IrDeserializationErrorEnum::UnknownSchemaTreeNodeType:
+            return "unknown schema tree node type";
+        case IrDeserializationErrorEnum::UnknownValueType:
+            return "unknown value type";
+        default:
+            return "unknown error code enum";
+    }
+}

components/core/src/clp/ffi/ir_stream/IrDeserializationError.hpp

@@ -0,0 +1,30 @@
+#ifndef CLP_IR_DESERIALIZATION_ERROR_HPP
+#define CLP_IR_DESERIALIZATION_ERROR_HPP
+
+#include <cstdint>
+
+#include <ystdlib/error_handling/ErrorCode.hpp>
+
+namespace clp::ffi::ir_stream {
+/**
+ * Error code enum for IR stream deserialization.
+ */
+enum class IrDeserializationErrorEnum : uint8_t {
+    DuplicateKey,
+    EncodedTextAstDeserializationFailure,
+    EndOfStream,
+    IncompleteStream,
+    InvalidKeyGroupOrdering,
+    InvalidTag,
+    UnsupportedMetadataFormat,
+    UnsupportedVersion,
+    UnknownSchemaTreeNodeType,
+    UnknownValueType,
+};
+
+using IrDeserializationError = ystdlib::error_handling::ErrorCode<IrDeserializationErrorEnum>;
+}  // namespace clp::ffi::ir_stream
+
+YSTDLIB_ERROR_HANDLING_MARK_AS_ERROR_CODE_ENUM(clp::ffi::ir_stream::IrDeserializationErrorEnum);
+
+#endif  // CLP_IR_DESERIALIZATION_ERROR_HPP

components/core/src/clp/ffi/ir_stream/IrErrorCode.cpp

@@ -12,6 +12,7 @@
 #include "../EncodedTextAst.hpp"
 #include "../StringBlob.hpp"
 #include "byteswap.hpp"
+#include "IrDeserializationError.hpp"
 #include "protocol_constants.hpp"
 #include "utils.hpp"
 
@@ -526,15 +527,15 @@ auto deserialize_encoded_text_ast(
 
 template <ir::EncodedVariableTypeReq encoded_variable_t>
 [[nodiscard]] auto deserialize_encoded_text_ast(ReaderInterface& reader, encoded_tag_t encoded_tag)
-        -> boost::outcome_v2::std_checked<EncodedTextAst<encoded_variable_t>, IRErrorCode> {
+        -> ystdlib::error_handling::Result<EncodedTextAst<encoded_variable_t>> {
     StringBlob string_blob;
     vector<encoded_variable_t> encoded_vars;
     bool is_encoded_var{};
     while (is_variable_tag<encoded_variable_t>(encoded_tag, is_encoded_var)) {
         if (is_encoded_var) {
             encoded_variable_t encoded_variable{};
             if (false == deserialize_int(reader, encoded_variable)) {
-                return IRErrorCode_Incomplete_IR;
+                return IrDeserializationError{IrDeserializationErrorEnum::IncompleteStream};
             }
             encoded_vars.push_back(encoded_variable);
         } else {
@@ -543,28 +544,28 @@ template <ir::EncodedVariableTypeReq encoded_variable_t>
                 };
                 IRErrorCode_Success != error_code)
             {
-                return error_code;
+                return IrDeserializationError{
+                        IrDeserializationErrorEnum::EncodedTextAstDeserializationFailure
+                };
             }
         }
         if (ErrorCode_Success != reader.try_read_numeric_value(encoded_tag)) {
-            return IRErrorCode_Incomplete_IR;
+            return IrDeserializationError{IrDeserializationErrorEnum::IncompleteStream};
         }
     }
 
     if (auto const error_code{deserialize_and_append_logtype(reader, encoded_tag, string_blob)};
         IRErrorCode_Success != error_code)
     {
-        return error_code;
+        return IrDeserializationError{
+                IrDeserializationErrorEnum::EncodedTextAstDeserializationFailure
+        };
     }
 
-    auto encoded_text_ast_result = EncodedTextAst<encoded_variable_t>::create(
+    return EncodedTextAst<encoded_variable_t>::create(
             std::move(encoded_vars),
             std::move(string_blob)
     );
-    if (encoded_text_ast_result.has_error()) {
-        return IRErrorCode_Corrupted_IR;
-    }
-    return std::move(encoded_text_ast_result.value());
 }
 
 IRErrorCode get_encoding_type(ReaderInterface& reader, bool& is_four_bytes_encoding) {
@@ -596,6 +597,14 @@ IRErrorCode deserialize_tag(ReaderInterface& reader, encoded_tag_t& tag) {
     return IRErrorCode_Success;
 }
 
+auto deserialize_tag(ReaderInterface& reader) -> ystdlib::error_handling::Result<encoded_tag_t> {
+    encoded_tag_t tag{};
+    if (ErrorCode_Success != reader.try_read_numeric_value(tag)) {
+        return IrDeserializationError{IrDeserializationErrorEnum::IncompleteStream};
+    }
+    return tag;
+}
+
 IRErrorCode deserialize_preamble(
         ReaderInterface& reader,
         encoded_tag_t& metadata_type,
@@ -682,6 +691,15 @@ IRErrorCode deserialize_utc_offset_change(ReaderInterface& reader, UtcOffset& ut
     return IRErrorCode_Success;
 }
 
+auto deserialize_utc_offset_change(ReaderInterface& reader)
+        -> ystdlib::error_handling::Result<UtcOffset> {
+    int64_t serialized_utc_offset{};
+    if (false == deserialize_int(reader, serialized_utc_offset)) {
+        return IrDeserializationError{IrDeserializationErrorEnum::IncompleteStream};
+    }
+    return UtcOffset{serialized_utc_offset};
+}
+
 namespace four_byte_encoding {
 IRErrorCode deserialize_log_event(
         ReaderInterface& reader,
@@ -752,10 +770,10 @@ template auto deserialize_encoded_text_ast<eight_byte_encoded_variable_t>(
 template auto deserialize_encoded_text_ast<four_byte_encoded_variable_t>(
         ReaderInterface& reader,
         encoded_tag_t encoded_tag
-) -> boost::outcome_v2::std_checked<EncodedTextAst<four_byte_encoded_variable_t>, IRErrorCode>;
+) -> ystdlib::error_handling::Result<EncodedTextAst<four_byte_encoded_variable_t>>;
 
 template auto deserialize_encoded_text_ast<eight_byte_encoded_variable_t>(
         ReaderInterface& reader,
         encoded_tag_t encoded_tag
-) -> boost::outcome_v2::std_checked<EncodedTextAst<eight_byte_encoded_variable_t>, IRErrorCode>;
+) -> ystdlib::error_handling::Result<EncodedTextAst<eight_byte_encoded_variable_t>>;
 }  // namespace clp::ffi::ir_stream