zeroc-ice 3.8.2 → 3.8.3

data/dist/ice/cpp/src/IceDiscovery/LookupI.h

@@ -22,7 +22,7 @@ namespace IceDiscovery
 
         virtual bool retry();
         void invoke(const std::string&, const std::vector<std::pair<LookupPrx, LookupReplyPrx>>&);
-        bool exception();
+        bool exception(size_t generation);
         [[nodiscard]] std::string getRequestId() const;
 
         virtual void finished(const std::optional<Ice::ObjectPrx>&) = 0;
@@ -35,6 +35,11 @@ namespace IceDiscovery
         int _retryCount;
         size_t _lookupCount{0};
         size_t _failureCount{0};
+
+        // Incremented on each invoke() (i.e. each retry round). The exception callbacks capture the value current when
+        // they were sent, so a delayed failure from an earlier round can be ignored instead of counting against the
+        // current round.
+        size_t _generation{0};
     };
     using RequestPtr = std::shared_ptr<Request>;
 
@@ -128,9 +133,9 @@ namespace IceDiscovery
         void foundAdapter(const std::string&, const std::string&, const Ice::ObjectPrx&, bool);
 
         void adapterRequestTimedOut(const AdapterRequestPtr&);
-        void adapterRequestException(const AdapterRequestPtr&, std::exception_ptr);
+        void adapterRequestException(const AdapterRequestPtr&, std::exception_ptr, size_t generation);
         void objectRequestTimedOut(const ObjectRequestPtr&);
-        void objectRequestException(const ObjectRequestPtr&, std::exception_ptr);
+        void objectRequestException(const ObjectRequestPtr&, std::exception_ptr, size_t generation);
 
         const IceInternal::TimerPtr& timer() { return _timer; }
 

data/dist/ice/cpp/src/IceDiscovery/generated/Lookup.cpp

@@ -1,6 +1,6 @@
 // Copyright (c) ZeroC, Inc.
 
-// slice2cpp version 3.8.2
+// slice2cpp version 3.8.3
 // <auto-generated>Generated from Slice file 'Lookup.ice'.</auto-generated>
 
 #define ICE_BUILDING_GENERATED_CODE
@@ -30,7 +30,7 @@
 #   if ICE_INT_VERSION % 100 >= 50
 #       error Beta header file detected
 #   endif
-#   if ICE_INT_VERSION % 100 < 2
+#   if ICE_INT_VERSION % 100 < 3
 #       error Ice patch level mismatch!
 #   endif
 #endif

data/dist/ice/cpp/src/IceLocatorDiscovery/PluginI.cpp

@@ -2,6 +2,7 @@
 
 #include "../Ice/Network.h" // For getInterfacesForMulticast
 #include "../Ice/Timer.h"
+#include "Ice/LocalExceptions.h"
 #include "Ice/LoggerUtil.h"
 #include "IceLocatorDiscovery/IceLocatorDiscovery.h"
 #include "IceLocatorDiscovery/Lookup.h"
@@ -76,16 +77,16 @@ namespace
 
         vector<Ice::LocatorPrx> getLocators(const string&, const chrono::milliseconds&);
 
-        void exception(std::exception_ptr);
+        void exception(std::exception_ptr, size_t generation);
 
     private:
         void runTimerTask() final;
 
         LookupPrx _lookup;
         vector<pair<LookupPrx, LookupReplyPrx>> _lookups;
-        chrono::milliseconds _timeout;
-        int _retryCount;
-        chrono::milliseconds _retryDelay;
+        const chrono::milliseconds _timeout;
+        const int _retryCount;
+        const chrono::milliseconds _retryDelay;
         const IceInternal::TimerPtr _timer;
         const int _traceLevel;
 
@@ -99,6 +100,10 @@ namespace
         bool _pending{false};
         int _pendingRetryCount{0};
         size_t _failureCount{0};
+        // Incremented at the start of each lookup round. The findLocatorAsync exception callbacks capture the value
+        // current when they were sent, so a delayed failure from an earlier round is ignored instead of counting
+        // against the current round.
+        size_t _generation{0};
         bool _warnOnce{true};
         vector<RequestPtr> _pendingRequests;
         std::mutex _mutex;
@@ -316,7 +321,7 @@ Request::invoke(const Ice::LocatorPrx& l)
                     }
                     else
                     {
-                        outPair.first = &outParams[0];
+                        outPair.first = outParams.data();
                         outPair.second = outPair.first + outParams.size();
                     }
                     self->response(ok, outPair);
@@ -377,6 +382,11 @@ Request::exception(std::exception_ptr ex)
     catch (...)
     {
         _exception = ex;
+        // This catch-all is reached only from the asynchronous ice_invokeAsync completion (which runs off
+        // LocatorI::_mutex), never synchronously from Request::invoke: the local exceptions ice_invokeAsync can throw
+        // synchronously (caught by Request::invoke's own catch clause and passed to exception() in-line) are all
+        // handled by the specific catch clauses above. That matters because the retry below re-enters
+        // LocatorI::invoke and re-locks the non-recursive LocatorI::_mutex.
         _locator->invoke(_locatorPrx, shared_from_this()); // Retry with new locator proxy
     }
 }
@@ -396,17 +406,26 @@ LocatorI::LocatorI(
       _locator(lookup->ice_getCommunicator()->getDefaultLocator()),
       _voidLocator(std::move(voidLocator))
 {
-    if (_timeout < chrono::milliseconds::zero())
+    if (_timeout <= chrono::milliseconds::zero())
     {
-        _timeout = chrono::milliseconds(300);
+        throw Ice::PropertyException{
+            __FILE__,
+            __LINE__,
+            "property 'IceLocatorDiscovery.Timeout' must be greater than 0"};
     }
     if (_retryCount < 0)
     {
-        _retryCount = 0;
+        throw Ice::PropertyException{
+            __FILE__,
+            __LINE__,
+            "property 'IceLocatorDiscovery.RetryCount' must be greater than or equal to 0"};
     }
     if (_retryDelay < chrono::milliseconds::zero())
     {
-        _retryDelay = chrono::milliseconds::zero();
+        throw Ice::PropertyException{
+            __FILE__,
+            __LINE__,
+            "property 'IceLocatorDiscovery.RetryDelay' must be greater than or equal to 0"};
     }
 }
 
@@ -533,8 +552,8 @@ LocatorI::foundLocator(const Ice::LocatorPrx& locator)
             out << "received Ice locator with different instance name:\n";
             out << "using = '" << _locator->ice_getIdentity().category << "'\n";
             out << "received = '" << locator->ice_getIdentity().category << "'\n";
-            out << "This is typically the case if multiple Ice locators with different";
-            out << "instance names are deployed and the property `IceLocatorDiscovery.InstanceName' ";
+            out << "This is typically the case if multiple Ice locators with different ";
+            out << "instance names are deployed and the property 'IceLocatorDiscovery.InstanceName' ";
             out << "is not set.";
         }
         return;
@@ -624,6 +643,7 @@ LocatorI::invoke(const optional<Ice::LocatorPrx>& locator, const RequestPtr& req
         {
             _pending = true;
             _failureCount = 0;
+            ++_generation;
             _pendingRetryCount = _retryCount;
             try
             {
@@ -642,7 +662,8 @@ LocatorI::invoke(const optional<Ice::LocatorPrx>& locator, const RequestPtr& req
                         _instanceName,
                         l.second,
                         nullptr,
-                        [self = shared_from_this()](exception_ptr ex) { self->exception(ex); });
+                        [self = shared_from_this(), generation = _generation](exception_ptr ex)
+                        { self->exception(ex, generation); });
                 }
                 _timer->schedule(shared_from_this(), _timeout);
             }
@@ -672,9 +693,15 @@ LocatorI::invoke(const optional<Ice::LocatorPrx>& locator, const RequestPtr& req
 }
 
 void
-LocatorI::exception(std::exception_ptr ex)
+LocatorI::exception(std::exception_ptr ex, size_t generation)
 {
     lock_guard lock(_mutex);
+    // Ignore a delayed failure from an earlier lookup round: it must not count against the current round, which reset
+    // _failureCount and may still have outstanding lookups.
+    if (generation != _generation)
+    {
+        return;
+    }
     if (++_failureCount == _lookups.size() && _pending)
     {
         //
@@ -757,13 +784,15 @@ LocatorI::runTimerTask()
                 }
             }
             _failureCount = 0;
+            ++_generation;
             for (const auto& l : _lookups)
             {
                 l.first->findLocatorAsync(
                     _instanceName,
                     l.second,
                     nullptr,
-                    [self = shared_from_this()](exception_ptr ex) { self->exception(ex); });
+                    [self = shared_from_this(), generation = _generation](exception_ptr ex)
+                    { self->exception(ex, generation); });
             }
             _timer->schedule(shared_from_this(), _timeout);
             return;

data/dist/ice/cpp/src/IceLocatorDiscovery/generated/Lookup.cpp

@@ -1,6 +1,6 @@
 // Copyright (c) ZeroC, Inc.
 
-// slice2cpp version 3.8.2
+// slice2cpp version 3.8.3
 // <auto-generated>Generated from Slice file 'Lookup.ice'.</auto-generated>
 
 #define ICE_BUILDING_GENERATED_CODE
@@ -30,7 +30,7 @@
 #   if ICE_INT_VERSION % 100 >= 50
 #       error Beta header file detected
 #   endif
-#   if ICE_INT_VERSION % 100 < 2
+#   if ICE_INT_VERSION % 100 < 3
 #       error Ice patch level mismatch!
 #   endif
 #endif

data/dist/ice/cpp/src/Slice/DocCommentParser.cpp

@@ -210,25 +210,19 @@ namespace
         {
             // Then we perform additional parsing to extract the name...
 
-            auto nameStart = line.find_first_not_of(ws, tag.size());
+            auto nameStart = doc.find_first_not_of(ws);
             if (nameStart == string::npos)
             {
-                return false; // Malformed line, ignore it.
+                return false; // Malformed line, missing the name part after the tag. Ignore this line.
             }
 
-            auto nameEnd = line.find_first_of(ws, nameStart);
-            if (nameEnd == string::npos)
-            {
-                return false; // Malformed line, ignore it.
-            }
-            name = line.substr(nameStart, nameEnd - nameStart);
+            // If there's no whitespace after the name, that means the name runs to the end of the line.
+            auto nameEnd = doc.find_first_of(ws, nameStart);
+            name = (nameEnd == string::npos) ? doc.substr(nameStart) : doc.substr(nameStart, nameEnd - nameStart);
 
-            // Store whatever remains of the doc comment in the `doc` string.
-            auto docSplitPos = line.find_first_not_of(ws, nameEnd);
-            if (docSplitPos != string::npos)
-            {
-                doc = line.substr(docSplitPos);
-            }
+            // If there's any non-whitespace characters after the name, store them in the `doc` string.
+            auto docStart = doc.find_first_not_of(ws, nameEnd);
+            doc = (docStart == string::npos) ? "" : doc.substr(docStart);
 
             return true;
         }
@@ -291,12 +285,12 @@ namespace
         openingEnd = (openingEnd == string::npos ? line.size() : openingEnd);
         auto count = openingEnd - pos;
 
-        // Find the closing delimeter, starting for the end of the opening delimeter.
+        // Find the closing delimiter, starting for the end of the opening delimiter.
         auto delimiter = string(count, '`');
         auto closingStart = line.find(delimiter, openingEnd);
         if (closingStart == string::npos)
         {
-            // No matching delimeter was found. Emit a warning, then skip to the next line. This one is broken.
+            // No matching delimiter was found. Emit a warning, then skip to the next line. This one is broken.
             const string msg = "unterminated code span: missing closing backtick delimiter";
             p->unit()->warning(p->file(), p->line(), InvalidComment, msg);
 
@@ -325,12 +319,24 @@ namespace
         const string linkTag = "{@link ";
 
         auto endpos = line.find('}', pos);
-        if (endpos != string::npos)
+        if (endpos == string::npos)
+        {
+            // No closing brace was found. Emit a warning, then skip to the next line. This one is broken.
+            const string msg = "unterminated link tag: missing closing '}'";
+            p->unit()->warning(p->file(), p->line(), InvalidComment, msg);
+
+            pos = line.size();
+        }
+        else
         {
-            // Extract the linked-to identifier.
+            // Extract the linked-to identifier, trimming any whitespace around it.
+            string linkText;
             auto identStart = line.find_first_not_of(" \t", pos + linkTag.size());
-            auto identEnd = line.find_last_not_of(" \t", endpos);
-            string linkText = line.substr(identStart, identEnd - identStart);
+            if (identStart < endpos)
+            {
+                auto identEnd = line.find_last_not_of(" \t", endpos - 1);
+                linkText = line.substr(identStart, identEnd - identStart + 1);
+            }
 
             // Then erase the entire '{@link foo}' tag from the comment.
             line.erase(pos, endpos - pos + 1);

data/dist/ice/cpp/src/Slice/DocCommentParser.h

@@ -30,7 +30,7 @@ namespace Slice
         /// @param paramName If @p paramPtr is non-null, this is the mapped name of the parameter being referenced.
         /// Otherwise, this is the identifier after '@p', taken verbatim from the doc-comment.
         /// @param paramPtr A pointer to the parameter that is being referenced, or `nullptr` if it doesn't exist.
-        /// @return A properly formatted parameters reference in the target language. The doc-comment parser will
+        /// @return A properly formatted parameter reference in the target language. The doc-comment parser will
         /// replace the entire "@p <rawParamName>" string with the returned value.
         //
         // By default we just emit the parameter's name in code formatting.
@@ -48,7 +48,7 @@ namespace Slice
 
         /// This function is called by the doc-comment parser to map see-also references ('@see <rawLink>') into each
         /// language's syntax.
-        /// @param rawLink The references's raw text, taken verbatim from the doc-comment.
+        /// @param rawLink The reference's raw text, taken verbatim from the doc-comment.
         /// @param source A pointer to the Slice element that the doc-comment (and reference) are written on.
         /// @param target A pointer to the Slice element that is being referenced, or `nullptr` if it doesn't exist.
         /// @return A properly formatted see-also-link in the target language. This value will be stored in the

data/dist/ice/cpp/src/Slice/FileTracker.cpp

@@ -3,6 +3,7 @@
 #include "FileTracker.h"
 #include "../Ice/ConsoleUtil.h"
 #include "../Ice/FileUtil.h"
+#include "Util.h"
 
 #include <cassert>
 
@@ -29,20 +30,11 @@ Slice::FileTracker::instance()
 void
 Slice::FileTracker::setSource(const string& source)
 {
-    _source = source;
     pair<map<string, list<string>>::iterator, bool> p = _generated.insert(make_pair(source, list<string>()));
     assert(p.second);
     _curr = p.first;
 }
 
-void
-Slice::FileTracker::error()
-{
-    assert(_curr != _generated.end());
-    _generated.erase(_curr);
-    _curr = _generated.end();
-}
-
 void
 Slice::FileTracker::addFile(const string& file)
 {
@@ -84,10 +76,10 @@ Slice::FileTracker::dumpxml()
     {
         if (!p.second.empty())
         {
-            consoleOut << endl << "  <source name=\"" << p.first << "\">";
+            consoleOut << endl << "  <source name=\"" << escapeXMLAttribute(p.first) << "\">";
             for (const auto& q : p.second)
             {
-                consoleOut << endl << "    <file name=\"" << q << "\"/>";
+                consoleOut << endl << "    <file name=\"" << escapeXMLAttribute(q) << "\"/>";
             }
             consoleOut << endl << "  </source>";
         }

data/dist/ice/cpp/src/Slice/FileTracker.h

@@ -30,13 +30,11 @@ namespace Slice
         void setSource(const std::string& source);
         void addFile(const std::string& file);
         void addDirectory(const std::string& dir);
-        void error();
         void cleanup();
         void dumpxml();
 
     private:
         std::list<std::pair<std::string, bool>> _files;
-        std::string _source;
         std::map<std::string, std::list<std::string>> _generated;
         std::map<std::string, std::list<std::string>>::iterator _curr;
     };