zeroc-ice 3.8.2 → 3.8.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aa4154bd37d4df0c510b9737d68ad939fd5168b8f96c5c4f627fbbe9916720ce
-  data.tar.gz: 492eecaf69cd8e94539ad50a178183b5674d9e7960602f29b0dd63ae725499ff
+  metadata.gz: 2a605837988ce25b7b58d46ea460f0c286a95530140d5f23e3af035c6f151b33
+  data.tar.gz: 0e3ad2c032e729a00b19ee324a8b11f6da47d774c57bd6f364765fc0d4c1348b
 SHA512:
-  metadata.gz: 63299394740124d99d1e5a83a4d384084682a026bc819a778467ac94325355fee31967c1c354b8cd001d93bb3ad3d9deedc3f22d5a9be88269349fadcde35bc6
-  data.tar.gz: a5bc4d318e83bb949c2b6578f25c1fca7a34d8cabcd6c1047823dec67a2633db6b9128ae1d6169a9a004c217fe2935c30c6175d8bb51ba536d50d458b31c0133
+  metadata.gz: 0e35197c1bec028fc5c27926658a61babf5c69738438ab2e68f44f7aa8fcd039de7196cc00d75af96bbf3b4ac7084b0b0b671a325beefe3bf29c0fe3e2eb0949
+  data.tar.gz: 2e0d8a8a6a3200e4450c798d28d496f45d9829fb94221b0e8512faad52b8de1c89de34492872605d3980fb65a4da0f6f133de9befe637cb836735c1ba7365b21

data/dist/IceRuby/Communicator.cpp

@@ -28,7 +28,24 @@ namespace
 extern "C" void
 IceRuby_Communicator_free(void* p)
 {
-    delete static_cast<Ice::CommunicatorPtr*>(p);
+    // The wrapper is collected only once no other object (such as a proxy) marks it. Erase the map
+    // entries so that the native communicator and slice loader can be released.
+    auto communicator = static_cast<Ice::CommunicatorPtr*>(p);
+    _communicatorMap.erase(*communicator);
+    _sliceLoaderMap.erase(*communicator);
+    delete communicator;
+}
+
+extern "C" void
+IceRuby_Communicator_compact(void* p)
+{
+    // Keep the map entry pointing at the wrapper's current location when GC compaction moves it.
+    auto communicator = static_cast<Ice::CommunicatorPtr*>(p);
+    CommunicatorMap::iterator q = _communicatorMap.find(*communicator);
+    if (q != _communicatorMap.end())
+    {
+        q->second = rb_gc_location(q->second);
+    }
 }
 
 static const rb_data_type_t IceRuby_CommunicatorType = {
@@ -36,6 +53,7 @@ static const rb_data_type_t IceRuby_CommunicatorType = {
     .function =
         {
             .dfree = IceRuby_Communicator_free,
+            .dcompact = IceRuby_Communicator_compact,
         },
     .flags = RUBY_TYPED_FREE_IMMEDIATELY,
 };
@@ -158,11 +176,6 @@ IceRuby_initialize(int argc, VALUE* argv, VALUE /*self*/)
             &IceRuby_CommunicatorType,
             new Ice::CommunicatorPtr(communicator));
 
-        CommunicatorMap::iterator p = _communicatorMap.find(communicator);
-        if (p != _communicatorMap.end())
-        {
-            _communicatorMap.erase(p);
-        }
         _communicatorMap.insert(CommunicatorMap::value_type(communicator, reinterpret_cast<const VALUE&>(result)));
 
         _sliceLoaderMap[communicator] = sliceLoader;
@@ -223,8 +236,12 @@ IceRuby_identityToString(int argc, VALUE* argv, VALUE /*self*/)
         if (argc == 2)
         {
             volatile VALUE modeValue = callRuby(rb_funcall, argv[1], rb_intern("to_i"), 0);
-            assert(TYPE(modeValue) == T_FIXNUM);
-            toStringMode = static_cast<Ice::ToStringMode>(FIX2LONG(modeValue));
+            int32_t mode = getInteger(modeValue);
+            if (mode < 0 || mode > static_cast<int32_t>(Ice::ToStringMode::Compat))
+            {
+                throw RubyException(rb_eRangeError, "invalid enumerator %d for enum Ice::ToStringMode", mode);
+            }
+            toStringMode = static_cast<Ice::ToStringMode>(mode);
         }
 
         string str = Ice::identityToString(ident, toStringMode);
@@ -386,7 +403,7 @@ IceRuby_Communicator_getImplicitContext(VALUE self)
     {
         Ice::CommunicatorPtr p = getCommunicator(self);
         Ice::ImplicitContextPtr implicitContext = p->getImplicitContext();
-        return createImplicitContext(implicitContext);
+        return implicitContext ? createImplicitContext(implicitContext) : Qnil;
     }
     ICE_RUBY_CATCH
     return Qnil;

data/dist/IceRuby/Config.h

@@ -55,18 +55,6 @@
 #    pragma GCC diagnostic pop
 #endif
 
-//
-// The Ruby header file win32/win32.h defines a number of macros for
-// functions like shutdown() and close() that wreak havoc.
-//
-#ifdef _WIN32
-#    undef shutdown
-#    undef close
-#    undef read
-#    undef write
-#    undef sleep
-#endif
-
 extern "C"
 {
     typedef VALUE (*ICE_RUBY_ENTRY_POINT)(...);

data/dist/IceRuby/Connection.cpp

@@ -148,10 +148,7 @@ IceRuby_Connection_setBufferSize(VALUE self, VALUE r, VALUE s)
         Ice::ConnectionPtr* p = reinterpret_cast<Ice::ConnectionPtr*>(DATA_PTR(self));
         assert(p);
 
-        int rcvSize = static_cast<int>(getInteger(r));
-        int sndSize = static_cast<int>(getInteger(s));
-
-        (*p)->setBufferSize(rcvSize, sndSize);
+        (*p)->setBufferSize(getInteger(r), getInteger(s));
     }
     ICE_RUBY_CATCH
     return Qnil;
@@ -191,14 +188,11 @@ IceRuby_Connection_equals(VALUE self, VALUE other)
 {
     ICE_RUBY_TRY
     {
-        if (NIL_P(other))
+        // eql? returns false for a non-Connection argument: Ruby calls it with arbitrary keys on a Hash collision.
+        if (NIL_P(other) || callRuby(rb_obj_is_kind_of, other, _connectionClass) != Qtrue)
         {
             return Qfalse;
         }
-        if (callRuby(rb_obj_is_kind_of, other, _connectionClass) != Qtrue)
-        {
-            throw RubyException(rb_eTypeError, "argument must be a connection");
-        }
         Ice::ConnectionPtr* p1 = reinterpret_cast<Ice::ConnectionPtr*>(DATA_PTR(self));
         Ice::ConnectionPtr* p2 = reinterpret_cast<Ice::ConnectionPtr*>(DATA_PTR(other));
         return *p1 == *p2 ? Qtrue : Qfalse;
@@ -207,6 +201,19 @@ IceRuby_Connection_equals(VALUE self, VALUE other)
     return Qnil;
 }
 
+extern "C" VALUE
+IceRuby_Connection_hash(VALUE self)
+{
+    ICE_RUBY_TRY
+    {
+        Ice::ConnectionPtr* p = reinterpret_cast<Ice::ConnectionPtr*>(DATA_PTR(self));
+        // Hash the native pointer, which is exactly what eql? compares.
+        return INT2FIX(std::hash<Ice::ConnectionPtr>{}(*p));
+    }
+    ICE_RUBY_CATCH
+    return Qnil;
+}
+
 // ConnectionInfo
 
 extern "C" void
@@ -303,6 +310,7 @@ IceRuby::createConnectionInfo(const Ice::ConnectionInfoPtr& p)
     rb_ivar_set(info, rb_intern("@underlying"), createConnectionInfo(p->underlying));
     rb_ivar_set(info, rb_intern("@incoming"), p->incoming ? Qtrue : Qfalse);
     rb_ivar_set(info, rb_intern("@adapterName"), createString(p->adapterName));
+    rb_ivar_set(info, rb_intern("@connectionId"), createString(p->connectionId));
     return info;
 }
 
@@ -336,6 +344,7 @@ IceRuby::initConnection(VALUE iceModule)
     rb_define_method(_connectionClass, "inspect", CAST_METHOD(IceRuby_Connection_toString), 0);
     rb_define_method(_connectionClass, "==", CAST_METHOD(IceRuby_Connection_equals), 1);
     rb_define_method(_connectionClass, "eql?", CAST_METHOD(IceRuby_Connection_equals), 1);
+    rb_define_method(_connectionClass, "hash", CAST_METHOD(IceRuby_Connection_hash), 0);
 
     //
     // ConnectionInfo.

data/dist/IceRuby/DefaultSliceLoader.h

@@ -8,7 +8,7 @@
 
 namespace IceRuby
 {
-    /// Instantiates generated Python classes/exceptions based on the Slice type ID.
+    /// Instantiates generated Ruby classes/exceptions based on the Slice type ID.
     class DefaultSliceLoader final : public Ice::SliceLoader
     {
     public:

data/dist/IceRuby/Endpoint.cpp

@@ -76,13 +76,9 @@ IceRuby_Endpoint_cmp(VALUE self, VALUE other)
 {
     ICE_RUBY_TRY
     {
-        if (NIL_P(other))
-        {
-            return INT2NUM(1);
-        }
         if (!checkEndpoint(other))
         {
-            throw RubyException(rb_eTypeError, "argument must be a endpoint");
+            return Qnil;
         }
         Ice::EndpointPtr p1 = Ice::EndpointPtr(*reinterpret_cast<Ice::EndpointPtr*>(DATA_PTR(self)));
         Ice::EndpointPtr p2 = Ice::EndpointPtr(*reinterpret_cast<Ice::EndpointPtr*>(DATA_PTR(other)));
@@ -90,7 +86,7 @@ IceRuby_Endpoint_cmp(VALUE self, VALUE other)
         {
             return INT2NUM(-1);
         }
-        else if (Ice::targetEqualTo(p1, p1))
+        else if (Ice::targetEqualTo(p1, p2))
         {
             return INT2NUM(0);
         }
@@ -109,6 +105,22 @@ IceRuby_Endpoint_equals(VALUE self, VALUE other)
     return IceRuby_Endpoint_cmp(self, other) == INT2NUM(0) ? Qtrue : Qfalse;
 }
 
+extern "C" VALUE
+IceRuby_Endpoint_hash(VALUE self)
+{
+    ICE_RUBY_TRY
+    {
+        Ice::EndpointPtr* p = reinterpret_cast<Ice::EndpointPtr*>(DATA_PTR(self));
+        assert(p);
+
+        // Hash the string representation, which encodes exactly the fields used by operator== (and hence eql?),
+        // so equal endpoints produce equal hashes.
+        return INT2FIX(std::hash<string>{}((*p)->toString()));
+    }
+    ICE_RUBY_CATCH
+    return Qnil;
+}
+
 // EndpointInfo
 
 extern "C" void
@@ -159,8 +171,8 @@ IceRuby::createEndpointInfo(const Ice::EndpointInfoPtr& p)
         info = TypedData_Wrap_Struct(_opaqueEndpointInfoClass, &IceRuby_EndpointInfoType, new Ice::EndpointInfoPtr(p));
 
         Ice::OpaqueEndpointInfoPtr opaque = dynamic_pointer_cast<Ice::OpaqueEndpointInfo>(p);
-        auto b = opaque->rawBytes;
-        volatile VALUE v = callRuby(rb_str_new, reinterpret_cast<const char*>(&b[0]), static_cast<long>(b.size()));
+        const auto& b = opaque->rawBytes;
+        volatile VALUE v = callRuby(rb_str_new, reinterpret_cast<const char*>(b.data()), static_cast<long>(b.size()));
         rb_ivar_set(info, rb_intern("@rawBytes"), v);
         rb_ivar_set(info, rb_intern("@rawEncoding"), createEncodingVersion(opaque->rawEncoding));
     }
@@ -254,6 +266,7 @@ IceRuby::initEndpoint(VALUE iceModule)
     rb_define_method(_endpointClass, "<=>", CAST_METHOD(IceRuby_Endpoint_cmp), 1);
     rb_define_method(_endpointClass, "==", CAST_METHOD(IceRuby_Endpoint_equals), 1);
     rb_define_method(_endpointClass, "eql?", CAST_METHOD(IceRuby_Endpoint_equals), 1);
+    rb_define_method(_endpointClass, "hash", CAST_METHOD(IceRuby_Endpoint_hash), 0);
 
     //
     // EndpointInfo.

data/dist/IceRuby/Operation.cpp

@@ -25,7 +25,7 @@ namespace IceRuby
     class ParamInfo final : public UnmarshalCallback
     {
     public:
-        void unmarshaled(VALUE, VALUE, void*) final;
+        void unmarshaled(VALUE, VALUE, void*, StreamUtil*) final;
 
         TypeInfoPtr type;
         bool optional;
@@ -146,7 +146,7 @@ IceRuby::Operation::~Operation() = default;
 // ParamInfo implementation.
 //
 void
-IceRuby::ParamInfo::unmarshaled(VALUE val, VALUE target, void* closure)
+IceRuby::ParamInfo::unmarshaled(VALUE val, VALUE target, void* closure, StreamUtil*)
 {
     assert(TYPE(target) == T_ARRAY);
     static_assert(sizeof(long) == sizeof(void*), "long and void* must have the same size");
@@ -267,7 +267,9 @@ IceRuby::OperationI::invoke(const Ice::ObjectPrx& proxy, VALUE args, VALUE hctx)
 
     if (!_deprecateMessage.empty())
     {
-        rb_warning("%s", _deprecateMessage.c_str());
+        // Route the warning through the rb_protect discipline: rb_warning dispatches to the overridable
+        // Warning.warn, and a raising override would otherwise longjmp past the live C++ locals above.
+        callRubyVoid([this] { rb_warning("%s", _deprecateMessage.c_str()); });
         _deprecateMessage.clear(); // Only show the warning once.
     }
 
@@ -366,7 +368,7 @@ IceRuby::OperationI::convertParam(VALUE v, long pos)
     ParamInfoPtr param = make_shared<ParamInfo>();
     param->type = getType(RARRAY_AREF(v, 0));
     param->optional = static_cast<bool>(RTEST(RARRAY_AREF(v, 1)));
-    param->tag = static_cast<int>(getInteger(RARRAY_AREF(v, 2)));
+    param->tag = getInteger(RARRAY_AREF(v, 2));
     param->pos = static_cast<int>(pos);
     return param;
 }
@@ -467,7 +469,7 @@ IceRuby::OperationI::unmarshalResults(const vector<byte>& bytes, const Ice::Comm
 
     //
     // Unmarshal the results. If there is more than one value to be returned, then return them
-    // in a tuple of the form (result, outParam1, ...). Otherwise just return the value.
+    // in an array of the form [result, outParam1, ...]. Otherwise just return the value.
     //
     Ice::InputStream is{communicator, bytes, lookupSliceLoader(communicator)};
 

data/dist/IceRuby/Properties.cpp

@@ -37,9 +37,9 @@ IceRuby_createProperties(int argc, VALUE* argv, VALUE /*self*/)
         }
 
         Ice::PropertiesPtr defaults;
-        if (argc == 2)
+        if (argc == 2 && !NIL_P(argv[1]))
         {
-            if (!NIL_P(argv[1]) && callRuby(rb_obj_is_instance_of, argv[1], _propertiesClass) == Qfalse)
+            if (callRuby(rb_obj_is_instance_of, argv[1], _propertiesClass) == Qfalse)
             {
                 throw RubyException(rb_eTypeError, "invalid properties argument to Ice::createProperties");
             }
@@ -156,8 +156,7 @@ IceRuby_Properties_getPropertyAsIntWithDefault(VALUE self, VALUE key, VALUE def)
     {
         Ice::PropertiesPtr p = getProperties(self);
         string k = getString(key);
-        int32_t d = static_cast<int32_t>(getInteger(def));
-        int32_t v = p->getPropertyAsIntWithDefault(k, d);
+        int32_t v = p->getPropertyAsIntWithDefault(k, getInteger(def));
         return INT2FIX(v);
     }
     ICE_RUBY_CATCH

data/dist/IceRuby/Proxy.cpp

@@ -248,7 +248,7 @@ IceRuby_ObjectPrx_ice_endpoints(VALUE self, VALUE seq)
         if (!NIL_P(seq))
         {
             volatile VALUE arr = callRuby(rb_check_array_type, seq);
-            if (NIL_P(seq))
+            if (NIL_P(arr))
             {
                 throw RubyException(rb_eTypeError, "unable to convert value to an array of endpoints");
             }
@@ -316,8 +316,7 @@ IceRuby_ObjectPrx_ice_locatorCacheTimeout(VALUE self, VALUE timeout)
         try
         {
             Ice::ObjectPrx p = getProxy(self);
-            long t = getInteger(timeout);
-            return createProxy(p->ice_locatorCacheTimeout(static_cast<int32_t>(t)), rb_class_of(self));
+            return createProxy(p->ice_locatorCacheTimeout(getInteger(timeout)), rb_class_of(self));
         }
         catch (const invalid_argument& ex)
         {
@@ -336,8 +335,7 @@ IceRuby_ObjectPrx_ice_invocationTimeout(VALUE self, VALUE timeout)
         try
         {
             Ice::ObjectPrx p = getProxy(self);
-            long t = getInteger(timeout);
-            return createProxy(p->ice_invocationTimeout(static_cast<int32_t>(t)), rb_class_of(self));
+            return createProxy(p->ice_invocationTimeout(getInteger(timeout)), rb_class_of(self));
         }
         catch (const invalid_argument& ex)
         {
@@ -425,17 +423,15 @@ IceRuby_ObjectPrx_ice_getEncodingVersion(VALUE self)
 extern "C" VALUE
 IceRuby_ObjectPrx_ice_encodingVersion(VALUE self, VALUE v)
 {
-    Ice::EncodingVersion val;
-    if (getEncodingVersion(v, val))
+    ICE_RUBY_TRY
     {
-        ICE_RUBY_TRY
-        {
-            Ice::ObjectPrx p = getProxy(self);
-            return createProxy(p->ice_encodingVersion(val), rb_class_of(self));
-        }
-        ICE_RUBY_CATCH
-    }
+        Ice::EncodingVersion val;
+        getEncodingVersion(v, val);
 
+        Ice::ObjectPrx p = getProxy(self);
+        return createProxy(p->ice_encodingVersion(val), rb_class_of(self));
+    }
+    ICE_RUBY_CATCH
     return Qnil;
 }
 
@@ -766,13 +762,9 @@ IceRuby_ObjectPrx_cmp(VALUE self, VALUE other)
 {
     ICE_RUBY_TRY
     {
-        if (NIL_P(other))
-        {
-            return INT2NUM(1);
-        }
         if (!checkProxy(other))
         {
-            throw RubyException(rb_eTypeError, "argument must be a proxy");
+            return Qnil;
         }
         Ice::ObjectPrx p1 = getProxy(self);
         Ice::ObjectPrx p2 = getProxy(other);

data/dist/IceRuby/RubySliceLoader.cpp

@@ -10,7 +10,7 @@ using namespace std;
 IceRuby::RubySliceLoader::RubySliceLoader(VALUE sliceLoader) : _sliceLoader{sliceLoader}
 {
     // Mark the object as in use for the lifetime of this wrapper.
-    rb_gc_register_address(&sliceLoader);
+    rb_gc_register_address(&_sliceLoader);
 }
 
 IceRuby::RubySliceLoader::~RubySliceLoader() { rb_gc_unregister_address(&_sliceLoader); }

data/dist/IceRuby/RubySliceLoader.h

@@ -15,6 +15,12 @@ namespace IceRuby
         explicit RubySliceLoader(VALUE sliceLoader);
         ~RubySliceLoader() final;
 
+        // Registers a GC root tied to the address of _sliceLoader, so it's neither copyable nor movable.
+        RubySliceLoader(const RubySliceLoader&) = delete;
+        RubySliceLoader(RubySliceLoader&&) = delete;
+        RubySliceLoader& operator=(const RubySliceLoader&) = delete;
+        RubySliceLoader& operator=(RubySliceLoader&&) = delete;
+
         [[nodiscard]] Ice::ValuePtr newClassInstance(std::string_view typeId) const final;
 
         // TODO: we currently don't support loading of custom Slice exceptions from Ruby.