b12f/nixpkgs
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

Merge pull request #176418 from Yureien/init/dragonflydb

Browse source 
dragonflydb: init at 0.1.0
This commit is contained in:
Ben Siraphob 2022-06-07 14:02:26 -07:00 committed by GitHub
parent ef47fd71fc 109e13db24
commit 033da0465f
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
8 changed files with 958 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
nixos/doc/manual/from_md/release-notes/rl-2211.section.xml
View file

@ -48,6 +48,13 @@
<link xlink:href="options.html#opt-virtualisation.appvm.enable">virtualisation.appvm</link>.
</para>
</listitem>
<listitem>
<para>
<link xlink:href="https://dragonflydb.io/">dragonflydb</link>,
a modern replacement for Redis and Memcached. Available as
<link linkend="opt-services.dragonflydb.enable">services.dragonflydb</link>.
</para>
</listitem>
<listitem>
<para>
<link xlink:href="https://github.com/leetronics/infnoise">infnoise</link>,

2
nixos/doc/manual/release-notes/rl-2211.section.md
View file

@ -25,6 +25,8 @@ In addition to numerous new and upgraded packages, this release has the followin
- [appvm](https://github.com/jollheef/appvm), Nix based app VMs. Available as [virtualisation.appvm](options.html#opt-virtualisation.appvm.enable).
- [dragonflydb](https://dragonflydb.io/), a modern replacement for Redis and Memcached. Available as [services.dragonflydb](#opt-services.dragonflydb.enable).
- [infnoise](https://github.com/leetronics/infnoise), a hardware True Random Number Generator dongle.
Available as [services.infnoise](options.html#opt-services.infnoise.enable).

1
nixos/modules/module-list.nix
View file

@ -348,6 +348,7 @@
./services/databases/clickhouse.nix
./services/databases/cockroachdb.nix
./services/databases/couchdb.nix
./services/databases/dragonflydb.nix
./services/databases/firebird.nix
./services/databases/foundationdb.nix
./services/databases/hbase.nix

152
nixos/modules/services/databases/dragonflydb.nix Normal file
View file

@ -0,0 +1,152 @@
{ config, lib, pkgs, ... }:
with lib;
let
cfg = config.services.dragonflydb;
dragonflydb = pkgs.dragonflydb;
settings =
{
port = cfg.port;
dir = "/var/lib/dragonflydb";
keys_output_limit = cfg.keysOutputLimit;
} //
(lib.optionalAttrs (cfg.bind != null) { bind = cfg.bind; }) //
(lib.optionalAttrs (cfg.requirePass != null) { requirepass = cfg.requirePass; }) //
(lib.optionalAttrs (cfg.maxMemory != null) { maxmemory = cfg.maxMemory; }) //
(lib.optionalAttrs (cfg.memcachePort != null) { memcache_port = cfg.memcachePort; }) //
(lib.optionalAttrs (cfg.dbNum != null) { dbnum = cfg.dbNum; }) //
(lib.optionalAttrs (cfg.cacheMode != null) { cache_mode = cfg.cacheMode; });
in
{
###### interface
options = {
services.dragonflydb = {
enable = mkEnableOption "DragonflyDB";
user = mkOption {
type = types.str;
default = "dragonfly";
description = "The user to run DragonflyDB as";
};
port = mkOption {
type = types.port;
default = 6379;
description = "The TCP port to accept connections.";
};
bind = mkOption {
type = with types; nullOr str;
default = "127.0.0.1";
description = ''
The IP interface to bind to.
<literal>null</literal> means "all interfaces".
'';
};
requirePass = mkOption {
type = with types; nullOr str;
default = null;
description = "Password for database";
example = "letmein!";
};
maxMemory = mkOption {
type = with types; nullOr ints.unsigned;
default = null;
description = ''
The maximum amount of memory to use for storage (in bytes).
<literal>null</literal> means this will be automatically set.
'';
};
memcachePort = mkOption {
type = with types; nullOr port;
default = null;
description = ''
To enable memcached compatible API on this port.
<literal>null</literal> means disabled.
'';
};
keysOutputLimit = mkOption {
type = types.ints.unsigned;
default = 8192;
description = ''
Maximum number of returned keys in keys command.
<literal>keys</literal> is a dangerous command.
We truncate its result to avoid blowup in memory when fetching too many keys.
'';
};
dbNum = mkOption {
type = with types; nullOr ints.unsigned;
default = null;
description = "Maximum number of supported databases for <literal>select</literal>";
};
cacheMode = mkOption {
type = with types; nullOr bool;
default = null;
description = ''
Once this mode is on, Dragonfly will evict items least likely to be stumbled
upon in the future but only when it is near maxmemory limit.
'';
};
};
};
###### implementation
config = mkIf config.services.dragonflydb.enable {
users.users = optionalAttrs (cfg.user == "dragonfly") {
dragonfly.description = "DragonflyDB server user";
dragonfly.isSystemUser = true;
dragonfly.group = "dragonfly";
};
users.groups = optionalAttrs (cfg.user == "dragonfly") { dragonfly = { }; };
environment.systemPackages = [ dragonflydb ];
systemd.services.dragonflydb = {
description = "DragonflyDB server";
wantedBy = [ "multi-user.target" ];
after = [ "network.target" ];
serviceConfig = {
ExecStart = "${dragonflydb}/bin/dragonfly --alsologtostderr ${builtins.concatStringsSep " " (attrsets.mapAttrsToList (n: v: "--${n} ${strings.escapeShellArg v}") settings)}";
User = cfg.user;
# Filesystem access
ReadWritePaths = [ settings.dir ];
StateDirectory = "dragonflydb";
StateDirectoryMode = "0700";
# Process Properties
LimitMEMLOCK = "infinity";
# Caps
CapabilityBoundingSet = "";
NoNewPrivileges = true;
# Sandboxing
ProtectSystem = "strict";
ProtectHome = true;
PrivateTmp = true;
PrivateDevices = true;
ProtectKernelTunables = true;
ProtectKernelModules = true;
ProtectControlGroups = true;
LockPersonality = true;
RestrictAddressFamilies = [ "AF_INET" "AF_INET6" ];
RestrictRealtime = true;
PrivateMounts = true;
MemoryDenyWriteExecute = true;
};
};
};
}

109
pkgs/servers/nosql/dragonflydb/default.nix Normal file
View file

@ -0,0 +1,109 @@
{ fetchFromGitHub
, fetchurl
, lib
, stdenv
, double-conversion
, gperftools
, mimalloc
, rapidjson
, liburing
, xxHash
, abseil-cpp_202111
, gbenchmark
, glog
, gtest
, jemalloc
, gcc-unwrapped
, autoconf
, autoconf-archive
, automake
, cmake
, ninja
, boost
, libunwind
, libtool
, openssl
}:
let
pname = "dragonflydb";
version = "0.1.0";
src = fetchFromGitHub {
owner = pname;
repo = "dragonfly";
rev = "v${version}";
hash = "sha256-P6WMW/n+VezWDXGagT4B+ZYyCp8oufDV6MTrpKpLZcs=";
fetchSubmodules = true;
};
# Needed exactly 5.4.4 for patch to work
lua = fetchurl {
url = "https://github.com/lua/lua/archive/refs/tags/v5.4.4.tar.gz";
hash = "sha256-L/ibvqIqfIuRDWsAb1ukVZ7c9GiiVTfO35mI7ZD2tFA=";
};
in
stdenv.mkDerivation {
inherit pname version src;
postPatch = ''
mkdir -p ./build/{third_party,_deps}
ln -s ${double-conversion.src} ./build/third_party/dconv
ln -s ${mimalloc.src} ./build/third_party/mimalloc
ln -s ${rapidjson.src} ./build/third_party/rapidjson
ln -s ${gbenchmark.src} ./build/_deps/benchmark-src
ln -s ${gtest.src} ./build/_deps/gtest-src
cp -R --no-preserve=mode,ownership ${gperftools.src} ./build/third_party/gperf
cp -R --no-preserve=mode,ownership ${liburing.src} ./build/third_party/uring
cp -R --no-preserve=mode,ownership ${xxHash.src} ./build/third_party/xxhash
cp -R --no-preserve=mode,ownership ${abseil-cpp_202111.src} ./build/_deps/abseil_cpp-src
cp -R --no-preserve=mode,ownership ${glog.src} ./build/_deps/glog-src
chmod u+x ./build/third_party/uring/configure
cp ./build/third_party/xxhash/cli/xxhsum.{1,c} ./build/third_party/xxhash
patch -p1 -d ./build/_deps/glog-src < ${./glog.patch}
sed '
s@REPLACEJEMALLOCURL@file://${jemalloc.src}@
s@REPLACELUAURL@file://${lua}@
' ${./fixes.patch} | patch -p1
'';
nativeBuildInputs = [
autoconf
autoconf-archive
automake
cmake
ninja
];
buildInputs = [
boost
libunwind
libtool
openssl
];
cmakeFlags = [
"-DCMAKE_AR=${gcc-unwrapped}/bin/gcc-ar"
"-DCMAKE_RANLIB=${gcc-unwrapped}/bin/gcc-ranlib"
];
ninjaFlags = "dragonfly";
doCheck = false;
dontUseNinjaInstall = true;
installPhase = ''
runHook preInstall
mkdir -p $out/bin
cp ./dragonfly $out/bin
runHook postInstall
'';
meta = with lib; {
description = "A modern replacement for Redis and Memcached";
homepage = "https://dragonflydb.io/";
license = licenses.bsl11;
platforms = platforms.linux;
maintainers = with maintainers; [ yureien ];
};
}

132
pkgs/servers/nosql/dragonflydb/fixes.patch Normal file
View file

@ -0,0 +1,132 @@
diff --git a/helio/cmake/third_party.cmake b/helio/cmake/third_party.cmake
index aeb78d9..e9d4e6b 100644
--- a/helio/cmake/third_party.cmake
+++ b/helio/cmake/third_party.cmake
@@ -143,7 +143,7 @@ endfunction()
FetchContent_Declare(
gtest
- URL https://github.com/google/googletest/archive/release-1.11.0.zip
+ DOWNLOAD_COMMAND true
)
FetchContent_GetProperties(gtest)
@@ -154,7 +154,7 @@ endif ()
FetchContent_Declare(
benchmark
- URL https://github.com/google/benchmark/archive/v1.6.1.tar.gz
+ DOWNLOAD_COMMAND true
)
FetchContent_GetProperties(benchmark)
@@ -169,7 +169,7 @@ endif ()
FetchContent_Declare(
abseil_cpp
- URL https://github.com/abseil/abseil-cpp/archive/20211102.0.tar.gz
+ DOWNLOAD_COMMAND true
PATCH_COMMAND patch -p1 < "${CMAKE_CURRENT_LIST_DIR}/../patches/abseil-20211102.patch"
)
@@ -183,11 +183,7 @@ endif()
FetchContent_Declare(
glog
- GIT_REPOSITORY https://github.com/romange/glog
- GIT_TAG Absl
-
- GIT_PROGRESS TRUE
- GIT_SHALLOW TRUE
+ DOWNLOAD_COMMAND true
)
FetchContent_GetProperties(glog)
@@ -233,10 +229,7 @@ endif()
add_third_party(
gperf
- URL https://github.com/gperftools/gperftools/archive/gperftools-2.9.1.tar.gz
- #GIT_REPOSITORY https://github.com/gperftools/gperftools
- #GIT_TAG gperftools-2.9.1
- GIT_SHALLOW TRUE
+ DOWNLOAD_COMMAND true
PATCH_COMMAND autoreconf -i # update runs every time for some reason
# CMAKE_PASS_FLAGS "-DGPERFTOOLS_BUILD_HEAP_PROFILER=OFF -DGPERFTOOLS_BUILD_HEAP_CHECKER=OFF \
# -DGPERFTOOLS_BUILD_DEBUGALLOC=OFF -DBUILD_TESTING=OFF \
@@ -260,11 +253,12 @@ else()
endif()
add_third_party(mimalloc
- URL https://github.com/microsoft/mimalloc/archive/refs/tags/v2.0.5.tar.gz
+ DOWNLOAD_COMMAND true
# Add -DCMAKE_BUILD_TYPE=Debug -DCMAKE_C_FLAGS=-O0 to debug
CMAKE_PASS_FLAGS "-DCMAKE_BUILD_TYPE=Release -DMI_BUILD_SHARED=OFF -DMI_BUILD_TESTS=OFF \
- -DMI_INSTALL_TOPLEVEL=ON -DMI_OVERRIDE=${MI_OVERRIDE} -DCMAKE_C_FLAGS=-g"
+ -DMI_INSTALL_TOPLEVEL=ON -DMI_OVERRIDE=${MI_OVERRIDE} -DCMAKE_C_FLAGS=-g \
+ -DCMAKE_INSTALL_LIBDIR=${THIRD_PARTY_LIB_DIR}/mimalloc/lib"
BUILD_COMMAND make -j4 mimalloc-static
INSTALL_COMMAND make install
@@ -274,7 +268,7 @@ add_third_party(mimalloc
)
add_third_party(jemalloc
- URL https://github.com/jemalloc/jemalloc/releases/download/5.2.1/jemalloc-5.2.1.tar.bz2
+ URL REPLACEJEMALLOCURL
PATCH_COMMAND ./autogen.sh
CONFIGURE_COMMAND <SOURCE_DIR>/configure --prefix=${THIRD_PARTY_LIB_DIR}/jemalloc --with-jemalloc-prefix=je_ --disable-libdl
)
@@ -282,24 +276,23 @@ add_third_party(jemalloc
add_third_party(
xxhash
- URL https://github.com/Cyan4973/xxHash/archive/v0.8.0.tar.gz
+ DOWNLOAD_COMMAND true
SOURCE_SUBDIR cmake_unofficial
- CMAKE_PASS_FLAGS "-DCMAKE_POSITION_INDEPENDENT_CODE=ON -DBUILD_SHARED_LIBS=OFF"
+ CMAKE_PASS_FLAGS "-DCMAKE_POSITION_INDEPENDENT_CODE=ON -DBUILD_SHARED_LIBS=OFF \
+ -DCMAKE_INSTALL_LIBDIR=${THIRD_PARTY_LIB_DIR}/xxhash/lib"
)
add_third_party(
uring
- GIT_REPOSITORY https://github.com/axboe/liburing.git
- GIT_TAG liburing-2.1
+ DOWNLOAD_COMMAND true
CONFIGURE_COMMAND <SOURCE_DIR>/configure --prefix=${THIRD_PARTY_LIB_DIR}/uring
BUILD_IN_SOURCE 1
)
add_third_party(
rapidjson
- GIT_REPOSITORY https://github.com/Tencent/rapidjson.git
- GIT_TAG 1a803826f1197b5e30703afe4b9c0e7dd48074f5
+ DOWNLOAD_COMMAND true
CMAKE_PASS_FLAGS "-DRAPIDJSON_BUILD_TESTS=OFF -DRAPIDJSON_BUILD_EXAMPLES=OFF \
-DRAPIDJSON_BUILD_DOC=OFF"
LIB "none"
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 0dc0824..d5b38b3 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,6 +1,6 @@
add_third_party(
lua
- URL https://github.com/lua/lua/archive/refs/tags/v5.4.4.tar.gz
+ URL REPLACELUAURL
PATCH_COMMAND patch -p1 -i "${CMAKE_SOURCE_DIR}/patches/lua-v5.4.4.patch"
CONFIGURE_COMMAND echo
BUILD_IN_SOURCE 1
@@ -11,7 +11,8 @@ add_third_party(
add_third_party(
dconv
- URL https://github.com/google/double-conversion/archive/refs/tags/v3.2.0.tar.gz
+ DOWNLOAD_COMMAND true
+ CMAKE_PASS_FLAGS "-DCMAKE_INSTALL_LIBDIR=${THIRD_PARTY_LIB_DIR}/dconv/lib"
LIB libdouble-conversion.a
)

553
pkgs/servers/nosql/dragonflydb/glog.patch Normal file
View file

@ -0,0 +1,553 @@
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 846b4448..b4900ead 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -39,6 +39,7 @@ option (PRINT_UNSYMBOLIZED_STACK_TRACES
"Print file offsets in traces instead of symbolizing" OFF)
option (WITH_CUSTOM_PREFIX "Enable support for user-generated message prefixes" ON)
option (WITH_GFLAGS "Use gflags" ON)
+option (WITH_ABSL "Use absl flags" OFF)
option (WITH_GTEST "Use Google Test" ON)
option (WITH_PKGCONFIG "Enable pkg-config support" ON)
option (WITH_SYMBOLIZE "Enable symbolize module" ON)
@@ -87,6 +88,13 @@ if (WITH_GFLAGS)
endif (gflags_FOUND)
endif (WITH_GFLAGS)
+if (WITH_ABSL)
+ set (HAVE_ABSL_FLAGS 1)
+ set (ac_cv_have_abslflags 1)
+else (WITH_ABSL)
+set (ac_cv_have_abslflags 0)
+endif (WITH_ABSL)
+
find_package (Threads)
find_package (Unwind)
@@ -1025,7 +1033,7 @@ write_basic_package_version_file (
${CMAKE_CURRENT_BINARY_DIR}/glog-config-version.cmake
COMPATIBILITY SameMajorVersion)
-export (TARGETS glog NAMESPACE glog:: FILE glog-targets.cmake)
+# export (TARGETS glog NAMESPACE glog:: FILE glog-targets.cmake)
export (PACKAGE glog)
get_filename_component (_PREFIX "${CMAKE_INSTALL_PREFIX}" ABSOLUTE)
diff --git a/src/base/commandlineflags.h b/src/base/commandlineflags.h
index bcb12dea..1c9d9294 100644
--- a/src/base/commandlineflags.h
+++ b/src/base/commandlineflags.h
@@ -57,6 +57,25 @@
#include <gflags/gflags.h>
+#else
+#ifdef HAVE_ABSL_FLAGS
+#include <absl/flags/flag.h>
+
+#define FLAG(name) absl::GetFlag(FLAGS_##name)
+
+#define DEFINE_bool(name, value, meaning) \
+ ABSL_FLAG(bool, name, value, meaning)
+
+#define DEFINE_int32(name, value, meaning) \
+ ABSL_FLAG(GOOGLE_NAMESPACE::int32, name, value, meaning)
+
+#define DEFINE_uint32(name, value, meaning) \
+ ABSL_FLAG(GOOGLE_NAMESPACE::uint32, name, value, meaning)
+
+#define DEFINE_string(name, value, meaning) \
+ ABSL_FLAG(std::string, name, value, meaning)
+
+
#else
#include <glog/logging.h>
@@ -108,6 +127,7 @@
} \
using fLS::FLAGS_##name
+#endif
#endif // HAVE_LIB_GFLAGS
// Define GLOG_DEFINE_* using DEFINE_* . By using these macros, we
diff --git a/src/base/mutex.h b/src/base/mutex.h
index e82c597f..a58c1412 100644
--- a/src/base/mutex.h
+++ b/src/base/mutex.h
@@ -319,11 +319,6 @@ class WriterMutexLock {
void operator=(const WriterMutexLock&);
};
-// Catch bug where variable name is omitted, e.g. MutexLock (&mu);
-#define MutexLock(x) COMPILE_ASSERT(0, mutex_lock_decl_missing_var_name)
-#define ReaderMutexLock(x) COMPILE_ASSERT(0, rmutex_lock_decl_missing_var_name)
-#define WriterMutexLock(x) COMPILE_ASSERT(0, wmutex_lock_decl_missing_var_name)
-
} // namespace MUTEX_NAMESPACE
using namespace MUTEX_NAMESPACE;
diff --git a/src/config.h.cmake.in b/src/config.h.cmake.in
index b225b7ec..a4c58c96 100644
--- a/src/config.h.cmake.in
+++ b/src/config.h.cmake.in
@@ -34,6 +34,8 @@
/* define if you have google gflags library */
#cmakedefine HAVE_LIB_GFLAGS
+#cmakedefine HAVE_ABSL_FLAGS
+
/* define if you have google gmock library */
#cmakedefine HAVE_LIB_GMOCK
diff --git a/src/glog/logging.h.in b/src/glog/logging.h.in
index 95a573b1..54cd838f 100644
--- a/src/glog/logging.h.in
+++ b/src/glog/logging.h.in
@@ -89,6 +89,10 @@
#include <gflags/gflags.h>
#endif
+#if @ac_cv_have_abslflags@
+#include <absl/flags/declare.h>
+#endif
+
#if @ac_cv_cxx11_atomic@ && __cplusplus >= 201103L
#include <atomic>
#elif defined(GLOG_OS_WINDOWS)
@@ -395,6 +399,14 @@ typedef void(*CustomPrefixCallback)(std::ostream& s, const LogMessageInfo& l, vo
#undef DECLARE_uint32
#endif
+#if @ac_cv_have_abslflags@
+#define DECLARE_VARIABLE 1
+#define DECLARE_bool(name) ABSL_DECLARE_FLAG(bool, name)
+#define DECLARE_int32(name) ABSL_DECLARE_FLAG(@ac_google_namespace@::int32, name)
+#define DECLARE_uint32(name) ABSL_DECLARE_FLAG(@ac_google_namespace@::uint32, name)
+#define DECLARE_string(name) ABSL_DECLARE_FLAG(std::string, name)
+#endif
+
#ifndef DECLARE_VARIABLE
#define DECLARE_VARIABLE(type, shorttype, name, tn) \
namespace fL##shorttype { \
diff --git a/src/glog/vlog_is_on.h.in b/src/glog/vlog_is_on.h.in
index 7526fc34..16e60f46 100644
--- a/src/glog/vlog_is_on.h.in
+++ b/src/glog/vlog_is_on.h.in
@@ -64,6 +64,14 @@
#include <glog/log_severity.h>
#if defined(__GNUC__)
+
+#if @ac_cv_have_abslflags@
+ extern int32_t absl_proxy_v;
+ #define VLEVEL (@ac_google_namespace@::absl_proxy_v)
+#else
+ #define VLEVEL (FLAGS_v)
+#endif
+
// We emit an anonymous static int* variable at every VLOG_IS_ON(n) site.
// (Normally) the first time every VLOG_IS_ON(n) site is hit,
// we determine what variable will dynamically control logging at this site:
@@ -74,7 +82,7 @@
__extension__ \
({ static @ac_google_namespace@::SiteFlag vlocal__ = {NULL, NULL, 0, NULL}; \
@ac_google_namespace@::int32 verbose_level__ = (verboselevel); \
- (vlocal__.level == NULL ? @ac_google_namespace@::InitVLOG3__(&vlocal__, &FLAGS_v, \
+ (vlocal__.level == NULL ? @ac_google_namespace@::InitVLOG3__(&vlocal__, &VLEVEL, \
__FILE__, verbose_level__) : *vlocal__.level >= verbose_level__); \
})
#else
diff --git a/src/logging.cc b/src/logging.cc
index 4028ccc0..fc618d3a 100644
--- a/src/logging.cc
+++ b/src/logging.cc
@@ -103,7 +103,9 @@ using std::fdopen;
#endif
// There is no thread annotation support.
+#ifndef EXCLUSIVE_LOCKS_REQUIRED
#define EXCLUSIVE_LOCKS_REQUIRED(mu)
+#endif
static bool BoolFromEnv(const char *varname, bool defval) {
const char* const valstr = getenv(varname);
@@ -351,8 +353,9 @@ static const char* GetAnsiColorCode(GLogColor color) {
// Safely get max_log_size, overriding to 1 if it somehow gets defined as 0
static uint32 MaxLogSize() {
- return (FLAGS_max_log_size > 0 && FLAGS_max_log_size < 4096
- ? FLAGS_max_log_size
+ uint32 maxlogsize = FLAG(max_log_size);
+ return (maxlogsize > 0 && maxlogsize < 4096
+ ? maxlogsize
: 1);
}
@@ -721,7 +724,7 @@ inline void LogDestination::SetStderrLogging(LogSeverity min_severity) {
// Prevent any subtle race conditions by wrapping a mutex lock around
// all this stuff.
MutexLock l(&log_mutex);
- FLAGS_stderrthreshold = min_severity;
+ absl::SetFlag(&FLAGS_stderrthreshold, min_severity);
}
inline void LogDestination::LogToStderr() {
@@ -747,8 +750,8 @@ static void ColoredWriteToStderrOrStdout(FILE* output, LogSeverity severity,
const char* message, size_t len) {
bool is_stdout = (output == stdout);
const GLogColor color = (LogDestination::terminal_supports_color() &&
- ((!is_stdout && FLAGS_colorlogtostderr) ||
- (is_stdout && FLAGS_colorlogtostdout)))
+ ((!is_stdout && FLAG(colorlogtostderr)) ||
+ (is_stdout && FLAG(colorlogtostdout))))
? SeverityToColor(severity)
: COLOR_DEFAULT;
@@ -789,7 +792,7 @@ static void ColoredWriteToStdout(LogSeverity severity, const char* message,
FILE* output = stdout;
// We also need to send logs to the stderr when the severity is
// higher or equal to the stderr threshold.
- if (severity >= FLAGS_stderrthreshold) {
+ if (severity >= FLAG(stderrthreshold)) {
output = stderr;
}
ColoredWriteToStderrOrStdout(output, severity, message, len);
@@ -808,7 +811,7 @@ static void WriteToStderr(const char* message, size_t len) {
inline void LogDestination::MaybeLogToStderr(LogSeverity severity,
const char* message, size_t message_len, size_t prefix_len) {
- if ((severity >= FLAGS_stderrthreshold) || FLAGS_alsologtostderr) {
+ if ((severity >= FLAG(stderrthreshold)) || FLAG(alsologtostderr)) {
ColoredWriteToStderr(severity, message, message_len);
#ifdef GLOG_OS_WINDOWS
(void) prefix_len;
@@ -835,8 +838,8 @@ inline void LogDestination::MaybeLogToStderr(LogSeverity severity,
inline void LogDestination::MaybeLogToEmail(LogSeverity severity,
const char* message, size_t len) {
if (severity >= email_logging_severity_ ||
- severity >= FLAGS_logemaillevel) {
- string to(FLAGS_alsologtoemail);
+ severity >= FLAG(logemaillevel)) {
+ string to(FLAG(alsologtoemail));
if (!addresses_.empty()) {
if (!to.empty()) {
to += ",";
@@ -862,7 +865,7 @@ inline void LogDestination::MaybeLogToLogfile(LogSeverity severity,
time_t timestamp,
const char* message,
size_t len) {
- const bool should_flush = severity > FLAGS_logbuflevel;
+ const bool should_flush = severity > FLAG(logbuflevel);
LogDestination* destination = log_destination(severity);
destination->logger_->Write(should_flush, timestamp, message, len);
}
@@ -871,9 +874,9 @@ inline void LogDestination::LogToAllLogfiles(LogSeverity severity,
time_t timestamp,
const char* message,
size_t len) {
- if (FLAGS_logtostdout) { // global flag: never log to file
+ if (FLAG(logtostdout)) { // global flag: never log to file
ColoredWriteToStdout(severity, message, len);
- } else if (FLAGS_logtostderr) { // global flag: never log to file
+ } else if (FLAG(logtostderr)) { // global flag: never log to file
ColoredWriteToStderr(severity, message, len);
} else {
for (int i = severity; i >= 0; --i) {
@@ -1032,25 +1035,25 @@ void LogFileObject::FlushUnlocked(){
bytes_since_flush_ = 0;
}
// Figure out when we are due for another flush.
- const int64 next = (FLAGS_logbufsecs
+ const int64 next = (FLAG(logbufsecs)
* static_cast<int64>(1000000)); // in usec
next_flush_time_ = CycleClock_Now() + UsecToCycles(next);
}
bool LogFileObject::CreateLogfile(const string& time_pid_string) {
string string_filename = base_filename_;
- if (FLAGS_timestamp_in_logfile_name) {
+ if (FLAG(timestamp_in_logfile_name)) {
string_filename += time_pid_string;
}
string_filename += filename_extension_;
const char* filename = string_filename.c_str();
//only write to files, create if non-existant.
int flags = O_WRONLY | O_CREAT;
- if (FLAGS_timestamp_in_logfile_name) {
+ if (FLAG(timestamp_in_logfile_name)) {
//demand that the file is unique for our timestamp (fail if it exists).
flags = flags | O_EXCL;
}
- int fd = open(filename, flags, FLAGS_logfile_mode);
+ int fd = open(filename, flags, FLAG(logfile_mode));
if (fd == -1) return false;
#ifdef HAVE_FCNTL
// Mark the file close-on-exec. We don't really care if this fails
@@ -1083,7 +1086,7 @@ bool LogFileObject::CreateLogfile(const string& time_pid_string) {
file_ = fdopen(fd, "a"); // Make a FILE*.
if (file_ == NULL) { // Man, we're screwed!
close(fd);
- if (FLAGS_timestamp_in_logfile_name) {
+ if (FLAG(timestamp_in_logfile_name)) {
unlink(filename); // Erase the half-baked evidence: an unusable log file, only if we just created it.
}
return false;
@@ -1125,8 +1128,8 @@ bool LogFileObject::CreateLogfile(const string& time_pid_string) {
// Make an additional link to the log file in a place specified by
// FLAGS_log_link, if indicated
- if (!FLAGS_log_link.empty()) {
- linkpath = FLAGS_log_link + "/" + linkname;
+ if (!FLAG(log_link).empty()) {
+ linkpath = FLAG(log_link) + "/" + linkname;
unlink(linkpath.c_str()); // delete old one if it exists
if (symlink(filename, linkpath.c_str()) != 0) {
// silently ignore failures
@@ -1165,7 +1168,7 @@ void LogFileObject::Write(bool force_flush,
rollover_attempt_ = 0;
struct ::tm tm_time;
- if (FLAGS_log_utc_time) {
+ if (FLAG(log_utc_time)) {
gmtime_r(&timestamp, &tm_time);
} else {
localtime_r(&timestamp, &tm_time);
@@ -1253,14 +1256,14 @@ void LogFileObject::Write(bool force_flush,
<< ' '
<< setw(2) << tm_time.tm_hour << ':'
<< setw(2) << tm_time.tm_min << ':'
- << setw(2) << tm_time.tm_sec << (FLAGS_log_utc_time ? " UTC\n" : "\n")
+ << setw(2) << tm_time.tm_sec << (FLAG(log_utc_time) ? " UTC\n" : "\n")
<< "Running on machine: "
<< LogDestination::hostname() << '\n';
if(!g_application_fingerprint.empty()) {
file_header_stream << "Application fingerprint: " << g_application_fingerprint << '\n';
}
- const char* const date_time_format = FLAGS_log_year_in_prefix
+ const char* const date_time_format = FLAG(log_year_in_prefix)
? "yyyymmdd hh:mm:ss.uuuuuu"
: "mmdd hh:mm:ss.uuuuuu";
file_header_stream << "Running duration (h:mm:ss): "
@@ -1284,7 +1287,7 @@ void LogFileObject::Write(bool force_flush,
// greater than 4096, thereby indicating an error.
errno = 0;
fwrite(message, 1, message_len, file_);
- if ( FLAGS_stop_logging_if_full_disk &&
+ if ( FLAG(stop_logging_if_full_disk) &&
errno == ENOSPC ) { // disk full, stop writing to disk
stop_writing = true; // until the disk is
return;
@@ -1307,7 +1310,7 @@ void LogFileObject::Write(bool force_flush,
FlushUnlocked();
#ifdef GLOG_OS_LINUX
// Only consider files >= 3MiB
- if (FLAGS_drop_log_memory && file_length_ >= (3U << 20U)) {
+ if (FLAG(drop_log_memory) && file_length_ >= (3U << 20U)) {
// Don't evict the most recent 1-2MiB so as not to impact a tailer
// of the log file and to avoid page rounding issue on linux < 4.7
uint32 total_drop_length =
@@ -1348,7 +1351,7 @@ void LogCleaner::Disable() {
}
void LogCleaner::UpdateCleanUpTime() {
- const int64 next = (FLAGS_logcleansecs
+ const int64 next = (FLAG(logcleansecs)
* 1000000); // in usec
next_cleanup_time_ = CycleClock_Now() + UsecToCycles(next);
}
@@ -1664,7 +1667,7 @@ void LogMessage::Init(const char* file,
// I20201018 160715 f5d4fbb0 logging.cc:1153]
// (log level, GMT year, month, date, time, thread_id, file basename, line)
// We exclude the thread_id for the default thread.
- if (FLAGS_log_prefix && (line != kNoLogPrefix)) {
+ if (FLAG(log_prefix) && (line != kNoLogPrefix)) {
std::ios saved_fmt(NULL);
saved_fmt.copyfmt(stream());
stream().fill('0');
@@ -1672,7 +1675,7 @@ void LogMessage::Init(const char* file,
if (custom_prefix_callback == NULL) {
#endif
stream() << LogSeverityNames[severity][0];
- if (FLAGS_log_year_in_prefix) {
+ if (FLAG(log_year_in_prefix)) {
stream() << setw(4) << 1900 + logmsgtime_.year();
}
stream() << setw(2) << 1 + logmsgtime_.month()
@@ -1703,11 +1706,11 @@ void LogMessage::Init(const char* file,
}
data_->num_prefix_chars_ = data_->stream_.pcount();
- if (!FLAGS_log_backtrace_at.empty()) {
+ if (!FLAG(log_backtrace_at).empty()) {
char fileline[128];
snprintf(fileline, sizeof(fileline), "%s:%d", data_->basename_, line);
#ifdef HAVE_STACKTRACE
- if (FLAGS_log_backtrace_at == fileline) {
+ if (FLAG(log_backtrace_at) == fileline) {
string stacktrace;
DumpStackTraceToString(&stacktrace);
stream() << " (stacktrace:\n" << stacktrace << ") ";
@@ -1746,7 +1749,7 @@ ostream& LogMessage::stream() {
// Flush buffered message, called by the destructor, or any other function
// that needs to synchronize the log.
void LogMessage::Flush() {
- if (data_->has_been_flushed_ || data_->severity_ < FLAGS_minloglevel) {
+ if (data_->has_been_flushed_ || data_->severity_ < FLAG(minloglevel)) {
return;
}
@@ -1808,7 +1811,7 @@ static char fatal_message[256];
void ReprintFatalMessage() {
if (fatal_message[0]) {
const size_t n = strlen(fatal_message);
- if (!FLAGS_logtostderr) {
+ if (!FLAG(logtostderr)) {
// Also write to stderr (don't color to avoid terminal checks)
WriteToStderr(fatal_message, n);
}
@@ -1837,8 +1840,8 @@ void LogMessage::SendToLog() EXCLUSIVE_LOCKS_REQUIRED(log_mutex) {
// global flag: never log to file if set. Also -- don't log to a
// file if we haven't parsed the command line flags to get the
// program name.
- if (FLAGS_logtostderr || FLAGS_logtostdout || !IsGoogleLoggingInitialized()) {
- if (FLAGS_logtostdout) {
+ if (FLAG(logtostderr) || FLAG(logtostdout) || !IsGoogleLoggingInitialized()) {
+ if (FLAG(logtostdout)) {
ColoredWriteToStdout(data_->severity_, data_->message_text_,
data_->num_chars_to_log_);
} else {
@@ -1891,7 +1894,7 @@ void LogMessage::SendToLog() EXCLUSIVE_LOCKS_REQUIRED(log_mutex) {
fatal_time = logmsgtime_.timestamp();
}
- if (!FLAGS_logtostderr && !FLAGS_logtostdout) {
+ if (!FLAG(logtostderr) && !FLAG(logtostdout)) {
for (int i = 0; i < NUM_SEVERITIES; ++i) {
if (LogDestination::log_destinations_[i]) {
LogDestination::log_destinations_[i]->logger_->Write(true, 0, "", 0);
@@ -2238,7 +2241,7 @@ static bool SendEmailInternal(const char*dest, const char *subject,
subject, body, dest);
}
- string logmailer = FLAGS_logmailer;
+ string logmailer = FLAG(logmailer);
if (logmailer.empty()) {
logmailer = "/bin/mail";
}
@@ -2338,9 +2341,9 @@ const vector<string>& GetLoggingDirectories() {
if (logging_directories_list == NULL) {
logging_directories_list = new vector<string>;
- if ( !FLAGS_log_dir.empty() ) {
+ if ( !FLAG(log_dir).empty() ) {
// A dir was specified, we should use it
- logging_directories_list->push_back(FLAGS_log_dir);
+ logging_directories_list->push_back(FLAG(log_dir));
} else {
GetTempDirectories(logging_directories_list);
#ifdef GLOG_OS_WINDOWS
@@ -2654,7 +2657,7 @@ LogMessageTime::LogMessageTime(std::tm t) {
LogMessageTime::LogMessageTime(std::time_t timestamp, WallTime now) {
std::tm t;
- if (FLAGS_log_utc_time)
+ if (FLAG(log_utc_time))
gmtime_r(&timestamp, &t);
else
localtime_r(&timestamp, &t);
@@ -2673,7 +2676,7 @@ void LogMessageTime::init(const std::tm& t, std::time_t timestamp,
void LogMessageTime::CalcGmtOffset() {
std::tm gmt_struct;
int isDst = 0;
- if ( FLAGS_log_utc_time ) {
+ if ( FLAG(log_utc_time )) {
localtime_r(&timestamp_, &gmt_struct);
isDst = gmt_struct.tm_isdst;
gmt_struct = time_struct_;
diff --git a/src/raw_logging.cc b/src/raw_logging.cc
index 43159832..8532362b 100644
--- a/src/raw_logging.cc
+++ b/src/raw_logging.cc
@@ -123,8 +123,8 @@ static char crash_buf[kLogBufSize + 1] = { 0 }; // Will end in '\0'
GLOG_ATTRIBUTE_FORMAT(printf, 4, 5)
void RawLog__(LogSeverity severity, const char* file, int line,
const char* format, ...) {
- if (!(FLAGS_logtostdout || FLAGS_logtostderr ||
- severity >= FLAGS_stderrthreshold || FLAGS_alsologtostderr ||
+ if (!(FLAG(logtostdout) || FLAG(logtostderr) ||
+ severity >= FLAG(stderrthreshold) || FLAG(alsologtostderr) ||
!IsGoogleLoggingInitialized())) {
return; // this stderr log message is suppressed
}
diff --git a/src/utilities.cc b/src/utilities.cc
index a332f1a1..a9d5102a 100644
--- a/src/utilities.cc
+++ b/src/utilities.cc
@@ -141,7 +141,7 @@ static void DumpStackTrace(int skip_count, DebugWriter *writerfn, void *arg) {
int depth = GetStackTrace(stack, ARRAYSIZE(stack), skip_count+1);
for (int i = 0; i < depth; i++) {
#if defined(HAVE_SYMBOLIZE)
- if (FLAGS_symbolize_stacktrace) {
+ if (FLAG(symbolize_stacktrace)) {
DumpPCAndSymbol(writerfn, arg, stack[i], " ");
} else {
DumpPC(writerfn, arg, stack[i], " ");
diff --git a/src/vlog_is_on.cc b/src/vlog_is_on.cc
index e478a366..4b7a5cae 100644
--- a/src/vlog_is_on.cc
+++ b/src/vlog_is_on.cc
@@ -43,14 +43,24 @@
#include <glog/logging.h>
#include <glog/raw_logging.h>
#include "base/googleinit.h"
+#include "config.h"
// glog doesn't have annotation
#define ANNOTATE_BENIGN_RACE(address, description)
using std::string;
+#ifdef HAVE_ABSL_FLAGS
+
+ABSL_FLAG(int32_t, v, 0, "Show all VLOG(m) messages for m <= this."
+" Overridable by --vmodule.").OnUpdate([] {
+ GOOGLE_NAMESPACE::absl_proxy_v = absl::GetFlag(FLAGS_v);
+ });
+
+#else
GLOG_DEFINE_int32(v, 0, "Show all VLOG(m) messages for m <= this."
" Overridable by --vmodule.");
+#endif
GLOG_DEFINE_string(vmodule, "", "per-module verbose level."
" Argument is a comma-separated list of <module name>=<log level>."
@@ -60,6 +70,8 @@ GLOG_DEFINE_string(vmodule, "", "per-module verbose level."
_START_GOOGLE_NAMESPACE_
+int32_t absl_proxy_v = 0;
+
namespace glog_internal_namespace_ {
// Used by logging_unittests.cc so can't make it static here.
@@ -132,7 +144,8 @@ static void VLOG2Initializer() {
// Can now parse --vmodule flag and initialize mapping of module-specific
// logging levels.
inited_vmodule = false;
- const char* vmodule = FLAGS_vmodule.c_str();
+ string vmodule_str = FLAG(vmodule);
+ const char* vmodule = vmodule_str.c_str();
const char* sep;
VModuleInfo* head = NULL;
VModuleInfo* tail = NULL;
@@ -164,7 +177,7 @@ static void VLOG2Initializer() {
// This can be called very early, so we use SpinLock and RAW_VLOG here.
int SetVLOGLevel(const char* module_pattern, int log_level) {
- int result = FLAGS_v;
+ int result = FLAG(v);
size_t const pattern_len = strlen(module_pattern);
bool found = false;
{

2
pkgs/top-level/all-packages.nix
View file

@ -25867,6 +25867,8 @@ with pkgs;
dr14_tmeter = callPackage ../applications/audio/dr14_tmeter { };
dragonflydb = callPackage ../servers/nosql/dragonflydb { };
dragonfly-reverb = callPackage ../applications/audio/dragonfly-reverb { };
drawing = callPackage ../applications/graphics/drawing { };