�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FSRC%2F'>SRC</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2F'>mariadb-11.7.2</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fwsrep-lib%2F'>wsrep-lib</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fwsrep-lib%2Fsrc%2F'>src</a>/</p><hr><h3>✏️ Editing: reporter.cpp</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>/*
 * Copyright (C) 2021 Codership Oy &lt;info@codership.com&gt;
 *
 * This file is part of wsrep-lib.
 *
 * Wsrep-lib is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * Wsrep-lib is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with wsrep-lib.  If not, see &lt;https://www.gnu.org/licenses/&gt;.
 */

#include &quot;wsrep/reporter.hpp&quot;
#include &quot;wsrep/logger.hpp&quot;

#include &lt;sstream&gt;
#include &lt;iomanip&gt;

#include &lt;cassert&gt;
#include &lt;cstring&gt;  // strerror()
#include &lt;cstdlib&gt;  // mkstemp()
#include &lt;cerrno&gt;   // errno
#include &lt;unistd.h&gt; // write()
#include &lt;cstdio&gt;   // rename(), snprintf()
#include &lt;ctime&gt;    // clock_gettime()
#include &lt;cmath&gt;    // floor()

static std::string const TEMP_EXTENSION(&quot;.XXXXXX&quot;);

static std::string make_progress_string(int const from, int const to,
                                        int const total,int const done,
                                        int const indefinite)
{
    std::ostringstream os;

    os &lt;&lt; &quot;{ \&quot;from\&quot;: &quot;     &lt;&lt; from       &lt;&lt; &quot;, &quot;
       &lt;&lt; &quot;\&quot;to\&quot;: &quot;         &lt;&lt; to         &lt;&lt; &quot;, &quot;
       &lt;&lt; &quot;\&quot;total\&quot;: &quot;      &lt;&lt; total      &lt;&lt; &quot;, &quot;
       &lt;&lt; &quot;\&quot;done\&quot;: &quot;       &lt;&lt; done       &lt;&lt; &quot;, &quot;
       &lt;&lt; &quot;\&quot;indefinite\&quot;: &quot; &lt;&lt; indefinite &lt;&lt; &quot; }&quot;;

    return os.str();
}

static std::string const indefinite_progress
    (make_progress_string(-1, -1, -1, -1, -1));
static std::string const steady_state
    (make_progress_string(-1, -1, 0, 0, -1));

static inline double
timestamp()
{
    struct timespec time;
    clock_gettime(CLOCK_REALTIME, &amp;time);
    return (double(time.tv_sec) + double(time.tv_nsec)*1.0e-9);
}

wsrep::reporter::reporter(wsrep::mutex&amp;      mutex,
                          const std::string&amp; file_name,
                          size_t const       max_msg)
    : mutex_(mutex)
    , file_name_(file_name)
    , progress_(indefinite_progress)
    , template_(new char [file_name_.length() + TEMP_EXTENSION.length() + 1])
    , state_(wsrep::reporter::s_disconnected_disconnected)
    , initialized_(false)
    , err_msg_()
    , warn_msg_()
    , events_()
    , max_msg_(max_msg)
{
    template_[file_name_.length() + TEMP_EXTENSION.length()] = &#039;\0&#039;;
    write_file(timestamp());
}

wsrep::reporter::~reporter()
{
    delete [] template_;
}

wsrep::reporter::substates
wsrep::reporter::substate_map(enum wsrep::server_state::state const state)
{
    switch (state)
    {
    case wsrep::server_state::s_disconnected:
        initialized_ = false;
        return s_disconnected_disconnected;
    case wsrep::server_state::s_initializing:
        if (s_disconnected_disconnected == state_)
            return s_disconnected_initializing;
        else if (s_joining_sst == state_)
            return s_joining_initializing;
        else if (s_joining_initializing == state_)
            return s_joining_initializing; // continuation
        else
        {
            assert(0);
            return state_;
        }
    case wsrep::server_state::s_initialized:
        initialized_ = true;
        if (s_disconnected_initializing &gt;= state_)
            return s_disconnected_initialized;
        else if (s_joining_initializing == state_)
            return s_joining_ist;
        else if (s_joining_ist == state_)
            return s_joining_ist; // continuation
        else
        {
            assert(0);
            return state_;
        }
    case wsrep::server_state::s_connected:
        return s_connected_waiting;
    case wsrep::server_state::s_joiner:
        if (initialized_)
            return s_joining_initialized;
        else
            return s_joining_sst;
    case wsrep::server_state::s_joined:
        return s_joined_syncing;
    case wsrep::server_state::s_donor:
        return s_donor_sending;
    case wsrep::server_state::s_synced:
        return s_synced_running;
    case wsrep::server_state::s_disconnecting:
        return s_disconnecting_disconnecting;
    default:
        assert(0);
        return state_;
    }
}

// See https://www.ietf.org/rfc/rfc4627.txt
static std::string escape_json(const std::string&amp; str)
{
    std::ostringstream os;
    for (auto c = str.cbegin(); c != str.cend(); ++c)
    {
        switch (*c)
        {
        case &#039;&quot;&#039;: os &lt;&lt; &quot;\\\&quot;&quot;; break;
        case &#039;\\&#039;: os &lt;&lt; &quot;\\\\&quot;; break;
        case &#039;/&#039;: os &lt;&lt; &quot;\\/&quot;; break;
        case &#039;\b&#039;: os &lt;&lt; &quot;\\b&quot;; break;
        case &#039;\f&#039;: os &lt;&lt; &quot;\\f&quot;; break;
        case &#039;\n&#039;: os &lt;&lt; &quot;\\n&quot;; break;
        case &#039;\r&#039;: os &lt;&lt; &quot;\\r&quot;; break;
        case &#039;\t&#039;: os &lt;&lt; &quot;\\t&quot;; break;
        default:
            // std::iscntrl() returns non-zero for [0x00, 0x1f] and
            // backspace character. Argument type is int so cast to
            // unsigned char is needed to make it safe, see
            // https://en.cppreference.com/w/cpp/string/byte/iscntrl
            if (std::iscntrl(static_cast&lt;unsigned char&gt;(*c)))
            {
                os &lt;&lt; &quot;\\u&quot; &lt;&lt; std::hex &lt;&lt; std::setw(4) &lt;&lt;
                    std::setfill(&#039;0&#039;) &lt;&lt; static_cast&lt;int&gt;(*c);
            }
            else
            {
                os &lt;&lt; *c;
            }
        }
    }
    return os.str();
}

void
wsrep::reporter::write_log_msg(std::ostream&amp;  os,
                               const log_msg_t&amp; msg)
{
    os &lt;&lt; &quot;\t\t{\n&quot;;
    os &lt;&lt; &quot;\t\t\t\&quot;timestamp\&quot;: &quot; &lt;&lt; std::showpoint &lt;&lt; std::setprecision(18)
       &lt;&lt; msg.tstamp &lt;&lt; &quot;,\n&quot;;
    os &lt;&lt; &quot;\t\t\t\&quot;msg\&quot;: \&quot;&quot; &lt;&lt; msg.msg &lt;&lt; &quot;\&quot;\n&quot;;
    os &lt;&lt; &quot;\t\t}&quot;;
}

void
wsrep::reporter::write_event(std::ostream&amp;  os,
                             const log_msg_t&amp; msg)
{
    os &lt;&lt; &quot;\t\t{\n&quot;;
    os &lt;&lt; &quot;\t\t\t\&quot;timestamp\&quot;: &quot; &lt;&lt; std::showpoint &lt;&lt; std::setprecision(18)
       &lt;&lt; msg.tstamp &lt;&lt; &quot;,\n&quot;;
    os &lt;&lt; &quot;\t\t\t\&quot;event\&quot;: &quot; &lt;&lt; msg.msg &lt;&lt; &quot;\n&quot;;
    os &lt;&lt; &quot;\t\t}&quot;;
}

void
wsrep::reporter::write_array(std::ostream&amp;              os,
                             const std::string&amp;         label,
                             const std::deque&lt;log_msg_t&gt;&amp; msgs,
                             void (*element_writer)(std::ostream&amp; os,
                                                    const log_msg_t&amp; msg))
{
    os &lt;&lt; &quot;\t\&quot;&quot; &lt;&lt; label &lt;&lt; &quot;\&quot;: [\n&quot;;
    for (size_t i(0); i &lt; msgs.size(); ++i)
    {
        element_writer(os, msgs[i]);
        os &lt;&lt; (i+1 &lt; msgs.size() ? &quot;,\n&quot; : &quot;\n&quot;);
    }
    os &lt;&lt; &quot;\t],\n&quot;;
}

// write data to temporary file and then rename it to target file for atomicity
void
wsrep::reporter::write_file(double const tstamp)
{
    enum progress_type {
        t_indefinite = -1, // indefinite wait
        t_progressive,     // measurable progress
        t_final            // final state
    };

    struct strings {
        const char*   state;
        const char*   comment;
        progress_type type;
    };

    static const struct strings strings[substates_max] =
        {
            { &quot;DISCONNECTED&quot;,  &quot;Disconnected&quot;,    t_indefinite  },
            { &quot;DISCONNECTED&quot;,  &quot;Initializing&quot;,    t_indefinite  },
            { &quot;DISCONNECTED&quot;,  &quot;Connecting&quot;,      t_indefinite  },
            { &quot;CONNECTED&quot;,     &quot;Waiting&quot;,         t_indefinite  },
            { &quot;JOINING&quot;,       &quot;Receiving state&quot;, t_progressive },
            { &quot;JOINING&quot;,       &quot;Receiving SST&quot;,   t_progressive },
            { &quot;JOINING&quot;,       &quot;Initializing&quot;,    t_progressive },
            { &quot;JOINING&quot;,       &quot;Receiving IST&quot;,   t_progressive },
            { &quot;JOINED&quot;,        &quot;Syncing&quot;,         t_progressive },
            { &quot;SYNCED&quot;,        &quot;Operational&quot;,     t_final       },
            { &quot;DONOR&quot;,         &quot;Donating SST&quot;,    t_progressive },
            { &quot;DISCONNECTING&quot;, &quot;Disconnecting&quot;,   t_indefinite  }
        };

    double const seconds(floor(tstamp));
    time_t const tt = time_t(seconds);
    struct tm    date;
    localtime_r(&amp;tt, &amp;date);

    char date_str[85] = { &#039;\0&#039;, };
    snprintf(date_str, sizeof(date_str) - 1,
             &quot;%04d-%02d-%02d %02d:%02d:%02d.%03d&quot;,
             date.tm_year + 1900, date.tm_mon + 1, date.tm_mday,
             date.tm_hour, date.tm_min, date.tm_sec,
             (int)((tstamp-seconds)*1000));

    std::ostringstream os;
    os &lt;&lt; &quot;{\n&quot;;
    os &lt;&lt; &quot;\t\&quot;date\&quot;: \&quot;&quot; &lt;&lt; date_str &lt;&lt; &quot;\&quot;,\n&quot;;
    os &lt;&lt; &quot;\t\&quot;timestamp\&quot;: &quot; &lt;&lt; std::showpoint &lt;&lt; std::setprecision(18)
       &lt;&lt; tstamp &lt;&lt; &quot;,\n&quot;;
    write_array(os, &quot;errors&quot;,   err_msg_, write_log_msg);
    write_array(os, &quot;warnings&quot;, warn_msg_, write_log_msg);
    write_array(os, &quot;events&quot;, events_, write_event);
    os &lt;&lt; &quot;\t\&quot;status\&quot;: {\n&quot;;
    os &lt;&lt; &quot;\t\t\&quot;state\&quot;: \&quot;&quot; &lt;&lt; strings[state_].state &lt;&lt; &quot;\&quot;,\n&quot;;
    os &lt;&lt; &quot;\t\t\&quot;comment\&quot;: \&quot;&quot; &lt;&lt; strings[state_].comment &lt;&lt; &quot;\&quot;,\n&quot;;
    os &lt;&lt; &quot;\t\t\&quot;progress\&quot;: &quot; &lt;&lt; progress_ &lt;&lt; &quot;\n&quot;;
    os &lt;&lt; &quot;\t}\n&quot;;
    os &lt;&lt; &quot;}\n&quot;;

    std::string const str(os.str());

    // prepare template for mkstemp()
    file_name_.copy(template_, file_name_.length());
    TEMP_EXTENSION.copy(template_ +file_name_.length(),TEMP_EXTENSION.length());

    int const fd(mkstemp(template_));
    if (fd &lt; 0)
    {
        std::cerr &lt;&lt; &quot;Reporter could not open temporary file `&quot; &lt;&lt; template_
                  &lt;&lt; &quot;&#039;: &quot; &lt;&lt; strerror(errno) &lt;&lt; &quot; (&quot; &lt;&lt; errno &lt;&lt; &quot;)\n&quot;;
        return;
    }
    ssize_t err(write(fd, str.c_str(), str.length()));
    close(fd);
    if (err &lt; 0)
    {
        std::cerr &lt;&lt; &quot;Could not write &quot; &lt;&lt; str.length()
                  &lt;&lt; &quot; bytes to temporary file &#039;&quot;
                  &lt;&lt; template_ &lt;&lt; &quot;&#039;: &quot; &lt;&lt; strerror(errno)
                  &lt;&lt; &quot; (&quot; &lt;&lt; errno &lt;&lt; &quot;)\n&quot;;
        return;
    }

    rename(template_, file_name_.c_str());
}

void
wsrep::reporter::report_state(enum server_state::state const s)
{
    wsrep::unique_lock&lt;wsrep::mutex&gt; lock(mutex_);

    substates const state(substate_map(s));

    if (state != state_)
    {
        state_ = state;

        if (state_ == s_synced_running)
            progress_ = steady_state;
        else
            progress_ = indefinite_progress;

        write_file(timestamp());
    }
}

void
wsrep::reporter::report_progress(const std::string&amp; json)
{
    wsrep::unique_lock&lt;wsrep::mutex&gt; lock(mutex_);

    if (json != progress_)
    {
        if (state_ != s_synced_running)
        {
            // ignore any progress in SYNCED state
            progress_ = json;
            write_file(timestamp());
        }
    }
}

void
wsrep::reporter::report_event(const std::string&amp; json)
{
    wsrep::unique_lock&lt;wsrep::mutex&gt; lock(mutex_);
    if (events_.size() == max_msg_)
    {
        events_.pop_front();
    }
    events_.push_back({timestamp(), json});
    write_file(timestamp());
}

void
wsrep::reporter::report_log_msg(log_level const    lvl,
                                const std::string&amp; msg,
                                double             tstamp)
{
    std::deque&lt;log_msg_t&gt;&amp; deque(lvl == error ? err_msg_ : warn_msg_);

    wsrep::unique_lock&lt;wsrep::mutex&gt; lock(mutex_);

    if (deque.empty() || msg != deque.back().msg)
    {
        if (deque.size() == max_msg_) deque.pop_front();

        if (tstamp &lt;= undefined) tstamp = timestamp();

        /* Log messages are not expected to be json formatted, so we escape
           the message strings here to keep the report file well formatted. */
        log_msg_t entry({tstamp, escape_json(msg)});
        deque.push_back(entry);
        write_file(tstamp);
    }
}
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fwsrep-lib%2Fsrc'>🔙 Back</a></p>