Include websocket tests by default

Signed-off-by: Nijat K <nijat.khanbabayev@gmail.com>

Author: NeejWeej

Makefile

@@ -24,7 +24,7 @@ build-debug:  ## build the library ( DEBUG ) - May need a make clean when switch
 	SKBUILD_CONFIGURE_OPTIONS="" DEBUG=1 python setup.py build build_ext --inplace
 
 build-conda:  ## build the library in Conda
-	python setup.py build build_ext --csp-no-vcpkg --inplace
+	CSP_USE_CCACHE=0 python setup.py build build_ext --csp-no-vcpkg --inplace
 
 install:  ## install library
 	python -m pip install .
@@ -83,7 +83,7 @@ checks: check
 
 TEST_ARGS :=
 test-py: ## Clean and Make unit tests
-	python -m pytest -v csp/tests --junitxml=junit.xml $(TEST_ARGS)
+	python -m pytest -vv -s csp/tests --junitxml=junit.xml $(TEST_ARGS)
 
 test-cpp: ## Make C++ unit tests
 ifneq ($(OS),Windows_NT)

cpp/csp/adapters/websocket/CMakeLists.txt

@@ -1,7 +1,6 @@
 csp_autogen( csp.adapters.websocket_types websocket_types WEBSOCKET_HEADER WEBSOCKET_SOURCE )
 
 set(WS_CLIENT_HEADER_FILES
-        WebsocketClientTypes.h
         ClientAdapterManager.h
         ClientInputAdapter.h
         ClientOutputAdapter.h
@@ -13,7 +12,6 @@ set(WS_CLIENT_HEADER_FILES
 )
 
 set(WS_CLIENT_SOURCE_FILES
-        WebsocketClientTypes.cpp
         ClientAdapterManager.cpp
         ClientInputAdapter.cpp
         ClientOutputAdapter.cpp

cpp/csp/adapters/websocket/ClientAdapterManager.h

@@ -3,7 +3,6 @@
 
 #include <csp/adapters/websocket/WebsocketEndpoint.h>
 #include <csp/adapters/websocket/WebsocketEndpointManager.h>
-#include <csp/adapters/websocket/WebsocketClientTypes.h>
 #include <csp/adapters/websocket/ClientInputAdapter.h>
 #include <csp/adapters/websocket/ClientHeaderUpdateAdapter.h>
 #include <csp/core/Enum.h>

cpp/csp/adapters/websocket/WebsocketClientTypes.cpp

@@ -1,5 +1,16 @@
 #include <csp/adapters/websocket/WebsocketEndpointManager.h>
 
+namespace csp {
+
+INIT_CSP_ENUM( adapters::websocket::ClientStatusType,
+               "ACTIVE",
+               "GENERIC_ERROR",
+               "CONNECTION_FAILED",
+               "CLOSED",
+               "MESSAGE_SEND_FAIL",
+);
+
+}
 namespace csp::adapters::websocket {
 
 WebsocketEndpointManager::WebsocketEndpointManager( ClientAdapterManager* mgr, const Dictionary & properties, Engine* engine ) 
@@ -96,7 +107,8 @@ void WebsocketEndpointManager::shutdownEndpoint(const std::string& endpoint_id)
         m_endpoints.erase(endpoint_it);
     std::stringstream ss;
     ss << "No more connections for endpoint={" << endpoint_id << "} Shutting down...";
-    m_mgr -> pushStatus(StatusLevel::INFO,  ClientStatusType::CLOSED, ss.str());
+    std::string msg = ss.str();
+    m_mgr -> pushStatus(StatusLevel::INFO,  ClientStatusType::CLOSED, msg);
 }
 
 void WebsocketEndpointManager::setupEndpoint(const std::string& endpoint_id, 
@@ -135,9 +147,10 @@ void WebsocketEndpointManager::setupEndpoint(const std::string& endpoint_id,
         // should only happen if persist is False
         if ( !payload.empty() )
             endpoint -> send(payload);
-        
-        m_mgr -> pushStatus(StatusLevel::INFO, ClientStatusType::ACTIVE, 
-                    "Connected successfully for endpoint={" + endpoint_id +"}");
+        std::stringstream ss;
+        ss << "Connected successfully for endpoint={" << endpoint_id << "}";
+        std::string msg = ss.str();
+        m_mgr -> pushStatus(StatusLevel::INFO, ClientStatusType::ACTIVE, msg);
         // We remove the caller id, if it was the only one, then we shut down the endpoint
         if( !persist )
             removeEndpointForCallerId(endpoint_id, is_consumer, validated_id);
@@ -170,8 +183,9 @@ void WebsocketEndpointManager::setupEndpoint(const std::string& endpoint_id,
     stored_endpoint -> setOnSendFail(
         [ this, endpoint_id ]( const std::string& s ) {
             std::stringstream ss;
-            ss << "Error: " << s << " for " << endpoint_id;
-            m_mgr -> pushStatus( StatusLevel::ERROR, ClientStatusType::MESSAGE_SEND_FAIL, ss.str() );
+            ss << "Error: " << s << " for endpoint={" << endpoint_id << "}";
+            std::string msg = ss.str();
+            m_mgr -> pushStatus( StatusLevel::ERROR, ClientStatusType::MESSAGE_SEND_FAIL, msg );
         }
     );
     stored_endpoint -> run();
@@ -214,10 +228,11 @@ void WebsocketEndpointManager::handleEndpointFailure(const std::string& endpoint
 
     std::stringstream ss;
     ss << "Connection Failure for endpoint={" << endpoint_id << "} Due to: " << reason;
+    std::string msg = ss.str();
     if ( status_type == ClientStatusType::CLOSED || status_type == ClientStatusType::ACTIVE )
-        m_mgr -> pushStatus(StatusLevel::INFO, status_type, ss.str());
+        m_mgr -> pushStatus(StatusLevel::INFO, status_type, msg);
     else{
-       m_mgr -> pushStatus(StatusLevel::ERROR, status_type, ss.str());
+       m_mgr -> pushStatus(StatusLevel::ERROR, status_type, msg);
     }
 };
 

cpp/csp/adapters/websocket/WebsocketClientTypes.h

@@ -2,7 +2,6 @@
 #define WEBSOCKET_ENDPOINT_MANAGER_H
 
 #include <boost/asio.hpp>
-#include <csp/adapters/websocket/WebsocketClientTypes.h>
 #include <csp/adapters/websocket/WebsocketEndpoint.h>
 #include <csp/adapters/websocket/ClientAdapterManager.h>
 #include <csp/adapters/websocket/ClientInputAdapter.h>
@@ -70,6 +69,25 @@ struct EndpointCallbacks {
     std::function<void(const std::string&, void*, size_t)> onMessage;
 };
 
+struct WebsocketClientStatusTypeTraits
+{
+    enum _enum : unsigned char
+    {
+        ACTIVE = 0,
+        GENERIC_ERROR = 1,
+        CONNECTION_FAILED = 2,
+        CLOSED = 3,
+        MESSAGE_SEND_FAIL = 4,
+
+        NUM_TYPES
+    };
+
+protected:
+    _enum m_value;
+};
+
+using ClientStatusType = Enum<WebsocketClientStatusTypeTraits>;
+
 class WebsocketEndpointManager {
 public:
     explicit WebsocketEndpointManager(ClientAdapterManager* mgr, const Dictionary & properties, Engine* engine);

cpp/csp/adapters/websocket/WebsocketEndpointManager.cpp

@@ -44,7 +44,7 @@ class StatusAdapter : public PushInputAdapter
         m_statusAccess.meta       = meta;
         m_statusAccess.level      = meta -> getMetaField<int64_t>( "level", "Status" );
         m_statusAccess.statusCode = meta -> getMetaField<int64_t>( "status_code", "Status" );
-        m_statusAccess.msg        = meta -> getMetaField<std::string>( "msg", "Status" );
+        m_statusAccess.msg        = meta -> getMetaField<typename csp::StringStructField::CType>( "msg", "Status" );
     }
 
     void pushStatus( int64_t level, int64_t statusCode, const std::string & msg, PushBatch *batch = nullptr )

cpp/csp/adapters/websocket/WebsocketEndpointManager.h

@@ -7,6 +7,7 @@
 #include <string>
 #include <vector>
 #include <unordered_map>
+#include <iostream>
 
 namespace csp
 {
@@ -668,16 +669,69 @@ class StructMeta : public std::enable_shared_from_this<StructMeta>
 };
 
 template<typename T>
-std::shared_ptr<typename StructField::upcast<T>::type> StructMeta::getMetaField( const char * fieldname, const char * expectedtype )
-{
-    auto field_ = field( fieldname );
-    if( !field_ )
-        CSP_THROW( TypeError, "Struct type " << name() << " missing required field " << fieldname << " for " << expectedtype );
+std::shared_ptr<typename StructField::upcast<T>::type> StructMeta::getMetaField(const char* fieldname, const char* expectedtype) {
+    std::cout << "\n=== getMetaField Debug ===\n";
+    std::cout << "1. Looking for field: " << fieldname << "\n";
+    
+    auto field_ = field(fieldname);
+    if(!field_) {
+        std::cout << "2. Field not found!\n";
+        CSP_THROW(TypeError, "Struct type " << name() << " missing required field " << fieldname);
+    }
+    
+    std::cout << "2. Field found\n";
+    std::cout << "3. Field name from object: " << field_->fieldname() << "\n";
+    std::cout << "4. Field type from CspType: " << field_->type()->type() << "\n";
+    std::cout << "5. Expected type: " << CspType::Type::fromCType<T>::type << "\n";
+    
+    // Memory layout & pointer checks
+    const StructField* field_ptr = field_.get();
+    std::cout << "6. Field ptr value: " << field_ptr << "\n";
+    std::cout << "7. Field use count: " << field_.use_count() << "\n";
+    
+    // Detailed field information
+    if(field_ptr) {
+        std::cout << "8. Field metadata:\n";
+        std::cout << "   - Field offset: " << field_ptr->offset() << "\n";
+        std::cout << "   - Field size: " << field_ptr->size() << "\n";
+        std::cout << "   - Field alignment: " << field_ptr->alignment() << "\n";
+        std::cout << "   - Field mask offset: " << field_ptr->maskOffset() << "\n";
+        std::cout << "   - Field mask bit: " << static_cast<int>(field_ptr->maskBit()) << "\n";
+        
+        // Type verification
+        std::cout << "9. Type checks:\n";
+        std::cout << "   - Original type: " << typeid(field_).name() << "\n";
+        std::cout << "   - Target type: " << typeid(typename StructField::upcast<T>::type).name() << "\n";
+        std::cout << "   - Is native: " << field_ptr->isNative() << "\n";
+        
+        // Test various casts
+    std::cout << "10. Detailed cast tests:\n";
+    std::cout << "   Base classes:\n";
+    std::cout << "   - As StructField*: " << (dynamic_cast<const StructField*>(field_ptr) != nullptr) << "\n";
+    std::cout << "   - As NonNativeStructField*: " << (dynamic_cast<const NonNativeStructField*>(field_ptr) != nullptr) << "\n";
+    std::cout << "   Non-native implementations:\n";
+    std::cout << "   - As StringStructField*: " << (dynamic_cast<const StringStructField*>(field_ptr) != nullptr) << "\n";
+    std::cout << "   - As DialectGenericStructField*: " << (dynamic_cast<const DialectGenericStructField*>(field_ptr) != nullptr) << "\n";
+    std::cout << "   - As ArrayStructField<std::string>*: " << (dynamic_cast<const ArrayStructField<std::vector<std::string>>*>(field_ptr) != nullptr) << "\n";
+    std::cout << "   Native field test:\n";
+    std::cout << "   - As NativeStructField<int64_t>*: " << (dynamic_cast<const NativeStructField<int64_t>*>(field_ptr) != nullptr) << "\n";
+}
+
+    using TargetType = typename StructField::upcast<T>::type;
+    auto typedfield = std::dynamic_pointer_cast<TargetType>(field_);
+    std::cout << "11. Final dynamic_cast result: " << (typedfield ? "success" : "failure") << "\n";
 
-    std::shared_ptr<typename StructField::upcast<T>::type> typedfield = std::dynamic_pointer_cast<typename StructField::upcast<T>::type>( field_ );
-    if( !typedfield )
-        CSP_THROW( TypeError, expectedtype << " - provided struct type " << name() << " expected type " << CspType::Type::fromCType<T>::type << " for field " << fieldname
-                                           << " but got type " << field_ -> type() -> type() << " for " << expectedtype );
+    if(!typedfield) {
+        std::cout << "12. FAILED CAST DETAILS:\n";
+        std::cout << "    - Source type: " << typeid(StructField).name() << "\n";
+        std::cout << "    - Target type: " << typeid(TargetType).name() << "\n";
+        
+        CSP_THROW(TypeError, expectedtype << " - provided struct type " << name() 
+                 << " expected type " << CspType::Type::fromCType<T>::type 
+                 << " for field " << fieldname
+                 << " but got type " << field_->type()->type() 
+                 << " for " << expectedtype);
+    }
 
     return typedfield;
 }
@@ -773,22 +827,31 @@ class Struct
     friend class StructMeta;
 
     //Note these members are not included on size(), they're stored before "this" ptr ( see operator new / delete )
-    struct HiddenData
-    {
-        size_t             refcount;
-        std::shared_ptr<const StructMeta> meta;
-        void             * dialectPtr;
+    struct alignas(8) HiddenData {
+        alignas(8) size_t refcount;            // 8 bytes at 0x0
+        alignas(8) std::shared_ptr<const StructMeta> meta;  // 16 bytes at 0x8
+        alignas(8) void* dialectPtr;           // 8 bytes at 0x18
+        // Total: 32 bytes
     };
 
     const HiddenData * hidden() const
     {
         return const_cast<Struct *>( this ) -> hidden();
     }
 
-    HiddenData * hidden()
-    {
-        return reinterpret_cast<HiddenData *>( reinterpret_cast<uint8_t *>( this ) - sizeof( HiddenData ) );
-    }
+    static constexpr size_t HIDDEN_OFFSET = 32;  // sizeof(HiddenData) aligned to 8 bytes
+    
+    HiddenData* hidden() {
+        std::byte* base = reinterpret_cast<std::byte*>(this);
+        // Force alignment to match shared_ptr requirements
+        static_assert(alignof(HiddenData) >= alignof(std::shared_ptr<void>), 
+                     "HiddenData must be aligned for shared_ptr");
+        return reinterpret_cast<HiddenData*>(base - HIDDEN_OFFSET);
+    }
+    // HiddenData * hidden()
+    // {
+    //     return reinterpret_cast<HiddenData *>( reinterpret_cast<uint8_t *>( this ) - sizeof( HiddenData ) );
+    // }
 
     //actual data is allocated past this point
 };

cpp/csp/engine/StatusAdapter.h

@@ -8,6 +8,7 @@
 
 import csp
 from csp import ts
+from csp.adapters.dynamic_adapter_utils import AdapterInfo
 from csp.adapters.status import Status
 from csp.adapters.utils import (
     BytesMessageProtoMapper,
@@ -17,20 +18,20 @@
     RawBytesMessageMapper,
     RawTextMessageMapper,
 )
+from csp.adapters.websocket_types import ActionType, ConnectionRequest, WebsocketHeaderUpdate, WebsocketStatus
 from csp.impl.wiring import input_adapter_def, output_adapter_def, status_adapter_def
 from csp.impl.wiring.delayed_node import DelayedNodeWrapperDef
 from csp.lib import _websocketadapterimpl
 
-from .dynamic_adapter_utils import AdapterInfo
-from .websocket_types import ActionType, ConnectionRequest, WebsocketHeaderUpdate, WebsocketStatus  # noqa
-
 # InternalConnectionRequest,
 _ = (
+    ActionType,
     BytesMessageProtoMapper,
     DateTimeType,
     JSONTextMessageMapper,
     RawBytesMessageMapper,
     RawTextMessageMapper,
+    WebsocketStatus,
 )
 T = TypeVar("T")
 
@@ -577,7 +578,7 @@ def update_headers(self, x: ts[List[WebsocketHeaderUpdate]]):
 
     def status(self, push_mode=csp.PushMode.NON_COLLAPSING):
         ts_type = Status
-        return status_adapter_def(self, ts_type, push_mode=push_mode)
+        return status_adapter_def(self, ts_type, push_mode)
 
     def _create(self, engine, memo):
         """method needs to return the wrapped c++ adapter manager"""