zeroc-ice 3.7.9.1 → 3.8.0

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

@@ -0,0 +1,31 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_LOGGER_ADMIN_I_H
+#define ICE_LOGGER_ADMIN_I_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;
+
+        // Returns the associated Admin facet
+        [[nodiscard]] virtual Ice::ObjectPtr getFacet() const = 0;
+
+        // 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

@@ -0,0 +1,234 @@
+// Copyright (c) ZeroC, Inc.
+
+#include "LoggerI.h"
+#include "ConsoleUtil.h"
+#include "FileUtil.h"
+#include "Ice/LocalExceptions.h"
+#include "Ice/StringUtil.h"
+#include "TimeUtil.h"
+
+#include <iostream>
+#include <mutex>
+#include <sstream>
+
+using namespace std;
+using namespace Ice;
+using namespace IceInternal;
+
+namespace
+{
+    mutex outputMutex;
+
+    // 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::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())
+    {
+        _formattedPrefix = _prefix + ": ";
+    }
+
+    if (!_file.empty())
+    {
+        _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)
+        {
+            _out.seekp(0, _out.end);
+        }
+    }
+}
+
+Ice::LoggerI::~LoggerI()
+{
+    if (_out.is_open())
+    {
+        _out.close();
+    }
+}
+
+void
+Ice::LoggerI::print(const string& message)
+{
+    write(message, false);
+}
+
+void
+Ice::LoggerI::trace(const string& category, const string& message)
+{
+    string s = "-- " + timePointToDateTimeString(chrono::system_clock::now()) + " " + _formattedPrefix;
+    if (!category.empty())
+    {
+        s += category + ": ";
+    }
+    s += message;
+
+    write(s, true);
+}
+
+void
+Ice::LoggerI::warning(const string& message)
+{
+    write(
+        "-! " + timePointToDateTimeString(chrono::system_clock::now()) + " " + _formattedPrefix + "warning: " + message,
+        true);
+}
+
+void
+Ice::LoggerI::error(const string& message)
+{
+    write(
+        "!! " + timePointToDateTimeString(chrono::system_clock::now()) + " " + _formattedPrefix + "error: " + message,
+        true);
+}
+
+string
+Ice::LoggerI::getPrefix()
+{
+    return _prefix;
+}
+
+LoggerPtr
+Ice::LoggerI::cloneWithPrefix(std::string prefix)
+{
+    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)
+{
+    unique_lock lock(outputMutex);
+    string s = message;
+
+    if (indent)
+    {
+        string::size_type idx = 0;
+        while ((idx = s.find('\n', idx)) != string::npos)
+        {
+            s.insert(idx + 1, "   ");
+            ++idx;
+        }
+    }
+
+    if (_out.is_open())
+    {
+        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 <= chrono::steady_clock::now())
+            {
+                string basename = _file;
+                string ext;
+
+                size_t i = basename.rfind('.');
+                if (i != string::npos && i + 1 < basename.size())
+                {
+                    ext = basename.substr(i + 1);
+                    basename = basename.substr(0, i);
+                }
+                _out.close();
+
+                int id = 0;
+                string archive;
+                string date = timePointToString(chrono::system_clock::now(), "%Y%m%d-%H%M%S");
+                while (true)
+                {
+                    ostringstream oss;
+                    oss << basename << "-" << date;
+                    if (id > 0)
+                    {
+                        oss << "-" << id;
+                    }
+                    if (!ext.empty())
+                    {
+                        oss << "." << ext;
+                    }
+                    if (IceInternal::fileExists(oss.str()))
+                    {
+                        id++;
+                        continue;
+                    }
+                    archive = oss.str();
+                    break;
+                }
+
+                int err = IceInternal::rename(_file, archive);
+
+                _out.open(IceInternal::streamFilename(_file).c_str(), fstream::out | fstream::app);
+
+                if (err)
+                {
+                    _nextRetry = chrono::steady_clock::now() + retryTimeout;
+
+                    //
+                    // We temporarily set the maximum size to 0 to ensure there isn't more rename attempts
+                    // in the nested error call.
+                    //
+                    size_t sizeMax = _sizeMax;
+                    _sizeMax = 0;
+                    lock.unlock();
+                    error("FileLogger: cannot rename '" + _file + "'\n" + IceInternal::lastErrorToString());
+                    lock.lock();
+                    _sizeMax = sizeMax;
+                }
+                else
+                {
+                    _nextRetry = chrono::steady_clock::time_point();
+                }
+
+                if (!_out.is_open())
+                {
+                    lock.unlock();
+                    error("FileLogger: cannot open '" + _file + "':\nlog messages will be sent to stderr");
+                    write(message, indent);
+                    return;
+                }
+            }
+        }
+        _out << s << endl;
+    }
+    else
+    {
+#if defined(_WIN32)
+        //
+        // Convert the message from the native narrow string encoding to the console
+        // code page encoding for printing. If the _convert member is set to false
+        // we don't do any conversion.
+        //
+        if (!_convert)
+        {
+            //
+            // Use fprintf_s to avoid encoding conversion when stderr is connected
+            // to Windows console. When _convert is set to false we always output
+            // UTF-8 encoded messages.
+            //
+            fprintf_s(stderr, "%s\n", nativeToUTF8(s, _converter).c_str());
+            fflush(stderr);
+        }
+        else
+        {
+            consoleErr << s << endl;
+        }
+#else
+        cerr << s << endl;
+#endif
+    }
+}

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

@@ -0,0 +1,47 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_LOGGER_I_H
+#define ICE_LOGGER_I_H
+
+#include "Ice/Logger.h"
+#include "Ice/StringConverter.h"
+#include <chrono>
+#include <fstream>
+
+namespace Ice
+{
+    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

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

@@ -0,0 +1,76 @@
+
+// Copyright (c) ZeroC, Inc.
+
+#include "Ice/LoggerUtil.h"
+#include "Ice/LocalExceptions.h"
+#include "Ice/Logger.h"
+#include "Instance.h"
+
+using namespace std;
+
+string
+Ice::LoggerOutputBase::str() const
+{
+    return _os.str();
+}
+
+ostringstream&
+Ice::LoggerOutputBase::_stream()
+{
+    return _os;
+}
+
+Ice::LoggerOutputBase&
+Ice::operator<<(Ice::LoggerOutputBase& out, ios_base& (*val)(ios_base&))
+{
+    out._stream() << val;
+    return out;
+}
+
+Ice::LoggerOutputBase&
+Ice::loggerInsert(Ice::LoggerOutputBase& out, const Ice::Exception& ex)
+{
+    out._stream() << ex;
+    return out;
+}
+
+Ice::Trace::Trace(LoggerPtr logger, string category) : _logger(std::move(logger)), _category(std::move(category)) {}
+
+Ice::Trace::~Trace() { flush(); }
+
+void
+Ice::Trace::flush()
+{
+    string s = _stream().str();
+    if (!s.empty())
+    {
+        _logger->trace(_category, s);
+    }
+    _stream().str("");
+}
+
+Ice::LoggerPlugin::LoggerPlugin(const CommunicatorPtr& communicator, const LoggerPtr& logger)
+{
+    if (communicator == nullptr)
+    {
+        throw PluginInitializationException(__FILE__, __LINE__, "communicator cannot be null");
+    }
+
+    if (logger == nullptr)
+    {
+        throw PluginInitializationException(__FILE__, __LINE__, "logger cannot be null");
+    }
+
+    IceInternal::InstancePtr instance = IceInternal::getInstance(communicator);
+    instance->setLogger(logger);
+}
+
+void
+Ice::LoggerPlugin::initialize()
+{
+}
+
+void
+Ice::LoggerPlugin::destroy()
+{
+}

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

@@ -0,0 +1,20 @@
+// Copyright (c) ZeroC, Inc.
+
+#include "Ice/MarshaledResult.h"
+#include "Ice/ObjectAdapter.h"
+#include "Ice/ReplyStatus.h"
+#include "Protocol.h"
+
+using namespace Ice;
+using namespace IceInternal;
+
+// currentProtocolEncoding because we're writing the protocol header.
+MarshaledResult::MarshaledResult(const Current& current)
+    : _ostr(current.adapter->getCommunicator(), currentProtocolEncoding)
+{
+    _ostr.writeBlob(replyHdr, sizeof(replyHdr));
+    _ostr.write(current.requestId);
+    _ostr.write(ReplyStatus::Ok);
+}
+
+MarshaledResult::~MarshaledResult() = default; // avoid weak vtable