Merge 'treewide: use fmtlib's fmt::format_string in format() ' from K…

…efu Chai

this series enables `seastar::format()` to use compile-time format check.

using `fmt::format_string` would allow us to perform compile-time
format checking. so in this change, we switch to `fmt::format_string`
when fmtlib's version is greater or equal to 8.0, which introduced
the compile-time checking.

also, because the `fmt::format_string` can only be instantiated with
a compile-time constexpr, the fmt string specified in test is changed
to a constexpr accordingly.

please note, this is a breaking change which might require caller to use
`seastar::format()` if the tree is compiled with libstdc++ 13 or a standard
library with `std::formt()` implemented.

Closes #1727

* github.com:scylladb/seastar:
  print: use fmtlib's fmt::format_string in format()
  rpc: do not use seastar::format() in rpc logger
  treewide: s/format/seastar::format/

apps/io_tester/io_tester.cc

@@ -966,7 +966,7 @@ struct convert<options> {
  } else if (st == "steady") {
  op.sleep_fn = timer_sleep<std::chrono::steady_clock>;
  } else {
- throw std::runtime_error(format("Unknown sleep_type {}", st));
+ throw std::runtime_error(seastar::format("Unknown sleep_type {}", st));
  }
  }
  if (node["pause_distribution"]) {
@@ -976,7 +976,7 @@ struct convert<options> {
  } else if (pd == "poisson") {
  op.pause_fn = make_poisson_pause;
  } else {
- throw std::runtime_error(format("Unknown pause_distribution {}", pd));
+ throw std::runtime_error(seastar::format("Unknown pause_distribution {}", pd));
  }
  }
  return true;

include/seastar/core/print.hh

@@ -140,9 +140,9 @@ log(A&&... a) {
  */
 template <typename... A>
 sstring
-format(const char* fmt, A&&... a) {
+format(fmt::format_string<A...> fmt, A&&... a) {
  fmt::memory_buffer out;
- fmt::format_to(fmt::appender(out), fmt::runtime(fmt), std::forward<A>(a)...);
+ fmt::format_to(fmt::appender(out), fmt, std::forward<A>(a)...);
  return sstring{out.data(), out.size()};
 }
 

include/seastar/rpc/rpc.hh

@@ -217,7 +217,9 @@ class logger {
  // Ignore less severe levels in order not to spam user's log with messages during transition,
  // i.e. when the user still only defines a level-less logger.
  } else if (_logger && level <= log_level::info) {
- _logger(format(fmt, std::forward<Args>(args)...));
+ fmt::memory_buffer out;
+ fmt::format_to(fmt::appender(out), fmt::runtime(fmt), std::forward<Args>(args)...);
+ _logger(sstring{out.data(), out.size()});
  }
  }
 

src/core/semaphore.cc

@@ -85,23 +85,23 @@ static_assert(std::is_nothrow_move_constructible_v<named_semaphore>);
 
 named_semaphore_timed_out::named_semaphore_timed_out(std::string_view msg) noexcept : _msg() {
  try {
- _msg = format("Semaphore timed out: {}", msg);
+ _msg = seastar::format("Semaphore timed out: {}", msg);
  } catch (...) {
  // ignore, empty _msg will generate a static message in what().
  }
 }
 
 broken_named_semaphore::broken_named_semaphore(std::string_view msg) noexcept : _msg() {
  try {
- _msg = format("Semaphore broken: {}", msg);
+ _msg = seastar::format("Semaphore broken: {}", msg);
  } catch (...) {
  // ignore, empty _msg will generate a static message in what().
  }
 }
 
 named_semaphore_aborted::named_semaphore_aborted(std::string_view msg) noexcept : _msg() {
  try {
- _msg = format("Semaphore aborted: {}", msg);
+ _msg = seastar::format("Semaphore aborted: {}", msg);
  } catch (...) {
  // ignore, empty _msg will generate a static message in what().
  }

src/json/formatter.cc

@@ -71,7 +71,7 @@ static bool needs_escaping(const string_view& str) {
 
 static sstring string_view_to_json(const string_view& str) {
  if (!needs_escaping(str)) {
- return format("\"{}\"", str);
+ return seastar::format("\"{}\"", str);
  }
 
  ostringstream oss;

src/net/net.cc

@@ -154,7 +154,7 @@ qp::qp(bool register_copy_stats,
  //
  // Tx
  sm::make_gauge(_queue_name + "_tx_packet_queue_last_bunch", _stats.tx.good.last_bunch,
- sm::description(format("Holds a number of packets sent in the bunch. "
+ sm::description(seastar::format("Holds a number of packets sent in the bunch. "
  "A high value in conjunction with a high value of a {} indicates an efficient Tx packets bulking.", _queue_name + "_tx_packet_queue"))),
  // Rx
  sm::make_gauge(_queue_name + "_rx_packet_queue_last_bunch", _stats.rx.good.last_bunch,
@@ -165,10 +165,10 @@ qp::qp(bool register_copy_stats,
  //
  // Tx
  sm::make_counter(_queue_name + "_tx_frags", _stats.tx.good.nr_frags,
- sm::description(format("Counts a number of sent fragments. Divide this value by a {} to get an average number of fragments in a Tx packet.", _queue_name + "_tx_packets"))),
+ sm::description(seastar::format("Counts a number of sent fragments. Divide this value by a {} to get an average number of fragments in a Tx packet.", _queue_name + "_tx_packets"))),
  // Rx
  sm::make_counter(_queue_name + "_rx_frags", _stats.rx.good.nr_frags,
- sm::description(format("Counts a number of received fragments. Divide this value by a {} to get an average number of fragments in an Rx packet.", _queue_name + "_rx_packets"))),
+ sm::description(seastar::format("Counts a number of received fragments. Divide this value by a {} to get an average number of fragments in an Rx packet.", _queue_name + "_rx_packets"))),
  });
 
  if (register_copy_stats) {
@@ -178,20 +178,20 @@ qp::qp(bool register_copy_stats,
  //
  // Tx
  sm::make_counter(_queue_name + "_tx_copy_bytes", _stats.tx.good.copy_bytes,
- sm::description(format("Counts a number of sent bytes that were handled in a non-zero-copy way. Divide this value by a {} to get a portion of data sent using a non-zero-copy flow.", _queue_name + "_tx_bytes"))),
+ sm::description(seastar::format("Counts a number of sent bytes that were handled in a non-zero-copy way. Divide this value by a {} to get a portion of data sent using a non-zero-copy flow.", _queue_name + "_tx_bytes"))),
  // Rx
  sm::make_counter(_queue_name + "_rx_copy_bytes", _stats.rx.good.copy_bytes,
- sm::description(format("Counts a number of received bytes that were handled in a non-zero-copy way. Divide this value by an {} to get a portion of received data handled using a non-zero-copy flow.", _queue_name + "_rx_bytes"))),
+ sm::description(seastar::format("Counts a number of received bytes that were handled in a non-zero-copy way. Divide this value by an {} to get a portion of received data handled using a non-zero-copy flow.", _queue_name + "_rx_bytes"))),
 
  //
  // Non-zero-copy data fragments rate: DERIVE:0:u
  //
  // Tx
  sm::make_counter(_queue_name + "_tx_copy_frags", _stats.tx.good.copy_frags,
- sm::description(format("Counts a number of sent fragments that were handled in a non-zero-copy way. Divide this value by a {} to get a portion of fragments sent using a non-zero-copy flow.", _queue_name + "_tx_frags"))),
+ sm::description(seastar::format("Counts a number of sent fragments that were handled in a non-zero-copy way. Divide this value by a {} to get a portion of fragments sent using a non-zero-copy flow.", _queue_name + "_tx_frags"))),
  // Rx
  sm::make_counter(_queue_name + "_rx_copy_frags", _stats.rx.good.copy_frags,
- sm::description(format("Counts a number of received fragments that were handled in a non-zero-copy way. Divide this value by a {} to get a portion of received fragments handled using a non-zero-copy flow.", _queue_name + "_rx_frags"))),
+ sm::description(seastar::format("Counts a number of received fragments that were handled in a non-zero-copy way. Divide this value by a {} to get a portion of received fragments handled using a non-zero-copy flow.", _queue_name + "_rx_frags"))),
 
  });
  }