MINIFI-311 upgraded spdlog to snapshot of master MINIFI-311 ported dockerfile to alpine MINIFI-311 allow warnings on Linux for compatibility with Alpine MINIFI-311 fixed spdlog path in BuildTests cmake file MINIFI-349 moved to multi-stage docker build MINIFI-311 removed unneeded dirs from spdlog snapshot MINIFI-312 Handle spdlog compilation failures in Alpine Linux
This closes #118. Signed-off-by: Aldrin Piri <ald...@apache.org> Project: http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/repo Commit: http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/commit/8389c8aa Tree: http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/tree/8389c8aa Diff: http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/diff/8389c8aa Branch: refs/heads/master Commit: 8389c8aa827118e5a8d605f0def6b1e4727efa90 Parents: 7ecdafa Author: Andrew Christianson <achristian...@hortonworks.com> Authored: Tue Jul 11 09:05:33 2017 -0700 Committer: Aldrin Piri <ald...@apache.org> Committed: Wed Aug 2 10:50:53 2017 -0400 ---------------------------------------------------------------------- .gitignore | 1 + CMakeLists.txt | 2 +- cmake/BuildTests.cmake | 2 +- docker/Dockerfile | 62 +- libminifi/CMakeLists.txt | 4 +- main/CMakeLists.txt | 2 +- thirdparty/civetweb-1.9.1/CMakeLists.txt | 2 +- thirdparty/spdlog-0.13.0/.gitignore | 64 - thirdparty/spdlog-0.13.0/CMakeLists.txt | 87 - thirdparty/spdlog-0.13.0/INSTALL | 13 - thirdparty/spdlog-0.13.0/LICENSE | 22 - thirdparty/spdlog-0.13.0/README.md | 218 - thirdparty/spdlog-0.13.0/astyle.sh | 5 - thirdparty/spdlog-0.13.0/cmake/Config.cmake.in | 24 - thirdparty/spdlog-0.13.0/cmake/spdlog.pc.in | 6 - .../spdlog-0.13.0/include/spdlog/async_logger.h | 82 - .../spdlog-0.13.0/include/spdlog/common.h | 143 - .../include/spdlog/details/async_log_helper.h | 391 -- .../include/spdlog/details/async_logger_impl.h | 102 - .../include/spdlog/details/file_helper.h | 118 - .../include/spdlog/details/log_msg.h | 46 - .../include/spdlog/details/logger_impl.h | 296 -- .../include/spdlog/details/mpmc_bounded_q.h | 172 - .../include/spdlog/details/null_mutex.h | 45 - .../spdlog-0.13.0/include/spdlog/details/os.h | 406 -- .../spdlog/details/pattern_formatter_impl.h | 670 --- .../include/spdlog/details/registry.h | 185 - .../include/spdlog/details/spdlog_impl.h | 245 - .../spdlog-0.13.0/include/spdlog/dummy.cpp | 22 - .../include/spdlog/fmt/bundled/format.cc | 940 ---- .../include/spdlog/fmt/bundled/format.h | 4501 ------------------ .../include/spdlog/fmt/bundled/ostream.cc | 43 - .../include/spdlog/fmt/bundled/ostream.h | 126 - .../include/spdlog/fmt/bundled/posix.cc | 238 - .../include/spdlog/fmt/bundled/posix.h | 443 -- .../include/spdlog/fmt/bundled/time.h | 58 - .../spdlog-0.13.0/include/spdlog/fmt/fmt.h | 28 - .../spdlog-0.13.0/include/spdlog/fmt/ostr.h | 17 - .../spdlog-0.13.0/include/spdlog/formatter.h | 45 - .../spdlog-0.13.0/include/spdlog/logger.h | 94 - .../include/spdlog/sinks/android_sink.h | 75 - .../include/spdlog/sinks/ansicolor_sink.h | 116 - .../include/spdlog/sinks/base_sink.h | 45 - .../include/spdlog/sinks/dist_sink.h | 71 - .../include/spdlog/sinks/file_sinks.h | 239 - .../include/spdlog/sinks/msvc_sink.h | 50 - .../include/spdlog/sinks/null_sink.h | 34 - .../include/spdlog/sinks/ostream_sink.h | 47 - .../spdlog-0.13.0/include/spdlog/sinks/sink.h | 53 - .../include/spdlog/sinks/stdout_sinks.h | 77 - .../include/spdlog/sinks/syslog_sink.h | 81 - .../include/spdlog/sinks/wincolor_sink.h | 116 - .../spdlog-0.13.0/include/spdlog/spdlog.h | 178 - .../spdlog-0.13.0/include/spdlog/tweakme.h | 108 - thirdparty/spdlog-20170710/.gitignore | 64 + thirdparty/spdlog-20170710/CMakeLists.txt | 87 + thirdparty/spdlog-20170710/INSTALL | 13 + thirdparty/spdlog-20170710/LICENSE | 22 + thirdparty/spdlog-20170710/README.md | 223 + thirdparty/spdlog-20170710/astyle.sh | 5 + .../spdlog-20170710/cmake/Config.cmake.in | 24 + thirdparty/spdlog-20170710/cmake/spdlog.pc.in | 6 + .../include/spdlog/async_logger.h | 82 + .../spdlog-20170710/include/spdlog/common.h | 157 + .../include/spdlog/details/async_log_helper.h | 399 ++ .../include/spdlog/details/async_logger_impl.h | 105 + .../include/spdlog/details/file_helper.h | 117 + .../include/spdlog/details/log_msg.h | 50 + .../include/spdlog/details/logger_impl.h | 563 +++ .../include/spdlog/details/mpmc_bounded_q.h | 172 + .../include/spdlog/details/null_mutex.h | 45 + .../spdlog-20170710/include/spdlog/details/os.h | 469 ++ .../spdlog/details/pattern_formatter_impl.h | 690 +++ .../include/spdlog/details/registry.h | 214 + .../include/spdlog/details/spdlog_impl.h | 263 + .../spdlog-20170710/include/spdlog/dummy.cpp | 22 + .../include/spdlog/fmt/bundled/format.cc | 940 ++++ .../include/spdlog/fmt/bundled/format.h | 4501 ++++++++++++++++++ .../include/spdlog/fmt/bundled/ostream.cc | 43 + .../include/spdlog/fmt/bundled/ostream.h | 126 + .../include/spdlog/fmt/bundled/posix.cc | 238 + .../include/spdlog/fmt/bundled/posix.h | 443 ++ .../include/spdlog/fmt/bundled/time.h | 58 + .../spdlog-20170710/include/spdlog/fmt/fmt.h | 28 + .../spdlog-20170710/include/spdlog/fmt/ostr.h | 17 + .../spdlog-20170710/include/spdlog/formatter.h | 47 + .../spdlog-20170710/include/spdlog/logger.h | 132 + .../include/spdlog/sinks/android_sink.h | 90 + .../include/spdlog/sinks/ansicolor_sink.h | 133 + .../include/spdlog/sinks/base_sink.h | 50 + .../include/spdlog/sinks/dist_sink.h | 73 + .../include/spdlog/sinks/file_sinks.h | 242 + .../include/spdlog/sinks/msvc_sink.h | 51 + .../include/spdlog/sinks/null_sink.h | 34 + .../include/spdlog/sinks/ostream_sink.h | 47 + .../spdlog-20170710/include/spdlog/sinks/sink.h | 53 + .../include/spdlog/sinks/stdout_sinks.h | 77 + .../include/spdlog/sinks/syslog_sink.h | 81 + .../include/spdlog/sinks/wincolor_sink.h | 117 + .../spdlog-20170710/include/spdlog/spdlog.h | 187 + .../spdlog-20170710/include/spdlog/tweakme.h | 134 + 101 files changed, 11791 insertions(+), 11203 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/8389c8aa/.gitignore ---------------------------------------------------------------------- diff --git a/.gitignore b/.gitignore index 3032f38..2ba3164 100644 --- a/.gitignore +++ b/.gitignore @@ -53,3 +53,4 @@ thirdparty/apache-rat/apache-rat* # Ignore source files that have been placed in the docker directory during build docker/minificppsource +*.swp http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/8389c8aa/CMakeLists.txt ---------------------------------------------------------------------- diff --git a/CMakeLists.txt b/CMakeLists.txt index 454908e..361f9a5 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -79,7 +79,7 @@ else () message( FATAL_ERROR "LevelDB was not found. Please install LevelDB" ) endif (LEVELDB_FOUND) find_package(UUID REQUIRED) -file(GLOB SPD_SOURCES "thirdparty/spdlog-0.13.0/include/spdlog/*") +file(GLOB SPD_SOURCES "thirdparty/spdlog-20170710/include/spdlog/*") http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/8389c8aa/cmake/BuildTests.cmake ---------------------------------------------------------------------- diff --git a/cmake/BuildTests.cmake b/cmake/BuildTests.cmake index 9500792..2502537 100644 --- a/cmake/BuildTests.cmake +++ b/cmake/BuildTests.cmake @@ -33,7 +33,7 @@ function(createTests testName) message ("-- Adding test: ${testName}") target_include_directories(${testName} PRIVATE BEFORE ${UUID_INCLUDE_DIRS}) target_include_directories(${testName} PRIVATE BEFORE "thirdparty/catch") - target_include_directories(${testName} PRIVATE BEFORE "thirdparty/spdlog-0.13.0/include") + target_include_directories(${testName} PRIVATE BEFORE "thirdparty/spdlog-20170710/include") target_include_directories(${testName} PRIVATE BEFORE "thirdparty/yaml-cpp-yaml-cpp-0.5.3/include") target_include_directories(${testName} PRIVATE BEFORE "thirdparty/jsoncpp/include") target_include_directories(${testName} PRIVATE BEFORE "thirdparty/civetweb-1.9.1/include") http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/8389c8aa/docker/Dockerfile ---------------------------------------------------------------------- diff --git a/docker/Dockerfile b/docker/Dockerfile index 7721ebc..213015c 100644 --- a/docker/Dockerfile +++ b/docker/Dockerfile @@ -16,7 +16,9 @@ # under the License. # -FROM ubuntu:16.10 +# First stage: the build environment +# Edge required for leveldb +FROM alpine:edge AS builder MAINTAINER Apache NiFi <d...@nifi.apache.org> ARG UID @@ -25,27 +27,30 @@ ARG MINIFI_VERSION ARG MINIFI_SOURCE_CODE # Install the system dependencies needed for a build -RUN apt-get update && apt-get install -y build-essential \ +# Add testing repo for leveldb +RUN echo 'http://dl-cdn.alpinelinux.org/alpine/edge/testing' >> /etc/apk/repositories +RUN apk --update --no-cache upgrade && apk --update --no-cache add gcc \ + g++ \ + make \ wget \ gdb \ - libboost-all-dev \ + musl-dev \ + boost-dev \ vim \ - uuid-dev \ - libleveldb-dev \ - libcurl4-openssl-dev \ + util-linux-dev \ + leveldb-dev \ + curl-dev \ cmake \ git \ unzip \ - libgps-dev \ - gpsd \ - gpsd-clients \ - libssl-dev + gpsd-dev \ + openssl-dev ENV USER minificpp ENV MINIFI_BASE_DIR /opt/minifi # Setup minificpp user -RUN addgroup --gid $GID $USER && adduser --uid $UID --gid $GID --disabled-password --gecos "" $USER +RUN addgroup -g $GID $USER && adduser -u $UID -D -G $USER -g "" $USER RUN mkdir -p $MINIFI_BASE_DIR ADD $MINIFI_SOURCE_CODE $MINIFI_BASE_DIR @@ -63,6 +68,39 @@ RUN cd $MINIFI_BASE_DIR \ && make package \ && tar -xzvf $MINIFI_BASE_DIR/build/nifi-minifi-cpp-$MINIFI_VERSION-bin.tar.gz -C $MINIFI_BASE_DIR +# Second stage: the runtime image +# Edge required for leveldb +FROM alpine:edge + +ARG UID +ARG GID +ARG MINIFI_VERSION +ARG MINIFI_SOURCE_CODE + +# Add testing repo for leveldb +RUN echo 'http://dl-cdn.alpinelinux.org/alpine/edge/testing' >> /etc/apk/repositories + +RUN apk --update --no-cache upgrade && apk add --update --no-cache \ + util-linux \ + leveldb \ + curl \ + unzip \ + gpsd \ + openssl + # Start MiNiFi CPP in the foreground -CMD cd $MINIFI_HOME && ./bin/minifi.sh run +ENV USER minificpp +ENV MINIFI_BASE_DIR /opt/minifi +ENV MINIFI_HOME $MINIFI_BASE_DIR/nifi-minifi-cpp-$MINIFI_VERSION + +RUN addgroup -g $GID $USER && adduser -u $UID -D -G $USER -g "" $USER +RUN mkdir -p $MINIFI_BASE_DIR + +# Copy built minifi distribution from builder +COPY --from=builder ${MINIFI_HOME} ${MINIFI_HOME} +RUN chown -R ${USER}:${USER} /opt/minifi + +USER $USER +WORKDIR ${MINIFI_HOME} +CMD ./bin/minifi.sh run http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/8389c8aa/libminifi/CMakeLists.txt ---------------------------------------------------------------------- diff --git a/libminifi/CMakeLists.txt b/libminifi/CMakeLists.txt index 439c641..a78fd8f 100644 --- a/libminifi/CMakeLists.txt +++ b/libminifi/CMakeLists.txt @@ -55,7 +55,7 @@ else() message(STATUS "The compiler ${CMAKE_CXX_COMPILER} has no C++11 support. Please use a different C++ compiler.") endif() -include_directories(../thirdparty/spdlog-0.13.0/include) +include_directories(../thirdparty/spdlog-20170710/include) include_directories(../thirdparty/yaml-cpp-yaml-cpp-0.5.3/include) include_directories(../thirdparty/civetweb-1.9.1/include) include_directories(../thirdparty/jsoncpp/include) @@ -64,7 +64,7 @@ include_directories(include) file(GLOB SOURCES "src/core/logging/*.cpp" "src/io/*.cpp" "src/io/tls/*.cpp" "src/core/controller/*.cpp" "src/controllers/*.cpp" "src/core/*.cpp" "src/core/repository/*.cpp" "src/core/yaml/*.cpp" "src/core/reporting/*.cpp" "src/provenance/*.cpp" "src/processors/*.cpp" "src/utils/*.cpp" "src/*.cpp") -file(GLOB SPD_SOURCES "../thirdparty/spdlog-0.13.0/include/spdlog/*") +file(GLOB SPD_SOURCES "../thirdparty/spdlog-20170710/include/spdlog/*") # Workaround the limitations of having a # header only library http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/8389c8aa/main/CMakeLists.txt ---------------------------------------------------------------------- diff --git a/main/CMakeLists.txt b/main/CMakeLists.txt index 93f5396..8c1a290 100644 --- a/main/CMakeLists.txt +++ b/main/CMakeLists.txt @@ -23,7 +23,7 @@ IF(POLICY CMP0048) CMAKE_POLICY(SET CMP0048 OLD) ENDIF(POLICY CMP0048) -include_directories(../libminifi/include ../libminifi/include/core/yaml ../libminifi/include/core ../thirdparty/spdlog-0.13.0/include ../thirdparty/concurrentqueue ../thirdparty/yaml-cpp-yaml-cpp-0.5.3/include ../thirdparty/civetweb-1.9.1/include ../thirdparty/jsoncpp/include ../thirdparty/leveldb-1.18/include ../thirdparty/) +include_directories(../libminifi/include ../libminifi/include/core/yaml ../libminifi/include/core ../thirdparty/spdlog-20170710/include ../thirdparty/concurrentqueue ../thirdparty/yaml-cpp-yaml-cpp-0.5.3/include ../thirdparty/civetweb-1.9.1/include ../thirdparty/jsoncpp/include ../thirdparty/leveldb-1.18/include ../thirdparty/) find_package(Boost REQUIRED) include_directories(${Boost_INCLUDE_DIRS}) http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/8389c8aa/thirdparty/civetweb-1.9.1/CMakeLists.txt ---------------------------------------------------------------------- diff --git a/thirdparty/civetweb-1.9.1/CMakeLists.txt b/thirdparty/civetweb-1.9.1/CMakeLists.txt index f36cd84..146f8e7 100644 --- a/thirdparty/civetweb-1.9.1/CMakeLists.txt +++ b/thirdparty/civetweb-1.9.1/CMakeLists.txt @@ -95,7 +95,7 @@ message(STATUS "Lua CGI support - ${CIVETWEB_ENABLE_LUA}") # Allow builds to complete with warnings (do not set -Werror) if (LINUX) # CivetWeb Linux support is stable: Builds must be free from warnings. - option(CIVETWEB_ALLOW_WARNINGS "Do not stop build if there are warnings" OFF) + option(CIVETWEB_ALLOW_WARNINGS "Do not stop build if there are warnings" ON) else() # CivetWeb Linux support for other systems is in a setup phase. option(CIVETWEB_ALLOW_WARNINGS "Do not stop build if there are warnings" ON) http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/8389c8aa/thirdparty/spdlog-0.13.0/.gitignore ---------------------------------------------------------------------- diff --git a/thirdparty/spdlog-0.13.0/.gitignore b/thirdparty/spdlog-0.13.0/.gitignore deleted file mode 100644 index b51a05b..0000000 --- a/thirdparty/spdlog-0.13.0/.gitignore +++ /dev/null @@ -1,64 +0,0 @@ -# Auto generated files -*.slo -*.lo -*.o -*.obj -*.suo -*.tlog -*.ilk -*.log -*.pdb -*.idb -*.iobj -*.ipdb -*.opensdf -*.sdf - -# Compiled Dynamic libraries -*.so -*.dylib -*.dll - -# Compiled Static libraries -*.lai -*.la -*.a -*.lib - -# Executables -*.exe -*.out -*.app - -# Codelite -.codelite - -# .orig files -*.orig - -# example files -example/* -!example/example.cpp -!example/bench.cpp -!example/utils.h -!example/Makefile* -!example/example.sln -!example/example.vcxproj -!example/CMakeLists.txt -!example/multisink.cpp -!example/jni - -# generated files -generated - -# Cmake -CMakeCache.txt -CMakeFiles -CMakeScripts -Makefile -cmake_install.cmake -install_manifest.txt -/tests/tests.VC.VC.opendb -/tests/tests.VC.db -/tests/tests -/tests/logs/file_helper_test.txt http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/8389c8aa/thirdparty/spdlog-0.13.0/CMakeLists.txt ---------------------------------------------------------------------- diff --git a/thirdparty/spdlog-0.13.0/CMakeLists.txt b/thirdparty/spdlog-0.13.0/CMakeLists.txt deleted file mode 100644 index 61c45b5..0000000 --- a/thirdparty/spdlog-0.13.0/CMakeLists.txt +++ /dev/null @@ -1,87 +0,0 @@ -# -# Copyright(c) 2015 Ruslan Baratov. -# Distributed under the MIT License (http://opensource.org/licenses/MIT) -# - -cmake_minimum_required(VERSION 3.1) -project(spdlog VERSION 1.0.0) -include(CTest) - -set(CMAKE_CXX_STANDARD 11) -set(CMAKE_CXX_STANDARD_REQUIRED ON) - -if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU" OR "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang") - set(CMAKE_CXX_FLAGS "-Wall ${CMAKE_CXX_FLAGS}") -endif() - -add_library(spdlog INTERFACE) - -option(SPDLOG_BUILD_EXAMPLES "Build examples" OFF) -option(SPDLOG_BUILD_TESTING "Build spdlog tests" ON) - -target_include_directories( - spdlog - INTERFACE - "$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>" - "$<INSTALL_INTERFACE:include>" -) - -set(HEADER_BASE "${CMAKE_CURRENT_SOURCE_DIR}/include") - -if(SPDLOG_BUILD_EXAMPLES) - add_subdirectory(example) -endif() - -if(SPDLOG_BUILD_TESTING) - add_subdirectory(tests) -endif() - -### Install ### -# * https://github.com/forexample/package-example -set(generated_dir "${CMAKE_CURRENT_BINARY_DIR}/generated") - -set(config_install_dir "lib/cmake/${PROJECT_NAME}") -set(include_install_dir "include") -set(pkgconfig_install_dir "lib/pkgconfig") - -set(version_config "${generated_dir}/${PROJECT_NAME}ConfigVersion.cmake") -set(project_config "${generated_dir}/${PROJECT_NAME}Config.cmake") -set(pkg_config "${generated_dir}/${PROJECT_NAME}.pc") -set(targets_export_name "${PROJECT_NAME}Targets") -set(namespace "${PROJECT_NAME}::") - -include(CMakePackageConfigHelpers) -write_basic_package_version_file( - "${version_config}" COMPATIBILITY SameMajorVersion -) - -# Note: use 'targets_export_name' -configure_file("cmake/Config.cmake.in" "${project_config}" @ONLY) -configure_file("cmake/spdlog.pc.in" "${pkg_config}" @ONLY) - -install( - TARGETS spdlog - EXPORT "${targets_export_name}" - INCLUDES DESTINATION "${include_install_dir}" -) - -install(DIRECTORY "include/spdlog" DESTINATION "${include_install_dir}") - -install( - FILES "${project_config}" "${version_config}" - DESTINATION "${config_install_dir}" -) - -install( - FILES "${pkg_config}" - DESTINATION "${pkgconfig_install_dir}" -) - -install( - EXPORT "${targets_export_name}" - NAMESPACE "${namespace}" - DESTINATION "${config_install_dir}" -) - -file(GLOB_RECURSE spdlog_include_SRCS "${HEADER_BASE}/*.h") -add_custom_target(spdlog_headers_for_ide SOURCES ${spdlog_include_SRCS}) http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/8389c8aa/thirdparty/spdlog-0.13.0/INSTALL ---------------------------------------------------------------------- diff --git a/thirdparty/spdlog-0.13.0/INSTALL b/thirdparty/spdlog-0.13.0/INSTALL deleted file mode 100644 index 664509d..0000000 --- a/thirdparty/spdlog-0.13.0/INSTALL +++ /dev/null @@ -1,13 +0,0 @@ -spdlog is header only library. -Just copy the files to your build tree and use a C++11 compiler - -Tested on: -gcc 4.8.1 and above -clang 3.5 -Visual Studio 2013 - -gcc 4.8 flags: --std==c++11 -pthread -O3 -flto -Wl,--no-as-needed -gcc 4.9 flags: --std=c++11 -pthread -O3 -flto - - -see the makefile in the example folder http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/8389c8aa/thirdparty/spdlog-0.13.0/LICENSE ---------------------------------------------------------------------- diff --git a/thirdparty/spdlog-0.13.0/LICENSE b/thirdparty/spdlog-0.13.0/LICENSE deleted file mode 100644 index 4b43e06..0000000 --- a/thirdparty/spdlog-0.13.0/LICENSE +++ /dev/null @@ -1,22 +0,0 @@ -The MIT License (MIT) - -Copyright (c) 2016 Gabi Melman. - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in -all copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -THE SOFTWARE. - http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/8389c8aa/thirdparty/spdlog-0.13.0/README.md ---------------------------------------------------------------------- diff --git a/thirdparty/spdlog-0.13.0/README.md b/thirdparty/spdlog-0.13.0/README.md deleted file mode 100644 index f5e5fe3..0000000 --- a/thirdparty/spdlog-0.13.0/README.md +++ /dev/null @@ -1,218 +0,0 @@ -# spdlog - -Very fast, header only, C++ logging library. [![Build Status](https://travis-ci.org/gabime/spdlog.svg?branch=master)](https://travis-ci.org/gabime/spdlog) [![Build status](https://ci.appveyor.com/api/projects/status/d2jnxclg20vd0o50?svg=true)](https://ci.appveyor.com/project/gabime/spdlog) - - -## Install -#### Just copy the headers: - -* Copy the source [folder](https://github.com/gabime/spdlog/tree/master/include/spdlog) to your build tree and use a C++11 compiler. - -#### Or use your favourite package manager: - -* Ubuntu: `apt-get install libspdlog-dev` -* Homebrew: `brew install spdlog` -* FreeBSD: `cd /usr/ports/devel/spdlog/ && make install clean` -* Fedora: `yum install spdlog` -* Arch Linux: `pacman -S spdlog-git` -* vcpkg: `vcpkg install spdlog` - - -## Platforms - * Linux, FreeBSD, Solaris - * Windows (vc 2013+, cygwin/mingw) - * Mac OSX (clang 3.5+) - * Android - -## Features -* Very fast - performance is the primary goal (see [benchmarks](#benchmarks) below). -* Headers only, just copy and use. -* Feature rich [call style](#usage-example) using the excellent [fmt](https://github.com/fmtlib/fmt) library. -* Extremely fast asynchronous mode (optional) - using lockfree queues and other tricks to reach millions of calls/sec. -* [Custom](https://github.com/gabime/spdlog/wiki/3.-Custom-formatting) formatting. -* Multi/Single threaded loggers. -* Various log targets: - * Rotating log files. - * Daily log files. - * Console logging (colors supported). - * syslog. - * Windows debugger (```OutputDebugString(..)```) - * Easily extendable with custom log targets (just implement a single function in the [sink](include/spdlog/sinks/sink.h) interface). -* Severity based filtering - threshold levels can be modified in runtime as well as in compile time. - - - -## Benchmarks - -Below are some [benchmarks](bench) comparing popular log libraries under Ubuntu 64 bit, Intel i7-4770 CPU @ 3.40GHz - -#### Synchronous mode -Time needed to log 1,000,000 lines in synchronous mode (in seconds, the best of 3 runs): - -|threads|boost log 1.54|glog |easylogging |spdlog| -|-------|:-------:|:-----:|----------:|------:| -|1| 4.169s |1.066s |0.975s |0.302s| -|10| 6.180s |3.032s |2.857s |0.968s| -|100| 5.981s |1.139s |4.512s |0.497s| - - -#### Asynchronous mode -Time needed to log 1,000,000 lines in asynchronous mode, i.e. the time it takes to put them in the async queue (in seconds, the best of 3 runs): - -|threads|g2log <sup>async logger</sup> |spdlog <sup>async mode</sup>| -|:-------|:-----:|-------------------------:| -|1| 1.850s |0.216s | -|10| 0.943s |0.173s| -|100| 0.959s |0.202s| - - - - -## Usage Example -```c++ - -#include "spdlog/spdlog.h" - -#include <iostream> -#include <memory> - -void async_example(); -void syslog_example(); -void user_defined_example(); -void err_handler_example(); - -namespace spd = spdlog; -int main(int, char*[]) -{ - try - { - // Console logger with color - auto console = spd::stdout_color_mt("console"); - console->info("Welcome to spdlog!"); - console->error("Some error message with arg{}..", 1); - - // Formatting examples - console->warn("Easy padding in numbers like {:08d}", 12); - console->critical("Support for int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}", 42); - console->info("Support for floats {:03.2f}", 1.23456); - console->info("Positional args are {1} {0}..", "too", "supported"); - console->info("{:<30}", "left aligned"); - - - spd::get("console")->info("loggers can be retrieved from a global registry using the spdlog::get(logger_name) function"); - - // Create basic file logger (not rotated) - auto my_logger = spd::basic_logger_mt("basic_logger", "logs/basic.txt"); - my_logger->info("Some log message"); - - // Create a file rotating logger with 5mb size max and 3 rotated files - auto rotating_logger = spd::rotating_logger_mt("some_logger_name", "logs/mylogfile", 1048576 * 5, 3); - for (int i = 0; i < 10; ++i) - rotating_logger->info("{} * {} equals {:>10}", i, i, i*i); - - // Create a daily logger - a new file is created every day on 2:30am - auto daily_logger = spd::daily_logger_mt("daily_logger", "logs/daily", 2, 30); - // trigger flush if the log severity is error or higher - daily_logger->flush_on(spd::level::err); - daily_logger->info(123.44); - - // Customize msg format for all messages - spd::set_pattern("*** [%H:%M:%S %z] [thread %t] %v ***"); - rotating_logger->info("This is another message with custom format"); - - - // Runtime log levels - spd::set_level(spd::level::info); //Set global log level to info - console->debug("This message shold not be displayed!"); - console->set_level(spd::level::debug); // Set specific logger's log level - console->debug("This message shold be displayed.."); - - // Compile time log levels - // define SPDLOG_DEBUG_ON or SPDLOG_TRACE_ON - SPDLOG_TRACE(console, "Enabled only #ifdef SPDLOG_TRACE_ON..{} ,{}", 1, 3.23); - SPDLOG_DEBUG(console, "Enabled only #ifdef SPDLOG_DEBUG_ON.. {} ,{}", 1, 3.23); - - // Asynchronous logging is very fast.. - // Just call spdlog::set_async_mode(q_size) and all created loggers from now on will be asynchronous.. - async_example(); - - // syslog example. linux/osx only - syslog_example(); - - // android example. compile with NDK - android_example(); - - // Log user-defined types example - user_defined_example(); - - // Change default log error handler - err_handler_example(); - - // Apply a function on all registered loggers - spd::apply_all([&](std::shared_ptr<spdlog::logger> l) - { - l->info("End of example."); - }); - - // Release and close all loggers - spdlog::drop_all(); - } - // Exceptions will only be thrown upon failed logger or sink construction (not during logging) - catch (const spd::spdlog_ex& ex) - { - std::cout << "Log init failed: " << ex.what() << std::endl; - return 1; - } -} - -void async_example() -{ - size_t q_size = 4096; //queue size must be power of 2 - spdlog::set_async_mode(q_size); - auto async_file = spd::daily_logger_st("async_file_logger", "logs/async_log.txt"); - for (int i = 0; i < 100; ++i) - async_file->info("Async message #{}", i); -} - -//syslog example -void syslog_example() -{ -#ifdef SPDLOG_ENABLE_SYSLOG - std::string ident = "spdlog-example"; - auto syslog_logger = spd::syslog_logger("syslog", ident, LOG_PID); - syslog_logger->warn("This is warning that will end up in syslog.."); -#endif -} - -// user defined types logging by implementing operator<< -struct my_type -{ - int i; - template<typename OStream> - friend OStream& operator<<(OStream& os, const my_type &c) - { - return os << "[my_type i="<<c.i << "]"; - } -}; - -#include <spdlog/fmt/ostr.h> // must be included -void user_defined_example() -{ - spd::get("console")->info("user defined type: {}", my_type { 14 }); -} - -// -//custom error handler -// -void err_handler_example() -{ - spdlog::set_error_handler([](const std::string& msg) { - std::cerr << "my err handler: " << msg << std::endl; - }); - // (or logger->set_error_handler(..) to set for specific logger) -} - -``` - -## Documentation -Documentation can be found in the [wiki](https://github.com/gabime/spdlog/wiki/1.-QuickStart) pages. http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/8389c8aa/thirdparty/spdlog-0.13.0/astyle.sh ---------------------------------------------------------------------- diff --git a/thirdparty/spdlog-0.13.0/astyle.sh b/thirdparty/spdlog-0.13.0/astyle.sh deleted file mode 100755 index a7a9051..0000000 --- a/thirdparty/spdlog-0.13.0/astyle.sh +++ /dev/null @@ -1,5 +0,0 @@ -#!/bin/bash -find . -name "*\.h" -o -name "*\.cpp"|xargs dos2unix -find . -name "*\.h" -o -name "*\.cpp"|xargs astyle -n -c -A1 - - http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/8389c8aa/thirdparty/spdlog-0.13.0/cmake/Config.cmake.in ---------------------------------------------------------------------- diff --git a/thirdparty/spdlog-0.13.0/cmake/Config.cmake.in b/thirdparty/spdlog-0.13.0/cmake/Config.cmake.in deleted file mode 100644 index ba0b36f..0000000 --- a/thirdparty/spdlog-0.13.0/cmake/Config.cmake.in +++ /dev/null @@ -1,24 +0,0 @@ -# *************************************************************************/ -# * Copyright (c) 2015 Ruslan Baratov. */ -# * */ -# * Permission is hereby granted, free of charge, to any person obtaining */ -# * a copy of this software and associated documentation files (the */ -# * "Software"), to deal in the Software without restriction, including */ -# * without limitation the rights to use, copy, modify, merge, publish, */ -# * distribute, sublicense, and/or sell copies of the Software, and to */ -# * permit persons to whom the Software is furnished to do so, subject to */ -# * the following conditions: */ -# * */ -# * The above copyright notice and this permission notice shall be */ -# * included in all copies or substantial portions of the Software. */ -# * */ -# * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ -# * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ -# * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ -# * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ -# * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ -# * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ -# * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -# *************************************************************************/ - -include("${CMAKE_CURRENT_LIST_DIR}/@targets_export_name@.cmake") http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/8389c8aa/thirdparty/spdlog-0.13.0/cmake/spdlog.pc.in ---------------------------------------------------------------------- diff --git a/thirdparty/spdlog-0.13.0/cmake/spdlog.pc.in b/thirdparty/spdlog-0.13.0/cmake/spdlog.pc.in deleted file mode 100644 index 262248a..0000000 --- a/thirdparty/spdlog-0.13.0/cmake/spdlog.pc.in +++ /dev/null @@ -1,6 +0,0 @@ -prefix=@CMAKE_INSTALL_PREFIX@ -includedir=${prefix}/include - -Name: @PROJECT_NAME@ -Description: Super fast C++ logging library. -Version: @PROJECT_VERSION@ http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/8389c8aa/thirdparty/spdlog-0.13.0/include/spdlog/async_logger.h ---------------------------------------------------------------------- diff --git a/thirdparty/spdlog-0.13.0/include/spdlog/async_logger.h b/thirdparty/spdlog-0.13.0/include/spdlog/async_logger.h deleted file mode 100644 index 76d70a3..0000000 --- a/thirdparty/spdlog-0.13.0/include/spdlog/async_logger.h +++ /dev/null @@ -1,82 +0,0 @@ -// -// Copyright(c) 2015 Gabi Melman. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) -// - -#pragma once - -// Very fast asynchronous logger (millions of logs per second on an average desktop) -// Uses pre allocated lockfree queue for maximum throughput even under large number of threads. -// Creates a single back thread to pop messages from the queue and log them. -// -// Upon each log write the logger: -// 1. Checks if its log level is enough to log the message -// 2. Push a new copy of the message to a queue (or block the caller until space is available in the queue) -// 3. will throw spdlog_ex upon log exceptions -// Upon destruction, logs all remaining messages in the queue before destructing.. - -#include <spdlog/common.h> -#include <spdlog/logger.h> - -#include <chrono> -#include <functional> -#include <string> -#include <memory> - -namespace spdlog -{ - -namespace details -{ -class async_log_helper; -} - -class async_logger :public logger -{ -public: - template<class It> - async_logger(const std::string& name, - const It& begin, - const It& end, - size_t queue_size, - const async_overflow_policy overflow_policy = async_overflow_policy::block_retry, - const std::function<void()>& worker_warmup_cb = nullptr, - const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero(), - const std::function<void()>& worker_teardown_cb = nullptr); - - async_logger(const std::string& logger_name, - sinks_init_list sinks, - size_t queue_size, - const async_overflow_policy overflow_policy = async_overflow_policy::block_retry, - const std::function<void()>& worker_warmup_cb = nullptr, - const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero(), - const std::function<void()>& worker_teardown_cb = nullptr); - - async_logger(const std::string& logger_name, - sink_ptr single_sink, - size_t queue_size, - const async_overflow_policy overflow_policy = async_overflow_policy::block_retry, - const std::function<void()>& worker_warmup_cb = nullptr, - const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero(), - const std::function<void()>& worker_teardown_cb = nullptr); - - //Wait for the queue to be empty, and flush synchronously - //Warning: this can potentialy last forever as we wait it to complete - void flush() override; - - // Error handler - virtual void set_error_handler(log_err_handler) override; - virtual log_err_handler error_handler() override; - -protected: - void _sink_it(details::log_msg& msg) override; - void _set_formatter(spdlog::formatter_ptr msg_formatter) override; - void _set_pattern(const std::string& pattern) override; - -private: - std::unique_ptr<details::async_log_helper> _async_log_helper; -}; -} - - -#include <spdlog/details/async_logger_impl.h> http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/8389c8aa/thirdparty/spdlog-0.13.0/include/spdlog/common.h ---------------------------------------------------------------------- diff --git a/thirdparty/spdlog-0.13.0/include/spdlog/common.h b/thirdparty/spdlog-0.13.0/include/spdlog/common.h deleted file mode 100644 index a0a227e..0000000 --- a/thirdparty/spdlog-0.13.0/include/spdlog/common.h +++ /dev/null @@ -1,143 +0,0 @@ -// -// Copyright(c) 2015 Gabi Melman. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) -// - -#pragma once - -#include <string> -#include <initializer_list> -#include <chrono> -#include <memory> -#include <atomic> -#include <exception> -#include<functional> - -#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES) -#include <codecvt> -#include <locale> -#endif - -#include <spdlog/details/null_mutex.h> - -//visual studio upto 2013 does not support noexcept nor constexpr -#if defined(_MSC_VER) && (_MSC_VER < 1900) -#define SPDLOG_NOEXCEPT throw() -#define SPDLOG_CONSTEXPR -#else -#define SPDLOG_NOEXCEPT noexcept -#define SPDLOG_CONSTEXPR constexpr -#endif - -#if defined(__GNUC__) || defined(__clang__) -#define SPDLOG_DEPRECATED __attribute__((deprecated)) -#elif defined(_MSC_VER) -#define SPDLOG_DEPRECATED __declspec(deprecated) -#else -#define SPDLOG_DEPRECATED -#endif - - -#include <spdlog/fmt/fmt.h> - -namespace spdlog -{ - -class formatter; - -namespace sinks -{ -class sink; -} - -using log_clock = std::chrono::system_clock; -using sink_ptr = std::shared_ptr < sinks::sink >; -using sinks_init_list = std::initializer_list < sink_ptr >; -using formatter_ptr = std::shared_ptr<spdlog::formatter>; -#if defined(SPDLOG_NO_ATOMIC_LEVELS) -using level_t = details::null_atomic_int; -#else -using level_t = std::atomic<int>; -#endif - -using log_err_handler = std::function<void(const std::string &err_msg)>; - -//Log level enum -namespace level -{ -typedef enum -{ - trace = 0, - debug = 1, - info = 2, - warn = 3, - err = 4, - critical = 5, - off = 6 -} level_enum; - -static const char* level_names[] { "trace", "debug", "info", "warning", "error", "critical", "off" }; - -static const char* short_level_names[] { "T", "D", "I", "W", "E", "C", "O" }; - -inline const char* to_str(spdlog::level::level_enum l) -{ - return level_names[l]; -} - -inline const char* to_short_str(spdlog::level::level_enum l) -{ - return short_level_names[l]; -} -} //level - - -// -// Async overflow policy - block by default. -// -enum class async_overflow_policy -{ - block_retry, // Block / yield / sleep until message can be enqueued - discard_log_msg // Discard the message it enqueue fails -}; - - -// -// Log exception -// -namespace details -{ -namespace os -{ -std::string errno_str(int err_num); -} -} -class spdlog_ex: public std::exception -{ -public: - spdlog_ex(const std::string& msg):_msg(msg) - {} - spdlog_ex(const std::string& msg, int last_errno) - { - _msg = msg + ": " + details::os::errno_str(last_errno); - } - const char* what() const SPDLOG_NOEXCEPT override - { - return _msg.c_str(); - } -private: - std::string _msg; - -}; - -// -// wchar support for windows file names (SPDLOG_WCHAR_FILENAMES must be defined) -// -#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES) -using filename_t = std::wstring; -#else -using filename_t = std::string; -#endif - - -} //spdlog http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/8389c8aa/thirdparty/spdlog-0.13.0/include/spdlog/details/async_log_helper.h ---------------------------------------------------------------------- diff --git a/thirdparty/spdlog-0.13.0/include/spdlog/details/async_log_helper.h b/thirdparty/spdlog-0.13.0/include/spdlog/details/async_log_helper.h deleted file mode 100644 index 92a0f4c..0000000 --- a/thirdparty/spdlog-0.13.0/include/spdlog/details/async_log_helper.h +++ /dev/null @@ -1,391 +0,0 @@ -// -// Copyright(c) 2015 Gabi Melman. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) -// - -// async log helper : -// Process logs asynchronously using a back thread. -// -// If the internal queue of log messages reaches its max size, -// then the client call will block until there is more room. -// -// If the back thread throws during logging, a spdlog::spdlog_ex exception -// will be thrown in client's thread when tries to log the next message - -#pragma once - -#include <spdlog/common.h> -#include <spdlog/sinks/sink.h> -#include <spdlog/details/mpmc_bounded_q.h> -#include <spdlog/details/log_msg.h> -#include <spdlog/details/os.h> -#include <spdlog/formatter.h> - -#include <chrono> -#include <exception> -#include <functional> -#include <memory> -#include <string> -#include <thread> -#include <utility> -#include <vector> - -namespace spdlog -{ -namespace details -{ - -class async_log_helper -{ - // Async msg to move to/from the queue - // Movable only. should never be copied - enum class async_msg_type - { - log, - flush, - terminate - }; - struct async_msg - { - std::string logger_name; - level::level_enum level; - log_clock::time_point time; - size_t thread_id; - std::string txt; - async_msg_type msg_type; - - async_msg() = default; - ~async_msg() = default; - - -async_msg(async_msg&& other) SPDLOG_NOEXCEPT: - logger_name(std::move(other.logger_name)), - level(std::move(other.level)), - time(std::move(other.time)), - txt(std::move(other.txt)), - msg_type(std::move(other.msg_type)) - {} - - async_msg(async_msg_type m_type):msg_type(m_type) - {} - - async_msg& operator=(async_msg&& other) SPDLOG_NOEXCEPT - { - logger_name = std::move(other.logger_name); - level = other.level; - time = std::move(other.time); - thread_id = other.thread_id; - txt = std::move(other.txt); - msg_type = other.msg_type; - return *this; - } - - // never copy or assign. should only be moved.. - async_msg(const async_msg&) = delete; - async_msg& operator=(const async_msg& other) = delete; - - // construct from log_msg - async_msg(const details::log_msg& m): - level(m.level), - time(m.time), - thread_id(m.thread_id), - txt(m.raw.data(), m.raw.size()), - msg_type(async_msg_type::log) - { -#ifndef SPDLOG_NO_NAME - logger_name = *m.logger_name; -#endif - } - - - // copy into log_msg - void fill_log_msg(log_msg &msg) - { - msg.logger_name = &logger_name; - msg.level = level; - msg.time = time; - msg.thread_id = thread_id; - msg.raw << txt; - } - }; - -public: - - using item_type = async_msg; - using q_type = details::mpmc_bounded_queue<item_type>; - - using clock = std::chrono::steady_clock; - - - async_log_helper(formatter_ptr formatter, - const std::vector<sink_ptr>& sinks, - size_t queue_size, - const log_err_handler err_handler, - const async_overflow_policy overflow_policy = async_overflow_policy::block_retry, - const std::function<void()>& worker_warmup_cb = nullptr, - const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero(), - const std::function<void()>& worker_teardown_cb = nullptr); - - void log(const details::log_msg& msg); - - // stop logging and join the back thread - ~async_log_helper(); - - void set_formatter(formatter_ptr); - - void flush(bool wait_for_q); - - void set_error_handler(spdlog::log_err_handler err_handler); - -private: - formatter_ptr _formatter; - std::vector<std::shared_ptr<sinks::sink>> _sinks; - - // queue of messages to log - q_type _q; - - log_err_handler _err_handler; - - bool _flush_requested; - - bool _terminate_requested; - - - // overflow policy - const async_overflow_policy _overflow_policy; - - // worker thread warmup callback - one can set thread priority, affinity, etc - const std::function<void()> _worker_warmup_cb; - - // auto periodic sink flush parameter - const std::chrono::milliseconds _flush_interval_ms; - - // worker thread teardown callback - const std::function<void()> _worker_teardown_cb; - - // worker thread - std::thread _worker_thread; - - void push_msg(async_msg&& new_msg); - - // worker thread main loop - void worker_loop(); - - // pop next message from the queue and process it. will set the last_pop to the pop time - // return false if termination of the queue is required - bool process_next_msg(log_clock::time_point& last_pop, log_clock::time_point& last_flush); - - void handle_flush_interval(log_clock::time_point& now, log_clock::time_point& last_flush); - - // sleep,yield or return immediatly using the time passed since last message as a hint - static void sleep_or_yield(const spdlog::log_clock::time_point& now, const log_clock::time_point& last_op_time); - - // wait until the queue is empty - void wait_empty_q(); - -}; -} -} - -/////////////////////////////////////////////////////////////////////////////// -// async_sink class implementation -/////////////////////////////////////////////////////////////////////////////// -inline spdlog::details::async_log_helper::async_log_helper( - formatter_ptr formatter, - const std::vector<sink_ptr>& sinks, - size_t queue_size, - log_err_handler err_handler, - const async_overflow_policy overflow_policy, - const std::function<void()>& worker_warmup_cb, - const std::chrono::milliseconds& flush_interval_ms, - const std::function<void()>& worker_teardown_cb): - _formatter(formatter), - _sinks(sinks), - _q(queue_size), - _err_handler(err_handler), - _flush_requested(false), - _terminate_requested(false), - _overflow_policy(overflow_policy), - _worker_warmup_cb(worker_warmup_cb), - _flush_interval_ms(flush_interval_ms), - _worker_teardown_cb(worker_teardown_cb), - _worker_thread(&async_log_helper::worker_loop, this) -{} - -// Send to the worker thread termination message(level=off) -// and wait for it to finish gracefully -inline spdlog::details::async_log_helper::~async_log_helper() -{ - try - { - push_msg(async_msg(async_msg_type::terminate)); - _worker_thread.join(); - } - catch (...) // don't crash in destructor - { - } -} - - -//Try to push and block until succeeded (if the policy is not to discard when the queue is full) -inline void spdlog::details::async_log_helper::log(const details::log_msg& msg) -{ - push_msg(async_msg(msg)); -} - -inline void spdlog::details::async_log_helper::push_msg(details::async_log_helper::async_msg&& new_msg) -{ - if (!_q.enqueue(std::move(new_msg)) && _overflow_policy != async_overflow_policy::discard_log_msg) - { - auto last_op_time = details::os::now(); - auto now = last_op_time; - do - { - now = details::os::now(); - sleep_or_yield(now, last_op_time); - } - while (!_q.enqueue(std::move(new_msg))); - } -} - -// optionally wait for the queue be empty and request flush from the sinks -inline void spdlog::details::async_log_helper::flush(bool wait_for_q) -{ - push_msg(async_msg(async_msg_type::flush)); - if (wait_for_q) - wait_empty_q(); //return only make after the above flush message was processed -} - -inline void spdlog::details::async_log_helper::worker_loop() -{ - if (_worker_warmup_cb) _worker_warmup_cb(); - auto last_pop = details::os::now(); - auto last_flush = last_pop; - auto active = true; - while (active) - { - try - { - active = process_next_msg(last_pop, last_flush); - } - catch (const std::exception &ex) - { - _err_handler(ex.what()); - } - catch (...) - { - _err_handler("Unknown exception"); - } - } - if (_worker_teardown_cb) _worker_teardown_cb(); - - -} - -// process next message in the queue -// return true if this thread should still be active (while no terminate msg was received) -inline bool spdlog::details::async_log_helper::process_next_msg(log_clock::time_point& last_pop, log_clock::time_point& last_flush) -{ - async_msg incoming_async_msg; - - if (_q.dequeue(incoming_async_msg)) - { - last_pop = details::os::now(); - switch (incoming_async_msg.msg_type) - { - case async_msg_type::flush: - _flush_requested = true; - break; - - case async_msg_type::terminate: - _flush_requested = true; - _terminate_requested = true; - break; - - default: - log_msg incoming_log_msg; - incoming_async_msg.fill_log_msg(incoming_log_msg); - _formatter->format(incoming_log_msg); - for (auto &s : _sinks) - { - if (s->should_log(incoming_log_msg.level)) - { - s->log(incoming_log_msg); - } - } - } - return true; - } - - // Handle empty queue.. - // This is the only place where the queue can terminate or flush to avoid losing messages already in the queue - else - { - auto now = details::os::now(); - handle_flush_interval(now, last_flush); - sleep_or_yield(now, last_pop); - return !_terminate_requested; - } -} - -// flush all sinks if _flush_interval_ms has expired -inline void spdlog::details::async_log_helper::handle_flush_interval(log_clock::time_point& now, log_clock::time_point& last_flush) -{ - auto should_flush = _flush_requested || (_flush_interval_ms != std::chrono::milliseconds::zero() && now - last_flush >= _flush_interval_ms); - if (should_flush) - { - for (auto &s : _sinks) - s->flush(); - now = last_flush = details::os::now(); - _flush_requested = false; - } -} - -inline void spdlog::details::async_log_helper::set_formatter(formatter_ptr msg_formatter) -{ - _formatter = msg_formatter; -} - - -// spin, yield or sleep. use the time passed since last message as a hint -inline void spdlog::details::async_log_helper::sleep_or_yield(const spdlog::log_clock::time_point& now, const spdlog::log_clock::time_point& last_op_time) -{ - using namespace std::this_thread; - using std::chrono::milliseconds; - using std::chrono::microseconds; - - auto time_since_op = now - last_op_time; - - // spin upto 50 micros - if (time_since_op <= microseconds(50)) - return; - - // yield upto 150 micros - if (time_since_op <= microseconds(100)) - return std::this_thread::yield(); - - // sleep for 20 ms upto 200 ms - if (time_since_op <= milliseconds(200)) - return sleep_for(milliseconds(20)); - - // sleep for 200 ms - return sleep_for(milliseconds(200)); -} - -// wait for the queue to be empty -inline void spdlog::details::async_log_helper::wait_empty_q() -{ - auto last_op = details::os::now(); - while (_q.approx_size() > 0) - { - sleep_or_yield(details::os::now(), last_op); - } -} - -inline void spdlog::details::async_log_helper::set_error_handler(spdlog::log_err_handler err_handler) -{ - _err_handler = err_handler; -} - - - http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/8389c8aa/thirdparty/spdlog-0.13.0/include/spdlog/details/async_logger_impl.h ---------------------------------------------------------------------- diff --git a/thirdparty/spdlog-0.13.0/include/spdlog/details/async_logger_impl.h b/thirdparty/spdlog-0.13.0/include/spdlog/details/async_logger_impl.h deleted file mode 100644 index 487c628..0000000 --- a/thirdparty/spdlog-0.13.0/include/spdlog/details/async_logger_impl.h +++ /dev/null @@ -1,102 +0,0 @@ -// -// Copyright(c) 2015 Gabi Melman. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) -// - -#pragma once - -// Async Logger implementation -// Use an async_sink (queue per logger) to perform the logging in a worker thread - -#include <spdlog/details/async_log_helper.h> -#include <spdlog/async_logger.h> - -#include <string> -#include <functional> -#include <chrono> -#include <memory> - -template<class It> -inline spdlog::async_logger::async_logger(const std::string& logger_name, - const It& begin, - const It& end, - size_t queue_size, - const async_overflow_policy overflow_policy, - const std::function<void()>& worker_warmup_cb, - const std::chrono::milliseconds& flush_interval_ms, - const std::function<void()>& worker_teardown_cb) : - logger(logger_name, begin, end), - _async_log_helper(new details::async_log_helper(_formatter, _sinks, queue_size, _err_handler, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb)) -{ -} - -inline spdlog::async_logger::async_logger(const std::string& logger_name, - sinks_init_list sinks_list, - size_t queue_size, - const async_overflow_policy overflow_policy, - const std::function<void()>& worker_warmup_cb, - const std::chrono::milliseconds& flush_interval_ms, - const std::function<void()>& worker_teardown_cb) : - async_logger(logger_name, sinks_list.begin(), sinks_list.end(), queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb) {} - -inline spdlog::async_logger::async_logger(const std::string& logger_name, - sink_ptr single_sink, - size_t queue_size, - const async_overflow_policy overflow_policy, - const std::function<void()>& worker_warmup_cb, - const std::chrono::milliseconds& flush_interval_ms, - const std::function<void()>& worker_teardown_cb) : - async_logger(logger_name, -{ - single_sink -}, queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb) {} - - -inline void spdlog::async_logger::flush() -{ - _async_log_helper->flush(true); -} - -// Error handler -inline void spdlog::async_logger::set_error_handler(spdlog::log_err_handler err_handler) -{ - _err_handler = err_handler; - _async_log_helper->set_error_handler(err_handler); - -} -inline spdlog::log_err_handler spdlog::async_logger::error_handler() -{ - return _err_handler; -} - - -inline void spdlog::async_logger::_set_formatter(spdlog::formatter_ptr msg_formatter) -{ - _formatter = msg_formatter; - _async_log_helper->set_formatter(_formatter); -} - -inline void spdlog::async_logger::_set_pattern(const std::string& pattern) -{ - _formatter = std::make_shared<pattern_formatter>(pattern); - _async_log_helper->set_formatter(_formatter); -} - - -inline void spdlog::async_logger::_sink_it(details::log_msg& msg) -{ - try - { - _async_log_helper->log(msg); - if (_should_flush_on(msg)) - _async_log_helper->flush(false); // do async flush - } - catch (const std::exception &ex) - { - _err_handler(ex.what()); - } - catch (...) - { - _err_handler("Unknown exception"); - } -} http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/8389c8aa/thirdparty/spdlog-0.13.0/include/spdlog/details/file_helper.h ---------------------------------------------------------------------- diff --git a/thirdparty/spdlog-0.13.0/include/spdlog/details/file_helper.h b/thirdparty/spdlog-0.13.0/include/spdlog/details/file_helper.h deleted file mode 100644 index 074d9b8..0000000 --- a/thirdparty/spdlog-0.13.0/include/spdlog/details/file_helper.h +++ /dev/null @@ -1,118 +0,0 @@ -// -// Copyright(c) 2015 Gabi Melman. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) -// - -#pragma once - -// Helper class for file sink -// When failing to open a file, retry several times(5) with small delay between the tries(10 ms) -// Can be set to auto flush on every line -// Throw spdlog_ex exception on errors - -#include <spdlog/details/os.h> -#include <spdlog/details/log_msg.h> - -#include <chrono> -#include <cstdio> -#include <string> -#include <thread> -#include <cerrno> - -namespace spdlog -{ -namespace details -{ - -class file_helper -{ - -public: - const int open_tries = 5; - const int open_interval = 10; - - explicit file_helper() : - _fd(nullptr) - {} - - file_helper(const file_helper&) = delete; - file_helper& operator=(const file_helper&) = delete; - - ~file_helper() - { - close(); - } - - - void open(const filename_t& fname, bool truncate = false) - { - - close(); - auto *mode = truncate ? SPDLOG_FILENAME_T("wb") : SPDLOG_FILENAME_T("ab"); - _filename = fname; - for (int tries = 0; tries < open_tries; ++tries) - { - if (!os::fopen_s(&_fd, fname, mode)) - return; - - std::this_thread::sleep_for(std::chrono::milliseconds(open_interval)); - } - - throw spdlog_ex("Failed opening file " + os::filename_to_str(_filename) + " for writing", errno); - } - - void reopen(bool truncate) - { - if (_filename.empty()) - throw spdlog_ex("Failed re opening file - was not opened before"); - open(_filename, truncate); - - } - - void flush() - { - std::fflush(_fd); - } - - void close() - { - if (_fd) - { - std::fclose(_fd); - _fd = nullptr; - } - } - - void write(const log_msg& msg) - { - - size_t msg_size = msg.formatted.size(); - auto data = msg.formatted.data(); - if (std::fwrite(data, 1, msg_size, _fd) != msg_size) - throw spdlog_ex("Failed writing to file " + os::filename_to_str(_filename), errno); - } - - size_t size() - { - if (!_fd) - throw spdlog_ex("Cannot use size() on closed file " + os::filename_to_str(_filename)); - return os::filesize(_fd); - } - - const filename_t& filename() const - { - return _filename; - } - - static bool file_exists(const filename_t& name) - { - - return os::file_exists(name); - } - -private: - FILE* _fd; - filename_t _filename; -}; -} -} http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/8389c8aa/thirdparty/spdlog-0.13.0/include/spdlog/details/log_msg.h ---------------------------------------------------------------------- diff --git a/thirdparty/spdlog-0.13.0/include/spdlog/details/log_msg.h b/thirdparty/spdlog-0.13.0/include/spdlog/details/log_msg.h deleted file mode 100644 index ecdc73d..0000000 --- a/thirdparty/spdlog-0.13.0/include/spdlog/details/log_msg.h +++ /dev/null @@ -1,46 +0,0 @@ -// -// Copyright(c) 2015 Gabi Melman. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) -// - -#pragma once - -#include <spdlog/common.h> -#include <spdlog/details/os.h> - - -#include <string> -#include <utility> - -namespace spdlog -{ -namespace details -{ -struct log_msg -{ - log_msg() = default; - log_msg(const std::string *loggers_name, level::level_enum lvl) : logger_name(loggers_name), level(lvl) - { -#ifndef SPDLOG_NO_DATETIME - time = os::now(); -#endif - -#ifndef SPDLOG_NO_THREAD_ID - thread_id = os::thread_id(); -#endif - } - - log_msg(const log_msg& other) = delete; - log_msg& operator=(log_msg&& other) = delete; - log_msg(log_msg&& other) = delete; - - - const std::string *logger_name; - level::level_enum level; - log_clock::time_point time; - size_t thread_id; - fmt::MemoryWriter raw; - fmt::MemoryWriter formatted; -}; -} -} http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/8389c8aa/thirdparty/spdlog-0.13.0/include/spdlog/details/logger_impl.h ---------------------------------------------------------------------- diff --git a/thirdparty/spdlog-0.13.0/include/spdlog/details/logger_impl.h b/thirdparty/spdlog-0.13.0/include/spdlog/details/logger_impl.h deleted file mode 100644 index 5bb85f6..0000000 --- a/thirdparty/spdlog-0.13.0/include/spdlog/details/logger_impl.h +++ /dev/null @@ -1,296 +0,0 @@ -// -// Copyright(c) 2015 Gabi Melman. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) -// - -#pragma once - -#include <spdlog/logger.h> -#include <spdlog/sinks/stdout_sinks.h> - -#include <memory> -#include <string> - - -// create logger with given name, sinks and the default pattern formatter -// all other ctors will call this one -template<class It> -inline spdlog::logger::logger(const std::string& logger_name, const It& begin, const It& end): - _name(logger_name), - _sinks(begin, end), - _formatter(std::make_shared<pattern_formatter>("%+")) -{ - _level = level::info; - _flush_level = level::off; - _last_err_time = 0; - _err_handler = [this](const std::string &msg) - { - this->_default_err_handler(msg); - }; -} - -// ctor with sinks as init list -inline spdlog::logger::logger(const std::string& logger_name, sinks_init_list sinks_list): - logger(logger_name, sinks_list.begin(), sinks_list.end()) -{} - - -// ctor with single sink -inline spdlog::logger::logger(const std::string& logger_name, spdlog::sink_ptr single_sink): - logger(logger_name, -{ - single_sink -}) -{} - - -inline spdlog::logger::~logger() = default; - - -inline void spdlog::logger::set_formatter(spdlog::formatter_ptr msg_formatter) -{ - _set_formatter(msg_formatter); -} - -inline void spdlog::logger::set_pattern(const std::string& pattern) -{ - _set_pattern(pattern); -} - - -template <typename... Args> -inline void spdlog::logger::log(level::level_enum lvl, const char* fmt, const Args&... args) -{ - if (!should_log(lvl)) return; - - try - { - details::log_msg log_msg(&_name, lvl); - log_msg.raw.write(fmt, args...); - _sink_it(log_msg); - } - catch (const std::exception &ex) - { - _err_handler(ex.what()); - } - catch (...) - { - _err_handler("Unknown exception"); - } -} - -template <typename... Args> -inline void spdlog::logger::log(level::level_enum lvl, const char* msg) -{ - if (!should_log(lvl)) return; - try - { - details::log_msg log_msg(&_name, lvl); - log_msg.raw << msg; - _sink_it(log_msg); - } - catch (const std::exception &ex) - { - _err_handler(ex.what()); - } - catch (...) - { - _err_handler("Unknown exception"); - } - -} - -template<typename T> -inline void spdlog::logger::log(level::level_enum lvl, const T& msg) -{ - if (!should_log(lvl)) return; - try - { - details::log_msg log_msg(&_name, lvl); - log_msg.raw << msg; - _sink_it(log_msg); - } - catch (const std::exception &ex) - { - _err_handler(ex.what()); - } - catch (...) - { - _err_handler("Unknown exception"); - } -} - - -template <typename Arg1, typename... Args> -inline void spdlog::logger::trace(const char* fmt, const Arg1 &arg1, const Args&... args) -{ - log(level::trace, fmt, arg1, args...); -} - -template <typename Arg1, typename... Args> -inline void spdlog::logger::debug(const char* fmt, const Arg1 &arg1, const Args&... args) -{ - log(level::debug, fmt, arg1, args...); -} - -template <typename Arg1, typename... Args> -inline void spdlog::logger::info(const char* fmt, const Arg1 &arg1, const Args&... args) -{ - log(level::info, fmt, arg1, args...); -} - -template <typename Arg1, typename... Args> -inline void spdlog::logger::warn(const char* fmt, const Arg1 &arg1, const Args&... args) -{ - log(level::warn, fmt, arg1, args...); -} - -template <typename Arg1, typename... Args> -inline void spdlog::logger::error(const char* fmt, const Arg1 &arg1, const Args&... args) -{ - log(level::err, fmt, arg1, args...); -} - -template <typename Arg1, typename... Args> -inline void spdlog::logger::critical(const char* fmt, const Arg1 &arg1, const Args&... args) -{ - log(level::critical, fmt, arg1, args...); -} - -template<typename T> -inline void spdlog::logger::trace(const T& msg) -{ - log(level::trace, msg); -} - -template<typename T> -inline void spdlog::logger::debug(const T& msg) -{ - log(level::debug, msg); -} - - -template<typename T> -inline void spdlog::logger::info(const T& msg) -{ - log(level::info, msg); -} - - -template<typename T> -inline void spdlog::logger::warn(const T& msg) -{ - log(level::warn, msg); -} - -template<typename T> -inline void spdlog::logger::error(const T& msg) -{ - log(level::err, msg); -} - -template<typename T> -inline void spdlog::logger::critical(const T& msg) -{ - log(level::critical, msg); -} - - - - -// -// name and level -// -inline const std::string& spdlog::logger::name() const -{ - return _name; -} - -inline void spdlog::logger::set_level(spdlog::level::level_enum log_level) -{ - _level.store(log_level); -} - -inline void spdlog::logger::set_error_handler(spdlog::log_err_handler err_handler) -{ - _err_handler = err_handler; -} - -inline spdlog::log_err_handler spdlog::logger::error_handler() -{ - return _err_handler; -} - - -inline void spdlog::logger::flush_on(level::level_enum log_level) -{ - _flush_level.store(log_level); -} - -inline spdlog::level::level_enum spdlog::logger::level() const -{ - return static_cast<spdlog::level::level_enum>(_level.load(std::memory_order_relaxed)); -} - -inline bool spdlog::logger::should_log(spdlog::level::level_enum msg_level) const -{ - return msg_level >= _level.load(std::memory_order_relaxed); -} - -// -// protected virtual called at end of each user log call (if enabled) by the line_logger -// -inline void spdlog::logger::_sink_it(details::log_msg& msg) -{ - _formatter->format(msg); - for (auto &sink : _sinks) - { - if( sink->should_log( msg.level)) - { - sink->log(msg); - } - } - - if(_should_flush_on(msg)) - flush(); -} - -inline void spdlog::logger::_set_pattern(const std::string& pattern) -{ - _formatter = std::make_shared<pattern_formatter>(pattern); -} -inline void spdlog::logger::_set_formatter(formatter_ptr msg_formatter) -{ - _formatter = msg_formatter; -} - -inline void spdlog::logger::flush() -{ - for (auto& sink : _sinks) - sink->flush(); -} - -inline void spdlog::logger::_default_err_handler(const std::string &msg) -{ - auto now = time(nullptr); - if (now - _last_err_time < 60) - return; - auto tm_time = details::os::localtime(now); - char date_buf[100]; - std::strftime(date_buf, sizeof(date_buf), "%Y-%m-%d %H:%M:%S", &tm_time); - details::log_msg err_msg; - err_msg.formatted.write("[*** LOG ERROR ***] [{}] [{}] [{}]{}", name(), msg, date_buf, details::os::eol); - sinks::stderr_sink_mt::instance()->log(err_msg); - _last_err_time = now; -} - -inline bool spdlog::logger::_should_flush_on(const details::log_msg &msg) -{ - const auto flush_level = _flush_level.load(std::memory_order_relaxed); - return (msg.level >= flush_level) && (msg.level != level::off); -} - -inline const std::vector<spdlog::sink_ptr>& spdlog::logger::sinks() const -{ - return _sinks; -} http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/8389c8aa/thirdparty/spdlog-0.13.0/include/spdlog/details/mpmc_bounded_q.h ---------------------------------------------------------------------- diff --git a/thirdparty/spdlog-0.13.0/include/spdlog/details/mpmc_bounded_q.h b/thirdparty/spdlog-0.13.0/include/spdlog/details/mpmc_bounded_q.h deleted file mode 100644 index 3a46e8e..0000000 --- a/thirdparty/spdlog-0.13.0/include/spdlog/details/mpmc_bounded_q.h +++ /dev/null @@ -1,172 +0,0 @@ -/* -A modified version of Bounded MPMC queue by Dmitry Vyukov. - -Original code from: -http://www.1024cores.net/home/lock-free-algorithms/queues/bounded-mpmc-queue - -licensed by Dmitry Vyukov under the terms below: - -Simplified BSD license - -Copyright (c) 2010-2011 Dmitry Vyukov. All rights reserved. -Redistribution and use in source and binary forms, with or without modification, -are permitted provided that the following conditions are met: -1. Redistributions of source code must retain the above copyright notice, this list of -conditions and the following disclaimer. - -2. Redistributions in binary form must reproduce the above copyright notice, this list -of conditions and the following disclaimer in the documentation and/or other materials -provided with the distribution. - -THIS SOFTWARE IS PROVIDED BY DMITRY VYUKOV "AS IS" AND ANY EXPRESS OR IMPLIED -WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF -MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT -SHALL DMITRY VYUKOV OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, -INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, -OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF -LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE -OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF -ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -The views and conclusions contained in the software and documentation are those of the authors and -should not be interpreted as representing official policies, either expressed or implied, of Dmitry Vyukov. -*/ - -/* -The code in its current form adds the license below: - -Copyright(c) 2015 Gabi Melman. -Distributed under the MIT License (http://opensource.org/licenses/MIT) - -*/ - -#pragma once - -#include <spdlog/common.h> - -#include <atomic> -#include <utility> - -namespace spdlog -{ -namespace details -{ - -template<typename T> -class mpmc_bounded_queue -{ -public: - - using item_type = T; - mpmc_bounded_queue(size_t buffer_size) - :max_size_(buffer_size), - buffer_(new cell_t [buffer_size]), - buffer_mask_(buffer_size - 1) - { - //queue size must be power of two - if(!((buffer_size >= 2) && ((buffer_size & (buffer_size - 1)) == 0))) - throw spdlog_ex("async logger queue size must be power of two"); - - for (size_t i = 0; i != buffer_size; i += 1) - buffer_[i].sequence_.store(i, std::memory_order_relaxed); - enqueue_pos_.store(0, std::memory_order_relaxed); - dequeue_pos_.store(0, std::memory_order_relaxed); - } - - ~mpmc_bounded_queue() - { - delete [] buffer_; - } - - - bool enqueue(T&& data) - { - cell_t* cell; - size_t pos = enqueue_pos_.load(std::memory_order_relaxed); - for (;;) - { - cell = &buffer_[pos & buffer_mask_]; - size_t seq = cell->sequence_.load(std::memory_order_acquire); - intptr_t dif = (intptr_t)seq - (intptr_t)pos; - if (dif == 0) - { - if (enqueue_pos_.compare_exchange_weak(pos, pos + 1, std::memory_order_relaxed)) - break; - } - else if (dif < 0) - { - return false; - } - else - { - pos = enqueue_pos_.load(std::memory_order_relaxed); - } - } - cell->data_ = std::move(data); - cell->sequence_.store(pos + 1, std::memory_order_release); - return true; - } - - bool dequeue(T& data) - { - cell_t* cell; - size_t pos = dequeue_pos_.load(std::memory_order_relaxed); - for (;;) - { - cell = &buffer_[pos & buffer_mask_]; - size_t seq = - cell->sequence_.load(std::memory_order_acquire); - intptr_t dif = (intptr_t)seq - (intptr_t)(pos + 1); - if (dif == 0) - { - if (dequeue_pos_.compare_exchange_weak(pos, pos + 1, std::memory_order_relaxed)) - break; - } - else if (dif < 0) - return false; - else - pos = dequeue_pos_.load(std::memory_order_relaxed); - } - data = std::move(cell->data_); - cell->sequence_.store(pos + buffer_mask_ + 1, std::memory_order_release); - return true; - } - - size_t approx_size() - { - size_t first_pos = dequeue_pos_.load(std::memory_order_relaxed); - size_t last_pos = enqueue_pos_.load(std::memory_order_relaxed); - if (last_pos <= first_pos) - return 0; - auto size = last_pos - first_pos; - return size < max_size_ ? size : max_size_; - } - -private: - struct cell_t - { - std::atomic<size_t> sequence_; - T data_; - }; - - size_t const max_size_; - - static size_t const cacheline_size = 64; - typedef char cacheline_pad_t [cacheline_size]; - - cacheline_pad_t pad0_; - cell_t* const buffer_; - size_t const buffer_mask_; - cacheline_pad_t pad1_; - std::atomic<size_t> enqueue_pos_; - cacheline_pad_t pad2_; - std::atomic<size_t> dequeue_pos_; - cacheline_pad_t pad3_; - - mpmc_bounded_queue(mpmc_bounded_queue const&) = delete; - void operator= (mpmc_bounded_queue const&) = delete; -}; - -} // ns details -} // ns spdlog http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/8389c8aa/thirdparty/spdlog-0.13.0/include/spdlog/details/null_mutex.h ---------------------------------------------------------------------- diff --git a/thirdparty/spdlog-0.13.0/include/spdlog/details/null_mutex.h b/thirdparty/spdlog-0.13.0/include/spdlog/details/null_mutex.h deleted file mode 100644 index 67b0aee..0000000 --- a/thirdparty/spdlog-0.13.0/include/spdlog/details/null_mutex.h +++ /dev/null @@ -1,45 +0,0 @@ -// -// Copyright(c) 2015 Gabi Melman. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) -// - -#pragma once - -#include <atomic> -// null, no cost dummy "mutex" and dummy "atomic" int - -namespace spdlog -{ -namespace details -{ -struct null_mutex -{ - void lock() {} - void unlock() {} - bool try_lock() - { - return true; - } -}; - -struct null_atomic_int -{ - int value; - null_atomic_int() = default; - - null_atomic_int(int val):value(val) - {} - - int load(std::memory_order) const - { - return value; - } - - void store(int val) - { - value = val; - } -}; - -} -} http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/8389c8aa/thirdparty/spdlog-0.13.0/include/spdlog/details/os.h ---------------------------------------------------------------------- diff --git a/thirdparty/spdlog-0.13.0/include/spdlog/details/os.h b/thirdparty/spdlog-0.13.0/include/spdlog/details/os.h deleted file mode 100644 index b63ce66..0000000 --- a/thirdparty/spdlog-0.13.0/include/spdlog/details/os.h +++ /dev/null @@ -1,406 +0,0 @@ -// -// Copyright(c) 2015 Gabi Melman. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) -// -#pragma once - -#include <spdlog/common.h> - -#include <cstdio> -#include <ctime> -#include <functional> -#include <string> -#include <chrono> -#include <thread> -#include <stdio.h> -#include <string.h> -#include <sys/stat.h> -#include <sys/types.h> - -#ifdef _WIN32 - -#ifndef NOMINMAX -#define NOMINMAX //prevent windows redefining min/max -#endif - -#ifndef WIN32_LEAN_AND_MEAN -#define WIN32_LEAN_AND_MEAN -#endif -#include <windows.h> -#include <process.h> // _get_pid support -#include <io.h> // _get_osfhandle support - -#ifdef __MINGW32__ -#include <share.h> -#endif - -#else // unix - -#include <unistd.h> -#include <fcntl.h> - -#ifdef __linux__ -#include <sys/syscall.h> //Use gettid() syscall under linux to get thread id - -#elif __FreeBSD__ -#include <sys/thr.h> //Use thr_self() syscall under FreeBSD to get thread id -#endif - -#endif //unix - -#ifndef __has_feature // Clang - feature checking macros. -#define __has_feature(x) 0 // Compatibility with non-clang compilers. -#endif - - -namespace spdlog -{ -namespace details -{ -namespace os -{ - -inline spdlog::log_clock::time_point now() -{ - -#if defined __linux__ && defined SPDLOG_CLOCK_COARSE - timespec ts; - ::clock_gettime(CLOCK_REALTIME_COARSE, &ts); - return std::chrono::time_point<log_clock, typename log_clock::duration>( - std::chrono::duration_cast<typename log_clock::duration>( - std::chrono::seconds(ts.tv_sec) + std::chrono::nanoseconds(ts.tv_nsec))); - - -#else - return log_clock::now(); -#endif - -} -inline std::tm localtime(const std::time_t &time_tt) -{ - -#ifdef _WIN32 - std::tm tm; - localtime_s(&tm, &time_tt); -#else - std::tm tm; - localtime_r(&time_tt, &tm); -#endif - return tm; -} - -inline std::tm localtime() -{ - std::time_t now_t = time(nullptr); - return localtime(now_t); -} - - -inline std::tm gmtime(const std::time_t &time_tt) -{ - -#ifdef _WIN32 - std::tm tm; - gmtime_s(&tm, &time_tt); -#else - std::tm tm; - gmtime_r(&time_tt, &tm); -#endif - return tm; -} - -inline std::tm gmtime() -{ - std::time_t now_t = time(nullptr); - return gmtime(now_t); -} -inline bool operator==(const std::tm& tm1, const std::tm& tm2) -{ - return (tm1.tm_sec == tm2.tm_sec && - tm1.tm_min == tm2.tm_min && - tm1.tm_hour == tm2.tm_hour && - tm1.tm_mday == tm2.tm_mday && - tm1.tm_mon == tm2.tm_mon && - tm1.tm_year == tm2.tm_year && - tm1.tm_isdst == tm2.tm_isdst); -} - -inline bool operator!=(const std::tm& tm1, const std::tm& tm2) -{ - return !(tm1 == tm2); -} - -// eol definition -#if !defined (SPDLOG_EOL) -#ifdef _WIN32 -#define SPDLOG_EOL "\r\n" -#else -#define SPDLOG_EOL "\n" -#endif -#endif - -SPDLOG_CONSTEXPR static const char* eol = SPDLOG_EOL; -SPDLOG_CONSTEXPR static int eol_size = sizeof(SPDLOG_EOL) - 1; - -inline void prevent_child_fd(FILE *f) -{ -#ifdef _WIN32 - auto file_handle = (HANDLE)_get_osfhandle(_fileno(f)); - if (!::SetHandleInformation(file_handle, HANDLE_FLAG_INHERIT, 0)) - throw spdlog_ex("SetHandleInformation failed", errno); -#else - auto fd = fileno(f); - if(fcntl(fd, F_SETFD, FD_CLOEXEC) == -1) - throw spdlog_ex("fcntl with FD_CLOEXEC failed", errno); -#endif -} - - -//fopen_s on non windows for writing -inline int fopen_s(FILE** fp, const filename_t& filename, const filename_t& mode) -{ -#ifdef _WIN32 -#ifdef SPDLOG_WCHAR_FILENAMES - *fp = _wfsopen((filename.c_str()), mode.c_str(), _SH_DENYWR); -#else - *fp = _fsopen((filename.c_str()), mode.c_str(), _SH_DENYWR); -#endif -#else //unix - *fp = fopen((filename.c_str()), mode.c_str()); -#endif - -#ifdef SPDLOG_PREVENT_CHILD_FD - if(*fp != nullptr) - prevent_child_fd(*fp); -#endif - return *fp == nullptr; -} - - -inline int remove(const filename_t &filename) -{ -#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES) - return _wremove(filename.c_str()); -#else - return std::remove(filename.c_str()); -#endif -} - -inline int rename(const filename_t& filename1, const filename_t& filename2) -{ -#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES) - return _wrename(filename1.c_str(), filename2.c_str()); -#else - return std::rename(filename1.c_str(), filename2.c_str()); -#endif -} - - -//Return if file exists -inline bool file_exists(const filename_t& filename) -{ -#ifdef _WIN32 -#ifdef SPDLOG_WCHAR_FILENAMES - auto attribs = GetFileAttributesW(filename.c_str()); -#else - auto attribs = GetFileAttributesA(filename.c_str()); -#endif - return (attribs != INVALID_FILE_ATTRIBUTES && !(attribs & FILE_ATTRIBUTE_DIRECTORY)); -#else //common linux/unix all have the stat system call - struct stat buffer; - return (stat (filename.c_str(), &buffer) == 0); -#endif -} - - - - -//Return file size according to open FILE* object -inline size_t filesize(FILE *f) -{ - if (f == nullptr) - throw spdlog_ex("Failed getting file size. fd is null"); -#ifdef _WIN32 - int fd = _fileno(f); -#if _WIN64 //64 bits - struct _stat64 st; - if (_fstat64(fd, &st) == 0) - return st.st_size; - -#else //windows 32 bits - long ret = _filelength(fd); - if (ret >= 0) - return static_cast<size_t>(ret); -#endif - -#else // unix - int fd = fileno(f); - //64 bits(but not in osx, where fstat64 is deprecated) -#if !defined(__FreeBSD__) && !defined(__APPLE__) && (defined(__x86_64__) || defined(__ppc64__)) - struct stat64 st; - if (fstat64(fd, &st) == 0) - return static_cast<size_t>(st.st_size); -#else // unix 32 bits or osx - struct stat st; - if (fstat(fd, &st) == 0) - return static_cast<size_t>(st.st_size); -#endif -#endif - throw spdlog_ex("Failed getting file size from fd", errno); -} - - - - -//Return utc offset in minutes or throw spdlog_ex on failure -inline int utc_minutes_offset(const std::tm& tm = details::os::localtime()) -{ - -#ifdef _WIN32 -#if _WIN32_WINNT < _WIN32_WINNT_WS08 - TIME_ZONE_INFORMATION tzinfo; - auto rv = GetTimeZoneInformation(&tzinfo); -#else - DYNAMIC_TIME_ZONE_INFORMATION tzinfo; - auto rv = GetDynamicTimeZoneInformation(&tzinfo); -#endif - if (rv == TIME_ZONE_ID_INVALID) - throw spdlog::spdlog_ex("Failed getting timezone info. ", errno); - - int offset = -tzinfo.Bias; - if (tm.tm_isdst) - offset -= tzinfo.DaylightBias; - else - offset -= tzinfo.StandardBias; - return offset; -#else - -#if defined(sun) || defined(__sun) - // 'tm_gmtoff' field is BSD extension and it's missing on SunOS/Solaris - struct helper - { - static long int calculate_gmt_offset(const std::tm & localtm = details::os::localtime(), const std::tm & gmtm = details::os::gmtime()) - { - int local_year = localtm.tm_year + (1900 - 1); - int gmt_year = gmtm.tm_year + (1900 - 1); - - long int days = ( - // difference in day of year - localtm.tm_yday - gmtm.tm_yday - - // + intervening leap days - + ((local_year >> 2) - (gmt_year >> 2)) - - (local_year / 100 - gmt_year / 100) - + ((local_year / 100 >> 2) - (gmt_year / 100 >> 2)) - - // + difference in years * 365 */ - + (long int)(local_year - gmt_year) * 365 - ); - - long int hours = (24 * days) + (localtm.tm_hour - gmtm.tm_hour); - long int mins = (60 * hours) + (localtm.tm_min - gmtm.tm_min); - long int secs = (60 * mins) + (localtm.tm_sec - gmtm.tm_sec); - - return secs; - } - }; - - long int offset_seconds = helper::calculate_gmt_offset(tm); -#else - long int offset_seconds = tm.tm_gmtoff; -#endif - - return static_cast<int>(offset_seconds / 60); -#endif -} - -//Return current thread id as size_t -//It exists because the std::this_thread::get_id() is much slower(espcially under VS 2013) -inline size_t _thread_id() -{ -#ifdef _WIN32 - return static_cast<size_t>(::GetCurrentThreadId()); -#elif __linux__ -# if defined(__ANDROID__) && defined(__ANDROID_API__) && (__ANDROID_API__ < 21) -# define SYS_gettid __NR_gettid -# endif - return static_cast<size_t>(syscall(SYS_gettid)); -#elif __FreeBSD__ - long tid; - thr_self(&tid); - return static_cast<size_t>(tid); -#else //Default to standard C++11 (OSX and other Unix) - return static_cast<size_t>(std::hash<std::thread::id>()(std::this_thread::get_id())); -#endif -} - -//Return current thread id as size_t (from thread local storage) -inline size_t thread_id() -{ -#if defined(_MSC_VER) && (_MSC_VER < 1900) || defined(__clang__) && !__has_feature(cxx_thread_local) - return _thread_id(); -#else - static thread_local const size_t tid = _thread_id(); - return tid; -#endif -} - - - - -// wchar support for windows file names (SPDLOG_WCHAR_FILENAMES must be defined) -#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES) -#define SPDLOG_FILENAME_T(s) L ## s -inline std::string filename_to_str(const filename_t& filename) -{ - std::wstring_convert<std::codecvt_utf8<wchar_t>, wchar_t> c; - return c.to_bytes(filename); -} -#else -#define SPDLOG_FILENAME_T(s) s -inline std::string filename_to_str(const filename_t& filename) -{ - return filename; -} -#endif - - -// Return errno string (thread safe) -inline std::string errno_str(int err_num) -{ - char buf[256]; - SPDLOG_CONSTEXPR auto buf_size = sizeof(buf); - -#ifdef _WIN32 - if(strerror_s(buf, buf_size, err_num) == 0) - return std::string(buf); - else - return "Unkown error"; - -#elif defined(__FreeBSD__) || defined(__APPLE__) || defined(ANDROID) || defined(__SUNPRO_CC) || \ - ((_POSIX_C_SOURCE >= 200112L) && ! defined(_GNU_SOURCE)) // posix version - - if (strerror_r(err_num, buf, buf_size) == 0) - return std::string(buf); - else - return "Unkown error"; - -#else // gnu version (might not use the given buf, so its retval pointer must be used) - return std::string(strerror_r(err_num, buf, buf_size)); -#endif -} - -inline int pid() -{ - -#ifdef _WIN32 - return ::_getpid(); -#else - return static_cast<int>(::getpid()); -#endif - -} - -} //os -} //details -} //spdlog