zeroc-ice 3.7.11 → 3.8.1

data/dist/ice/cpp/src/Ice/LoggerAdminI.h

@@ -1,41 +1,31 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_LOGGER_ADMIN_I_H
 #define ICE_LOGGER_ADMIN_I_H
 
-#include <Ice/Config.h>
-#include <Ice/Logger.h>
-#include <Ice/PropertiesF.h>
-#include <Ice/CommunicatorF.h>
+#include "Ice/CommunicatorF.h"
+#include "Ice/Config.h"
+#include "Ice/Logger.h"
+#include "Ice/ObjectF.h"
+#include "Ice/PropertiesF.h"
 
 namespace IceInternal
 {
+    // A logger that works in tandem with a "Logger" admin facet.
+    class LoggerAdminLogger : public Ice::Logger
+    {
+    public:
+        ~LoggerAdminLogger() override;
 
-//
-// A logger that works in tandem with a "Logger" admin facet.
-//
-class LoggerAdminLogger : public Ice::Logger
-{
-public:
-
-    //
-    // Return the associated Admin facet
-    //
-    virtual Ice::ObjectPtr getFacet() const = 0;
-
-    //
-    // Destroy this logger, in particular join any thread
-    // that this logger may have started
-    //
-    virtual void destroy() = 0;
-};
-ICE_DEFINE_PTR(LoggerAdminLoggerPtr, LoggerAdminLogger);
+        // Returns the associated Admin facet
+        [[nodiscard]] virtual Ice::ObjectPtr getFacet() const = 0;
 
-LoggerAdminLoggerPtr
-createLoggerAdminLogger(const Ice::PropertiesPtr&, const Ice::LoggerPtr&);
+        // Once detach is called, the logger only logs to the local logger.
+        virtual void detach() = 0;
+    };
+    using LoggerAdminLoggerPtr = std::shared_ptr<LoggerAdminLogger>;
 
+    LoggerAdminLoggerPtr createLoggerAdminLogger(const Ice::PropertiesPtr&, const Ice::LoggerPtr&);
 }
 
 #endif

data/dist/ice/cpp/src/Ice/LoggerI.cpp

@@ -1,80 +1,51 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
-#include <IceUtil/Time.h>
-#include <Ice/LoggerI.h>
-#include <IceUtil/StringUtil.h>
-#include <IceUtil/Mutex.h>
-#include <IceUtil/MutexPtrLock.h>
+#include "LoggerI.h"
+#include "ConsoleUtil.h"
+#include "FileUtil.h"
+#include "Ice/LocalExceptions.h"
+#include "Ice/StringUtil.h"
+#include "TimeUtil.h"
 
-#include <Ice/LocalException.h>
-#include <IceUtil/FileUtil.h>
-
-#ifdef __IBMCPP__
-// Work-around for xlC visibility bug
-// See "ifstream::tellg visibility error" thread on IBM xlC forum
-extern template class std::fpos<char*>;
-#endif
+#include <iostream>
+#include <mutex>
+#include <sstream>
 
 using namespace std;
 using namespace Ice;
 using namespace IceInternal;
-using namespace IceUtilInternal;
 
 namespace
 {
+    mutex outputMutex;
 
-IceUtil::Mutex* outputMutex = 0;
-
-class Init
-{
-public:
-
-    Init()
-    {
-        outputMutex = new IceUtil::Mutex;
-    }
-
-    ~Init()
-    {
-        delete outputMutex;
-        outputMutex = 0;
-    }
-};
-
-Init init;
-
-//
-// Timeout in milliseconds after which rename will be attempted
-// in case of failures renaming files. That is set to 5 minutes.
-//
-const IceUtil::Time retryTimeout = IceUtil::Time::seconds(5 * 60);
-
+    // Timeout after which rename will be attempted in case of failures renaming files. That is set to 5 minutes.
+    const chrono::minutes retryTimeout = chrono::minutes(5); // NOLINT(cert-err58-cpp)
 }
 
-Ice::LoggerI::LoggerI(const string& prefix, const string& file,
-                      bool convert, size_t sizeMax) :
-    _prefix(prefix),
-    _convert(convert),
-    _converter(getProcessStringConverter()),
-    _sizeMax(sizeMax)
+Ice::Logger::~Logger() = default; // avoid weak vtable
+
+Ice::LoggerI::LoggerI(string prefix, string file, bool convert, size_t sizeMax)
+    : _prefix(std::move(prefix)),
+      _convert(convert),
+      _converter(getProcessStringConverter()),
+      _file(std::move(file)),
+      _sizeMax(sizeMax)
 {
-    if(!prefix.empty())
+    if (!_prefix.empty())
     {
-        _formattedPrefix = prefix + ": ";
+        _formattedPrefix = _prefix + ": ";
     }
 
-    if(!file.empty())
+    if (!_file.empty())
     {
-        _file = file;
-        _out.open(IceUtilInternal::streamFilename(file).c_str(), fstream::out | fstream::app);
-        if(!_out.is_open())
+        _out.open(IceInternal::streamFilename(_file).c_str(), fstream::out | fstream::app);
+        if (!_out.is_open())
         {
             throw InitializationException(__FILE__, __LINE__, "FileLogger: cannot open " + _file);
         }
 
-        if(_sizeMax > 0)
+        if (_sizeMax > 0)
         {
             _out.seekp(0, _out.end);
         }
@@ -83,7 +54,7 @@ Ice::LoggerI::LoggerI(const string& prefix, const string& file,
 
 Ice::LoggerI::~LoggerI()
 {
-    if(_out.is_open())
+    if (_out.is_open())
     {
         _out.close();
     }
@@ -98,8 +69,8 @@ Ice::LoggerI::print(const string& message)
 void
 Ice::LoggerI::trace(const string& category, const string& message)
 {
-    string s = "-- " + IceUtil::Time::now().toDateTime() + " " + _formattedPrefix;
-    if(!category.empty())
+    string s = "-- " + timePointToDateTimeString(chrono::system_clock::now()) + " " + _formattedPrefix;
+    if (!category.empty())
     {
         s += category + ": ";
     }
@@ -111,13 +82,17 @@ Ice::LoggerI::trace(const string& category, const string& message)
 void
 Ice::LoggerI::warning(const string& message)
 {
-    write("-! " + IceUtil::Time::now().toDateTime() + " " + _formattedPrefix + "warning: " + message, true);
+    write(
+        "-! " + timePointToDateTimeString(chrono::system_clock::now()) + " " + _formattedPrefix + "warning: " + message,
+        true);
 }
 
 void
 Ice::LoggerI::error(const string& message)
 {
-    write("!! " + IceUtil::Time::now().toDateTime() + " " + _formattedPrefix + "error: " + message, true);
+    write(
+        "!! " + timePointToDateTimeString(chrono::system_clock::now()) + " " + _formattedPrefix + "error: " + message,
+        true);
 }
 
 string
@@ -127,45 +102,44 @@ Ice::LoggerI::getPrefix()
 }
 
 LoggerPtr
-Ice::LoggerI::cloneWithPrefix(const std::string& prefix)
+Ice::LoggerI::cloneWithPrefix(std::string prefix)
 {
-    IceUtilInternal::MutexPtrLock<IceUtil::Mutex> sync(outputMutex); // for _sizeMax
-    return ICE_MAKE_SHARED(LoggerI, prefix, _file, _convert, _sizeMax);
+    lock_guard lock(outputMutex); // for _sizeMax
+    return make_shared<LoggerI>(std::move(prefix), _file, _convert, _sizeMax);
 }
 
 void
 Ice::LoggerI::write(const string& message, bool indent)
 {
-    IceUtilInternal::MutexPtrLock<IceUtil::Mutex> sync(outputMutex);
-
+    unique_lock lock(outputMutex);
     string s = message;
 
-    if(indent)
+    if (indent)
     {
         string::size_type idx = 0;
-        while((idx = s.find("\n", idx)) != string::npos)
+        while ((idx = s.find('\n', idx)) != string::npos)
         {
             s.insert(idx + 1, "   ");
             ++idx;
         }
     }
 
-    if(_out.is_open())
+    if (_out.is_open())
     {
-        if(_sizeMax > 0)
+        if (_sizeMax > 0)
         {
             //
             // If file size + message size exceeds max size we archive the log file,
             // but we do not archive empty files or truncate messages.
             //
             size_t sz = static_cast<size_t>(_out.tellp());
-            if(sz > 0 && sz + message.size() >= _sizeMax && _nextRetry <= IceUtil::Time::now())
+            if (sz > 0 && sz + message.size() >= _sizeMax && _nextRetry <= chrono::steady_clock::now())
             {
                 string basename = _file;
                 string ext;
 
-                size_t i = basename.rfind(".");
-                if(i != string::npos && i + 1 < basename.size())
+                size_t i = basename.rfind('.');
+                if (i != string::npos && i + 1 < basename.size())
                 {
                     ext = basename.substr(i + 1);
                     basename = basename.substr(0, i);
@@ -174,20 +148,20 @@ Ice::LoggerI::write(const string& message, bool indent)
 
                 int id = 0;
                 string archive;
-                string date = IceUtil::Time::now().toString("%Y%m%d-%H%M%S");
-                while(true)
+                string date = timePointToString(chrono::system_clock::now(), "%Y%m%d-%H%M%S");
+                while (true)
                 {
                     ostringstream oss;
                     oss << basename << "-" << date;
-                    if(id > 0)
+                    if (id > 0)
                     {
                         oss << "-" << id;
                     }
-                    if(!ext.empty())
+                    if (!ext.empty())
                     {
                         oss << "." << ext;
                     }
-                    if(IceUtilInternal::fileExists(oss.str()))
+                    if (IceInternal::fileExists(oss.str()))
                     {
                         id++;
                         continue;
@@ -196,13 +170,13 @@ Ice::LoggerI::write(const string& message, bool indent)
                     break;
                 }
 
-                int err = IceUtilInternal::rename(_file, archive);
+                int err = IceInternal::rename(_file, archive);
 
-                _out.open(IceUtilInternal::streamFilename(_file).c_str(), fstream::out | fstream::app);
+                _out.open(IceInternal::streamFilename(_file).c_str(), fstream::out | fstream::app);
 
-                if(err)
+                if (err)
                 {
-                    _nextRetry = IceUtil::Time::now() + retryTimeout;
+                    _nextRetry = chrono::steady_clock::now() + retryTimeout;
 
                     //
                     // We temporarily set the maximum size to 0 to ensure there isn't more rename attempts
@@ -210,23 +184,24 @@ Ice::LoggerI::write(const string& message, bool indent)
                     //
                     size_t sizeMax = _sizeMax;
                     _sizeMax = 0;
-                    sync.release();
-                    error("FileLogger: cannot rename `" + _file + "'\n" + IceUtilInternal::lastErrorToString());
-                    sync.acquire();
+                    lock.unlock();
+                    error("FileLogger: cannot rename '" + _file + "'\n" + IceInternal::lastErrorToString());
+                    lock.lock();
                     _sizeMax = sizeMax;
                 }
                 else
                 {
-                    _nextRetry = IceUtil::Time();
+                    _nextRetry = chrono::steady_clock::time_point();
                 }
 
-                if(!_out.is_open())
+                if (!_out.is_open())
                 {
-                    sync.release();
-                    error("FileLogger: cannot open `" + _file + "':\nlog messages will be sent to stderr");
+                    lock.unlock();
+                    error("FileLogger: cannot open '" + _file + "':\nlog messages will be sent to stderr");
                     write(message, indent);
                     return;
-                }            }
+                }
+            }
         }
         _out << s << endl;
     }
@@ -238,7 +213,7 @@ Ice::LoggerI::write(const string& message, bool indent)
         // code page encoding for printing. If the _convert member is set to false
         // we don't do any conversion.
         //
-        if(!_convert)
+        if (!_convert)
         {
             //
             // Use fprintf_s to avoid encoding conversion when stderr is connected

data/dist/ice/cpp/src/Ice/LoggerI.h

@@ -1,52 +1,47 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_LOGGER_I_H
 #define ICE_LOGGER_I_H
 
-#include <Ice/Logger.h>
-#include <Ice/StringConverter.h>
+#include "Ice/Logger.h"
+#include "Ice/StringConverter.h"
+#include <chrono>
 #include <fstream>
 
 namespace Ice
 {
-
-class LoggerI : public Logger
-{
-public:
-
-    LoggerI(const std::string&, const std::string&, bool convert = true, std::size_t sizeMax = 0);
-    ~LoggerI();
-
-    virtual void print(const std::string&);
-    virtual void trace(const std::string&, const std::string&);
-    virtual void warning(const std::string&);
-    virtual void error(const std::string&);
-    virtual std::string getPrefix();
-    virtual LoggerPtr cloneWithPrefix(const std::string&);
-
-private:
-
-    void write(const std::string&, bool);
-
-    const std::string _prefix;
-    std::string _formattedPrefix;
-    const bool _convert;
-    const StringConverterPtr _converter;
-    std::ofstream _out;
-
-    std::string _file;
-    std::size_t _sizeMax;
-
-    //
-    // In case of a log file rename failure is set to the time in milliseconds
-    // after which rename could be attempted again. Otherwise is set to zero.
-    //
-    IceUtil::Time _nextRetry;
-};
-ICE_DEFINE_PTR(LoggerIPtr, LoggerI);
-
+    class LoggerI final : public Logger
+    {
+    public:
+        LoggerI(std::string prefix, std::string file, bool convert = true, std::size_t sizeMax = 0);
+        ~LoggerI() override;
+
+        void print(const std::string&) final;
+        void trace(const std::string& category, const std::string& message) final;
+        void warning(const std::string&) final;
+        void error(const std::string&) final;
+        std::string getPrefix() final;
+        LoggerPtr cloneWithPrefix(std::string) final;
+
+    private:
+        void write(const std::string&, bool);
+
+        const std::string _prefix;
+        std::string _formattedPrefix;
+        const bool _convert;
+        const StringConverterPtr _converter;
+        std::ofstream _out;
+
+        const std::string _file;
+        std::size_t _sizeMax;
+
+        //
+        // In case of a log file rename failure is set to the time in milliseconds
+        // after which rename could be attempted again. Otherwise is set to zero.
+        //
+        std::chrono::steady_clock::time_point _nextRetry;
+    };
+    using LoggerIPtr = std::shared_ptr<LoggerI>;
 }
 
 #endif

data/dist/ice/cpp/src/Ice/LoggerMiddleware.cpp

@@ -0,0 +1,176 @@
+// Copyright (c) ZeroC, Inc.
+
+#include "LoggerMiddleware.h"
+#include "Ice/StringUtil.h"
+#include "Ice/UserException.h"
+
+using namespace std;
+using namespace Ice;
+using namespace IceInternal;
+
+LoggerMiddleware::LoggerMiddleware(
+    Ice::ObjectPtr next,
+    LoggerPtr logger,
+    int traceLevel,
+    const char* traceCat,
+    int warningLevel,
+    ToStringMode toStringMode)
+    : _next(std::move(next)),
+      _logger(std::move(logger)),
+      _traceLevel(traceLevel),
+      _traceCat(traceCat),
+      _warningLevel(warningLevel),
+      _toStringMode(toStringMode)
+{
+    assert(_next);
+    assert(_logger);
+    assert(_traceLevel > 0 || _warningLevel > 0);
+}
+
+void
+LoggerMiddleware::dispatch(Ice::IncomingRequest& request, function<void(OutgoingResponse)> sendResponse)
+{
+    try
+    {
+        _next->dispatch(
+            request,
+            [sendResponse = std::move(sendResponse), self = shared_from_this()](OutgoingResponse response)
+            {
+                switch (response.replyStatus())
+                {
+                    case ReplyStatus::Ok:
+                    case ReplyStatus::UserException:
+                        if (self->_traceLevel > 0)
+                        {
+                            self->logDispatch(response.replyStatus(), response.current());
+                        }
+                        break;
+
+                    case ReplyStatus::UnknownException:
+                    case ReplyStatus::UnknownUserException:
+                    case ReplyStatus::UnknownLocalException:
+                        self->logDispatchFailed(response.exceptionDetails(), response.current());
+                        break;
+
+                    default:
+                        if (self->_traceLevel > 0 || self->_warningLevel > 1)
+                        {
+                            self->logDispatchFailed(response.exceptionDetails(), response.current());
+                        }
+                        break;
+                }
+                sendResponse(std::move(response));
+            });
+    }
+    catch (const UserException&)
+    {
+        if (_traceLevel > 0)
+        {
+            logDispatch(ReplyStatus::UserException, request.current());
+        }
+        throw;
+    }
+    catch (const UnknownException& ex)
+    {
+        logDispatchFailed(ex, request.current()); // always log when this middleware installed
+        throw;
+    }
+    catch (const DispatchException& ex)
+    {
+        if (_traceLevel > 0 || _warningLevel > 1)
+        {
+            logDispatchFailed(ex, request.current());
+        }
+        throw;
+    }
+    catch (const Ice::LocalException& ex)
+    {
+        logDispatchFailed(ex, request.current());
+        throw;
+    }
+    catch (const std::exception& ex)
+    {
+        logDispatchFailed(ex.what(), request.current());
+        throw;
+    }
+    catch (...)
+    {
+        logDispatchFailed("c++ exception", request.current());
+        throw;
+    }
+}
+
+void
+LoggerMiddleware::logDispatch(ReplyStatus replyStatus, const Current& current) const noexcept
+{
+    Trace out{_logger, _traceCat};
+    out << "dispatch of " << current.operation << " to ";
+    printTarget(out, current);
+    out << " returned a response status with reply status " << replyStatus;
+}
+
+void
+LoggerMiddleware::logDispatchFailed(string_view exceptionDetails, const Current& current) const noexcept
+{
+    Warning out{_logger};
+    out << "failed to dispatch " << current.operation << " to ";
+    printTarget(out, current);
+
+    if (!exceptionDetails.empty())
+    {
+        out << ":\n" << exceptionDetails;
+    }
+}
+
+void
+LoggerMiddleware::logDispatchFailed(const LocalException& ex, const Current& current) const noexcept
+{
+    ostringstream os;
+    os << ex;
+    logDispatchFailed(os.str(), current);
+}
+
+void
+LoggerMiddleware::printTarget(LoggerOutputBase& out, const Current& current) const noexcept
+{
+    out << identityToString(current.id, _toStringMode);
+
+    if (!current.facet.empty())
+    {
+        out << " -f " << escapeString(current.facet, "", _toStringMode);
+    }
+
+    out << " over ";
+
+    if (current.con)
+    {
+        ConnectionInfoPtr connInfo = nullptr;
+        try
+        {
+            connInfo = current.con->getInfo();
+            while (connInfo->underlying)
+            {
+                connInfo = connInfo->underlying;
+            }
+        }
+        catch (...)
+        {
+            // Thrown by getInfo() when the connection is closed.
+        }
+
+        if (auto ipConnInfo = dynamic_pointer_cast<IPConnectionInfo>(connInfo))
+        {
+            out << ipConnInfo->localAddress << ':' << ipConnInfo->localPort << "<->" << ipConnInfo->remoteAddress << ':'
+                << ipConnInfo->remotePort;
+        }
+        else
+        {
+            // Connection::toString returns a multiline string, so we just use type() here for bt and similar.
+            out << current.con->type();
+        }
+    }
+    else
+    {
+        out << "colloc";
+    }
+}

data/dist/ice/cpp/src/Ice/LoggerMiddleware.h

@@ -0,0 +1,42 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_LOGGER_MIDDLEWARE_H
+#define ICE_LOGGER_MIDDLEWARE_H
+
+#include "Ice/Initialize.h" // for ToStringMode
+#include "Ice/Logger.h"
+#include "Ice/LoggerUtil.h"
+#include "Ice/Object.h"
+
+namespace IceInternal
+{
+    /// A middleware that logs warnings for failed dispatches.
+    class LoggerMiddleware final : public Ice::Object, public std::enable_shared_from_this<LoggerMiddleware>
+    {
+    public:
+        LoggerMiddleware(
+            Ice::ObjectPtr next,
+            Ice::LoggerPtr logger,
+            int traceLevel,
+            const char* traceCat,
+            int warningLevel,
+            Ice::ToStringMode toStringMode);
+
+        void dispatch(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>) final;
+
+    private:
+        void logDispatch(Ice::ReplyStatus replyStatus, const Ice::Current& current) const noexcept;
+        void logDispatchFailed(std::string_view message, const Ice::Current& current) const noexcept;
+        void logDispatchFailed(const Ice::LocalException& localException, const Ice::Current& current) const noexcept;
+        void printTarget(Ice::LoggerOutputBase& out, const Ice::Current& current) const noexcept;
+
+        Ice::ObjectPtr _next;
+        Ice::LoggerPtr _logger;
+        int _traceLevel;
+        const char* _traceCat;
+        int _warningLevel;
+        Ice::ToStringMode _toStringMode;
+    };
+}
+
+#endif