couchbase 4.2.8-dev.1 → 4.2.9

package/deps/couchbase-cxx-cache/spdlog/66ab2619a0014319471759c03e2de1af6bda14de/spdlog/example/example.cpp

@@ -1,398 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-
-// spdlog usage example
-
-#include <cstdio>
-#include <chrono>
-
-void load_levels_example();
-void stdout_logger_example();
-void basic_example();
-void rotating_example();
-void daily_example();
-void callback_example();
-void async_example();
-void binary_example();
-void vector_example();
-void stopwatch_example();
-void trace_example();
-void multi_sink_example();
-void user_defined_example();
-void err_handler_example();
-void syslog_example();
-void udp_example();
-void custom_flags_example();
-void file_events_example();
-void replace_default_logger_example();
-
-#include "spdlog/spdlog.h"
-#include "spdlog/cfg/env.h"  // support for loading levels from the environment variable
-#include "spdlog/fmt/ostr.h" // support for user defined types
-
-
-int main(int, char *[])
-{
-    // Log levels can be loaded from argv/env using "SPDLOG_LEVEL"
-    load_levels_example();
-
-    spdlog::info("Welcome to spdlog version {}.{}.{}  !", SPDLOG_VER_MAJOR, SPDLOG_VER_MINOR, SPDLOG_VER_PATCH);
-
-    spdlog::warn("Easy padding in numbers like {:08d}", 12);
-    spdlog::critical("Support for int: {0:d};  hex: {0:x};  oct: {0:o}; bin: {0:b}", 42);
-    spdlog::info("Support for floats {:03.2f}", 1.23456);
-    spdlog::info("Positional args are {1} {0}..", "too", "supported");
-    spdlog::info("{:>8} aligned, {:<8} aligned", "right", "left");
-
-    // Runtime log levels
-    spdlog::set_level(spdlog::level::info); // Set global log level to info
-    spdlog::debug("This message should not be displayed!");
-    spdlog::set_level(spdlog::level::trace); // Set specific logger's log level
-    spdlog::debug("This message should be displayed..");
-
-    // Customize msg format for all loggers
-    spdlog::set_pattern("[%H:%M:%S %z] [%^%L%$] [thread %t] %v");
-    spdlog::info("This an info message with custom format");
-    spdlog::set_pattern("%+"); // back to default format
-    spdlog::set_level(spdlog::level::info);
-
-    // Backtrace support
-    // Loggers can store in a ring buffer all messages (including debug/trace) for later inspection.
-    // When needed, call dump_backtrace() to see what happened:
-    spdlog::enable_backtrace(10); // create ring buffer with capacity of 10  messages
-    for (int i = 0; i < 100; i++)
-    {
-        spdlog::debug("Backtrace message {}", i); // not logged..
-    }
-    // e.g. if some error happened:
-    spdlog::dump_backtrace(); // log them now!
-
-    try
-    {
-        stdout_logger_example();
-        basic_example();
-        rotating_example();
-        daily_example();
-        callback_example();
-        async_example();
-        binary_example();
-        vector_example();
-        multi_sink_example();
-        user_defined_example();
-        err_handler_example();
-        trace_example();
-        stopwatch_example();
-        udp_example();
-        custom_flags_example();
-        file_events_example();
-        replace_default_logger_example();
-
-        // Flush all *registered* loggers using a worker thread every 3 seconds.
-        // note: registered loggers *must* be thread safe for this to work correctly!
-        spdlog::flush_every(std::chrono::seconds(3));
-
-        // Apply some function on all registered loggers
-        spdlog::apply_all([&](std::shared_ptr<spdlog::logger> l) { l->info("End of example."); });
-
-        // Release all spdlog resources, and drop all loggers in the registry.
-        // This is optional (only mandatory if using windows + async log).
-        spdlog::shutdown();
-    }
-
-    // Exceptions will only be thrown upon failed logger or sink construction (not during logging).
-    catch (const spdlog::spdlog_ex &ex)
-    {
-        std::printf("Log initialization failed: %s\n", ex.what());
-        return 1;
-    }
-}
-
-#include "spdlog/sinks/stdout_color_sinks.h"
-// or #include "spdlog/sinks/stdout_sinks.h" if no colors needed.
-void stdout_logger_example()
-{
-    // Create color multi threaded logger.
-    auto console = spdlog::stdout_color_mt("console");
-    // or for stderr:
-    // auto console = spdlog::stderr_color_mt("error-logger");
-}
-
-#include "spdlog/sinks/basic_file_sink.h"
-void basic_example()
-{
-    // Create basic file logger (not rotated).
-    auto my_logger = spdlog::basic_logger_mt("file_logger", "logs/basic-log.txt", true);
-}
-
-#include "spdlog/sinks/rotating_file_sink.h"
-void rotating_example()
-{
-    // Create a file rotating logger with 5mb size max and 3 rotated files.
-    auto rotating_logger = spdlog::rotating_logger_mt("some_logger_name", "logs/rotating.txt", 1048576 * 5, 3);
-}
-
-#include "spdlog/sinks/daily_file_sink.h"
-void daily_example()
-{
-    // Create a daily logger - a new file is created every day on 2:30am.
-    auto daily_logger = spdlog::daily_logger_mt("daily_logger", "logs/daily.txt", 2, 30);
-}
-
-#include "spdlog/sinks/callback_sink.h"
-void callback_example()
-{
-    // Create the logger
-    auto logger = spdlog::callback_logger_mt("custom_callback_logger", [](const spdlog::details::log_msg & /*msg*/) {
-        // do what you need to do with msg
-    });
-}
-
-#include "spdlog/cfg/env.h"
-void load_levels_example()
-{
-    // Set the log level to "info" and mylogger to "trace":
-    // SPDLOG_LEVEL=info,mylogger=trace && ./example
-    spdlog::cfg::load_env_levels();
-    // or from command line:
-    // ./example SPDLOG_LEVEL=info,mylogger=trace
-    // #include "spdlog/cfg/argv.h" // for loading levels from argv
-    // spdlog::cfg::load_argv_levels(args, argv);
-}
-
-#include "spdlog/async.h"
-void async_example()
-{
-    // Default thread pool settings can be modified *before* creating the async logger:
-    // spdlog::init_thread_pool(32768, 1); // queue with max 32k items 1 backing thread.
-    auto async_file = spdlog::basic_logger_mt<spdlog::async_factory>("async_file_logger", "logs/async_log.txt");
-    // alternatively:
-    // auto async_file = spdlog::create_async<spdlog::sinks::basic_file_sink_mt>("async_file_logger", "logs/async_log.txt");
-
-    for (int i = 1; i < 101; ++i)
-    {
-        async_file->info("Async message #{}", i);
-    }
-}
-
-// Log binary data as hex.
-// Many types of std::container<char> types can be used.
-// Iterator ranges are supported too.
-// Format flags:
-// {:X} - print in uppercase.
-// {:s} - don't separate each byte with space.
-// {:p} - don't print the position on each line start.
-// {:n} - don't split the output to lines.
-
-#if !defined SPDLOG_USE_STD_FORMAT || defined(_MSC_VER)
-#include "spdlog/fmt/bin_to_hex.h"
-void binary_example()
-{
-    std::vector<char> buf(80);
-    for (int i = 0; i < 80; i++)
-    {
-        buf.push_back(static_cast<char>(i & 0xff));
-    }
-    spdlog::info("Binary example: {}", spdlog::to_hex(buf));
-    spdlog::info("Another binary example:{:n}", spdlog::to_hex(std::begin(buf), std::begin(buf) + 10));
-    // more examples:
-    // logger->info("uppercase: {:X}", spdlog::to_hex(buf));
-    // logger->info("uppercase, no delimiters: {:Xs}", spdlog::to_hex(buf));
-    // logger->info("uppercase, no delimiters, no position info: {:Xsp}", spdlog::to_hex(buf));
-    // logger->info("hexdump style: {:a}", spdlog::to_hex(buf));
-    // logger->info("hexdump style, 20 chars per line {:a}", spdlog::to_hex(buf, 20));
-}
-#else
-void binary_example() {
-    // not supported with std::format yet
-}
-#endif
-
-// Log a vector of numbers
-#ifndef SPDLOG_USE_STD_FORMAT
-#    include "spdlog/fmt/ranges.h"
-void vector_example()
-{
-    std::vector<int> vec = {1, 2, 3};
-    spdlog::info("Vector example: {}", vec);
-}
-
-#else
-void vector_example() {}
-#endif
-
-// ! DSPDLOG_USE_STD_FORMAT
-
-// Compile time log levels.
-// define SPDLOG_ACTIVE_LEVEL to required level (e.g. SPDLOG_LEVEL_TRACE)
-void trace_example()
-{
-    // trace from default logger
-    SPDLOG_TRACE("Some trace message.. {} ,{}", 1, 3.23);
-    // debug from default logger
-    SPDLOG_DEBUG("Some debug message.. {} ,{}", 1, 3.23);
-
-    // trace from logger object
-    auto logger = spdlog::get("file_logger");
-    SPDLOG_LOGGER_TRACE(logger, "another trace message");
-}
-
-// stopwatch example
-#include "spdlog/stopwatch.h"
-#include <thread>
-void stopwatch_example()
-{
-    spdlog::stopwatch sw;
-    std::this_thread::sleep_for(std::chrono::milliseconds(123));
-    spdlog::info("Stopwatch: {} seconds", sw);
-}
-
-#include "spdlog/sinks/udp_sink.h"
-void udp_example()
-{
-    spdlog::sinks::udp_sink_config cfg("127.0.0.1", 11091);
-    auto my_logger = spdlog::udp_logger_mt("udplog", cfg);
-    my_logger->set_level(spdlog::level::debug);
-    my_logger->info("hello world");
-}
-
-// A logger with multiple sinks (stdout and file) - each with a different format and log level.
-void multi_sink_example()
-{
-    auto console_sink = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
-    console_sink->set_level(spdlog::level::warn);
-    console_sink->set_pattern("[multi_sink_example] [%^%l%$] %v");
-
-    auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>("logs/multisink.txt", true);
-    file_sink->set_level(spdlog::level::trace);
-
-    spdlog::logger logger("multi_sink", {console_sink, file_sink});
-    logger.set_level(spdlog::level::debug);
-    logger.warn("this should appear in both console and file");
-    logger.info("this message should not appear in the console, only in the file");
-}
-
-// User defined types logging
-struct my_type
-{
-    int i = 0;
-    explicit my_type(int i)
-        : i(i){};
-};
-
-#ifndef SPDLOG_USE_STD_FORMAT // when using fmtlib
-template<>
-struct fmt::formatter<my_type> : fmt::formatter<std::string>
-{
-    auto format(my_type my, format_context &ctx) -> decltype(ctx.out())
-    {
-        return fmt::format_to(ctx.out(), "[my_type i={}]", my.i);
-    }
-};
-
-#else // when using std::format
-template<>
-struct std::formatter<my_type> : std::formatter<std::string>
-{
-    auto format(my_type my, format_context &ctx) const -> decltype(ctx.out())
-    {
-        return format_to(ctx.out(), "[my_type i={}]", my.i);
-    }
-};
-#endif
-
-void user_defined_example()
-{
-    spdlog::info("user defined type: {}", my_type(14));
-}
-
-// Custom error handler. Will be triggered on log failure.
-void err_handler_example()
-{
-    // can be set globally or per logger(logger->set_error_handler(..))
-    spdlog::set_error_handler([](const std::string &msg) { printf("*** Custom log error handler: %s ***\n", msg.c_str()); });
-}
-
-// syslog example (linux/osx/freebsd)
-#ifndef _WIN32
-#    include "spdlog/sinks/syslog_sink.h"
-void syslog_example()
-{
-    std::string ident = "spdlog-example";
-    auto syslog_logger = spdlog::syslog_logger_mt("syslog", ident, LOG_PID);
-    syslog_logger->warn("This is warning that will end up in syslog.");
-}
-#endif
-
-// Android example.
-#if defined(__ANDROID__)
-#    include "spdlog/sinks/android_sink.h"
-void android_example()
-{
-    std::string tag = "spdlog-android";
-    auto android_logger = spdlog::android_logger_mt("android", tag);
-    android_logger->critical("Use \"adb shell logcat\" to view this message.");
-}
-#endif
-
-// Log patterns can contain custom flags.
-// this will add custom flag '%*' which will be bound to a <my_formatter_flag> instance
-#include "spdlog/pattern_formatter.h"
-class my_formatter_flag : public spdlog::custom_flag_formatter
-{
-public:
-    void format(const spdlog::details::log_msg &, const std::tm &, spdlog::memory_buf_t &dest) override
-    {
-        std::string some_txt = "custom-flag";
-        dest.append(some_txt.data(), some_txt.data() + some_txt.size());
-    }
-
-    std::unique_ptr<custom_flag_formatter> clone() const override
-    {
-        return spdlog::details::make_unique<my_formatter_flag>();
-    }
-};
-
-void custom_flags_example()
-{
-
-    using spdlog::details::make_unique; // for pre c++14
-    auto formatter = make_unique<spdlog::pattern_formatter>();
-    formatter->add_flag<my_formatter_flag>('*').set_pattern("[%n] [%*] [%^%l%$] %v");
-    // set the new formatter using spdlog::set_formatter(formatter) or logger->set_formatter(formatter)
-    // spdlog::set_formatter(std::move(formatter));
-}
-
-void file_events_example()
-{
-    // pass the spdlog::file_event_handlers to file sinks for open/close log file notifications
-    spdlog::file_event_handlers handlers;
-    handlers.before_open = [](spdlog::filename_t filename) { spdlog::info("Before opening {}", filename); };
-    handlers.after_open = [](spdlog::filename_t filename, std::FILE *fstream) {
-        spdlog::info("After opening {}", filename);
-        fputs("After opening\n", fstream);
-    };
-    handlers.before_close = [](spdlog::filename_t filename, std::FILE *fstream) {
-        spdlog::info("Before closing {}", filename);
-        fputs("Before closing\n", fstream);
-    };
-    handlers.after_close = [](spdlog::filename_t filename) { spdlog::info("After closing {}", filename); };
-    auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>("logs/events-sample.txt", true, handlers);
-    spdlog::logger my_logger("some_logger", file_sink);
-    my_logger.info("Some log line");
-}
-
-void replace_default_logger_example()
-{
-    // store the old logger so we don't break other examples.
-    auto old_logger = spdlog::default_logger();
-
-    auto new_logger = spdlog::basic_logger_mt("new_default_logger", "logs/new-default-log.txt", true);
-    spdlog::set_default_logger(new_logger);
-    spdlog::set_level(spdlog::level::info);
-    spdlog::debug("This message should not be displayed!");
-    spdlog::set_level(spdlog::level::trace);
-    spdlog::debug("This message should be displayed..");
-
-    spdlog::set_default_logger(old_logger);
-}

package/deps/couchbase-cxx-client/core/impl/append.cxx

@@ -1,87 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *   Copyright 2020-Present Couchbase, Inc.
- *
- *   Licensed under the Apache License, Version 2.0 (the "License");
- *   you may not use this file except in compliance with the License.
- *   You may obtain a copy of the License at
- *
- *       http://www.apache.org/licenses/LICENSE-2.0
- *
- *   Unless required by applicable law or agreed to in writing, software
- *   distributed under the License is distributed on an "AS IS" BASIS,
- *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *   See the License for the specific language governing permissions and
- *   limitations under the License.
- */
-
-#include "core/cluster.hxx"
-#include "core/error_context/key_value.hxx"
-#include "core/impl/observe_poll.hxx"
-#include "core/impl/observe_seqno.hxx"
-#include "core/operations/document_append.hxx"
-
-#include <couchbase/append_options.hxx>
-
-namespace couchbase::core::impl
-{
-void
-initiate_append_operation(std::shared_ptr<couchbase::core::cluster> core,
-                          std::string bucket_name,
-                          std::string scope_name,
-                          std::string collection_name,
-                          std::string document_key,
-                          std::vector<std::byte> data,
-                          append_options::built options,
-                          append_handler&& handler)
-{
-    auto id = document_id{
-        std::move(bucket_name),
-        std::move(scope_name),
-        std::move(collection_name),
-        std::move(document_key),
-    };
-    if (options.persist_to == persist_to::none && options.replicate_to == replicate_to::none) {
-        return core->execute(
-          operations::append_request{
-            std::move(id),
-            std::move(data),
-            {},
-            {},
-            options.durability_level,
-            options.timeout,
-            { options.retry_strategy },
-          },
-          [handler = std::move(handler)](operations::append_response&& resp) mutable {
-              if (resp.ctx.ec()) {
-                  return handler(std::move(resp.ctx), mutation_result{});
-              }
-              return handler(std::move(resp.ctx), mutation_result{ resp.cas, std::move(resp.token) });
-          });
-    }
-
-    operations::append_request request{
-        id, std::move(data), {}, {}, durability_level::none, options.timeout, { options.retry_strategy },
-    };
-    return core->execute(
-      std::move(request), [core, id = std::move(id), options, handler = std::move(handler)](operations::append_response&& resp) mutable {
-          if (resp.ctx.ec()) {
-              return handler(std::move(resp.ctx), mutation_result{ resp.cas, std::move(resp.token) });
-          }
-
-          initiate_observe_poll(core,
-                                std::move(id),
-                                resp.token,
-                                options.timeout,
-                                options.persist_to,
-                                options.replicate_to,
-                                [resp = std::move(resp), handler = std::move(handler)](std::error_code ec) mutable {
-                                    if (ec) {
-                                        resp.ctx.override_ec(ec);
-                                        return handler(std::move(resp.ctx), mutation_result{});
-                                    }
-                                    return handler(std::move(resp.ctx), mutation_result{ resp.cas, std::move(resp.token) });
-                                });
-      });
-}
-} // namespace couchbase::core::impl

package/deps/couchbase-cxx-client/core/impl/build_deferred_query_indexes.cxx

@@ -1,157 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *   Copyright 2020-Present Couchbase, Inc.
- *
- *   Licensed under the Apache License, Version 2.0 (the "License");
- *   you may not use this file except in compliance with the License.
- *   You may obtain a copy of the License at
- *
- *       http://www.apache.org/licenses/LICENSE-2.0
- *
- *   Unless required by applicable law or agreed to in writing, software
- *   distributed under the License is distributed on an "AS IS" BASIS,
- *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *   See the License for the specific language governing permissions and
- *   limitations under the License.
- */
-
-#include <couchbase/error_codes.hxx>
-#include <couchbase/query_index_manager.hxx>
-
-#include "core/cluster.hxx"
-#include "core/operations/management/query_index_build.hxx"
-#include "core/operations/management/query_index_build_deferred.hxx"
-
-namespace couchbase
-{
-template<typename Response>
-static manager_error_context
-build_context(Response& resp)
-{
-    return manager_error_context(internal_manager_error_context{ resp.ctx.ec,
-                                                                 resp.ctx.last_dispatched_to,
-                                                                 resp.ctx.last_dispatched_from,
-                                                                 resp.ctx.retry_attempts,
-                                                                 std::move(resp.ctx.retry_reasons),
-                                                                 std::move(resp.ctx.client_context_id),
-                                                                 resp.ctx.http_status,
-                                                                 std::move(resp.ctx.http_body),
-                                                                 std::move(resp.ctx.path) });
-}
-
-static core::operations::management::query_index_build_request
-build_build_index_request(std::string bucket_name,
-                          core::operations::management::query_index_get_all_deferred_response list_resp,
-                          const build_query_index_options::built& options)
-{
-    core::operations::management::query_index_build_request request{
-        std::move(bucket_name), {}, {}, {}, std::move(list_resp.index_names), {}, options.timeout
-    };
-    return request;
-}
-
-static core::operations::management::query_index_get_all_deferred_request
-build_get_all_request(std::string bucket_name, const build_query_index_options::built& options)
-{
-    core::operations::management::query_index_get_all_deferred_request request{ std::move(bucket_name), {}, {}, {}, {}, options.timeout };
-    return request;
-}
-
-static core::operations::management::query_index_build_request
-build_build_index_request(std::string bucket_name,
-                          std::string scope_name,
-                          std::string collection_name,
-                          core::operations::management::query_index_get_all_deferred_response list_resp,
-                          const build_query_index_options::built& options)
-{
-    core::operations::management::query_index_build_request request{ "",
-                                                                     "",
-                                                                     std::move(collection_name),
-                                                                     core::query_context{ std::move(bucket_name), std::move(scope_name) },
-                                                                     std::move(list_resp.index_names),
-                                                                     {},
-                                                                     options.timeout };
-    return request;
-}
-
-static core::operations::management::query_index_get_all_deferred_request
-build_get_all_request(std::string bucket_name,
-                      std::string scope_name,
-                      std::string collection_name,
-                      const build_query_index_options::built& options)
-{
-    core::operations::management::query_index_get_all_deferred_request request{
-        "", "", std::move(collection_name), core::query_context{ std::move(bucket_name), std::move(scope_name) }, {}, options.timeout
-    };
-    return request;
-}
-
-void
-query_index_manager::build_deferred_indexes(std::string bucket_name,
-                                            const couchbase::build_query_index_options& options,
-                                            couchbase::build_deferred_query_indexes_handler&& handler) const
-{
-
-    auto get_all_request = build_get_all_request(bucket_name, options.build());
-    core_->execute(std::move(get_all_request),
-                   [handler = std::move(handler), this, bucket_name, options](
-                     core::operations::management::query_index_get_all_deferred_response resp1) mutable {
-                       auto list_resp = std::move(resp1);
-                       if (list_resp.ctx.ec) {
-                           return handler(build_context(list_resp));
-                       }
-                       if (list_resp.index_names.empty()) {
-                           return handler(build_context(list_resp));
-                       }
-                       auto build_request = build_build_index_request(std::move(bucket_name), list_resp, options.build());
-                       core_->execute(
-                         std::move(build_request),
-                         [handler = std::move(handler)](core::operations::management::query_index_build_response resp2) mutable {
-                             auto build_resp = std::move(resp2);
-                             return handler(build_context(build_resp));
-                         });
-                   });
-}
-
-auto
-query_index_manager::build_deferred_indexes(std::string bucket_name, const couchbase::build_query_index_options& options) const
-  -> std::future<manager_error_context>
-{
-    auto barrier = std::make_shared<std::promise<manager_error_context>>();
-    build_deferred_indexes(std::move(bucket_name), options, [barrier](auto ctx) mutable { barrier->set_value(std::move(ctx)); });
-    return barrier->get_future();
-}
-
-void
-collection_query_index_manager::build_deferred_indexes(const build_query_index_options& options,
-                                                       build_deferred_query_indexes_handler&& handler) const
-{
-    auto get_all_request = build_get_all_request(bucket_name_, scope_name_, collection_name_, options.build());
-    core_->execute(
-      std::move(get_all_request),
-      [handler = std::move(handler), this, options](core::operations::management::query_index_get_all_deferred_response resp1) mutable {
-          auto list_resp = std::move(resp1);
-          if (list_resp.ctx.ec) {
-              return handler(build_context(list_resp));
-          }
-          if (list_resp.index_names.empty()) {
-              return handler(build_context(list_resp));
-          }
-          auto build_request = build_build_index_request(bucket_name_, scope_name_, collection_name_, list_resp, options.build());
-          core_->execute(std::move(build_request),
-                         [handler = std::move(handler)](core::operations::management::query_index_build_response resp2) mutable {
-                             auto build_resp = std::move(resp2);
-                             return handler(build_context(build_resp));
-                         });
-      });
-}
-
-auto
-collection_query_index_manager::build_deferred_indexes(const couchbase::build_query_index_options& options) const
-  -> std::future<manager_error_context>
-{
-    auto barrier = std::make_shared<std::promise<manager_error_context>>();
-    build_deferred_indexes(options, [barrier](auto ctx) mutable { barrier->set_value(std::move(ctx)); });
-    return barrier->get_future();
-}
-} // namespace couchbase