userver

https://userver.tech
Admin
userver is a modern open-source asynchronous C++ framework for building microservices, services, and...
Tokens:1,330,211
Snippets:10,212
Trust Score:8.1
Update:1 month ago
Show doc for...
Tokens:
Raw
### Start Service with Static Config

Source: https://userver.tech/db/d69/md_en_2userver_2tutorial_2production__service.html

Command line execution example for starting the service with a specified static configuration file.

```bash
./samples/userver-samples-production_service --config /etc/production-service/static_config.yaml
```

--------------------------------

### start()

Source: https://userver.tech/d8/d81/classpytest__userver_1_1grpc_1_1MockserverSession.html

Starts the gRPC mock server.

```APIDOC
## start()

### Description
Starts the server. It is recommended to use the async contextmanager syntax if possible.

### Signature
`None start(self)`
```

--------------------------------

### start()

Source: https://userver.tech/d8/d81/classpytest__userver_1_1grpc_1_1MockserverSession.html

Starts the gRPC server.

```APIDOC
### start()

Starts the server.
```

--------------------------------

### Example REDIS_PUBSUB_METRICS_SETTINGS configuration

Source: https://userver.tech/d5/d11/md_en_2dynamic__configs_2REDIS__PUBSUB__METRICS__SETTINGS.html

A JSON example showing how to enable per-shard statistics.

```json
{
"per-shard-stats-enabled": true,
}
```

--------------------------------

### Start Mockserver

Source: https://userver.tech/dd/d10/grpc_2____init_____8py_source.html

Starts the gRPC server. Prefer using the async context manager syntax.

```python
async def start(self) -> None:
    await self._server.start()
```

--------------------------------

### POSTGRES_TOPOLOGY_SETTINGS Schema Example

Source: https://userver.tech/dd/da3/md_en_2dynamic__configs_2POSTGRES__TOPOLOGY__SETTINGS.html

Example configuration structure showing settings for a specific component and a default fallback.

```json
{
    // settings for a specific component
    "postgresql-orders": {
        "max_replication_lag_ms": 0,
        "disabled_replicas": ["sas-01.db.yandex.net", "vla-02.db.yandex.net"]
    },
    // settings for all other components
    "__default__": {
        "max_replication_lag_ms": 60000
    }
}
```

```json
{
// settings for a specific component
"postgresql-orders": {
"max_replication_lag_ms": 0,
"disabled_replicas": ["sas-01.db.yandex.net", "vla-02.db.yandex.net"]
},
// settings for all other components
"__default__": {
"max_replication_lag_ms": 60000
}
}
```

--------------------------------

### Register components and start the server

Source: https://userver.tech/db/db9/md_en_2userver_2tutorial_2tcp__full.html

Use MinimalServerComponentList to register handlers and components, then invoke DaemonMain to start the server.

```cpp
int main(int argc, const char* const argv[]) {
const auto component_list =
components::MinimalServerComponentList()
.Append<server::handlers::ServerMonitor>()
.Append<samples::tcp::echo::Echo>()
// Testuite components:
.Append<server::handlers::TestsControl>()
.Append<components::TestsuiteSupport>()
.Append<clients::dns::Component>()
.AppendComponentList(clients::http::ComponentList());
return utils::DaemonMain(argc, argv, component_list);
}
```

--------------------------------

### Example POSTGRES_CONNECTION_SETTINGS JSON

Source: https://userver.tech/dc/dea/md_en_2dynamic__configs_2POSTGRES__CONNECTION__SETTINGS.html

A JSON example demonstrating the structure of the default connection settings configuration.

```json
{
"__default__": {
"persistent-prepared-statements": true,
"user-types-enabled": true,
"check-user-types": false,
"max-prepared-cache-size": 5000,
"ignore-unused-query-params": false,
"recent-errors-threshold": 2
}
}
```

--------------------------------

### SCYLLA_DEFAULT_COMMAND_CONTROL Configuration Example

Source: https://userver.tech/d8/d27/md_en_2dynamic__configs_2SCYLLA__DEFAULT__COMMAND__CONTROL.html

A JSON example demonstrating how to configure specific component overrides and a default fallback for ScyllaDB queries.

```json
{
"scylla-orders": {
"request_timeout_ms": 5000,
"consistency": "one"
},
"__default__": {
"request_timeout_ms": 10000,
"consistency": "local_quorum",
"serial_consistency": "local_serial"
}
}
```

--------------------------------

### REDIS_METRICS_SETTINGS Configuration Example

Source: https://userver.tech/d6/d0e/md_en_2dynamic__configs_2REDIS__METRICS__SETTINGS.html

A JSON example showing the configuration of metric settings for a Redis instance.

```json
{
"timings-enabled": true,
"command-timings-enabled": true,
"request-sizes-enabled": true,
"reply-sizes-enabled": true
}
```

--------------------------------

### DefaultDict Configuration Example

Source: https://userver.tech/db/de5/classutils_1_1DefaultDict.html

Example of a configuration structure using a default fallback value.

```json
{
".htm": "text/html",
".html": "text/html",
"__default__": "text/plain"
}
```

--------------------------------

### Start()

Source: https://userver.tech/d2/d52/classurabbitmq_1_1ConsumerBase.html

Starts consuming messages from the broker. If the consumer is already running, this method has no effect.

```APIDOC
### void Start()

Starts consuming messages from the broker. Calling this method on a running consumer has no effect. This method does not throw; in case of initial setup failure, the library will restart the consumer in the background.
```

--------------------------------

### Service Main Entry Point

Source: https://userver.tech/d1/d00/samples_2postgres_service_2main_8cpp-example.html

Configures the component list and starts the daemon.

```cpp
int main(int argc, char* argv[]) {
const auto component_list =
components::MinimalServerComponentList()
.Append<samples_postgres_service::pg::KeyValue>()
.Append<components::Postgres>("key-value-database")
.AppendComponentList(clients::http::ComponentList())
.Append<components::TestsuiteSupport>()
.Append<server::handlers::TestsControl>()
.Append<clients::dns::Component>();
return utils::DaemonMain(argc, argv, component_list);
}
```

--------------------------------

### Initialize Server Main

Source: https://userver.tech/dc/d93/md_en_2userver_2tutorial_2tcp__service.html

Register the component and start the daemon using MinimalComponentList.

```cpp
int main(int argc, const char* const argv[]) {
const auto component_list = components::MinimalComponentList().Append<samples::tcp::Hello>();
return utils::DaemonMain(argc, argv, component_list);
}
```

--------------------------------

### Static Configuration Example

Source: https://userver.tech/d1/dff/grpc_2include_2userver_2ugrpc_2server_2middlewares_2access__log_2component_8hpp_source.html

Example configuration for the gRPC server access log component in a YAML file.

```yaml
    grpc-server-access-log:
      enabled: true
      log-level: info
      logger: grpc-access-logger
```

--------------------------------

### Main Daemon Entry Point

Source: https://userver.tech/df/daf/samples_2flatbuf_service_2main_8cpp-example.html

Registers components and starts the userver daemon.

```cpp
int main(int argc, char* argv[]) {
auto component_list =
components::MinimalServerComponentList() //
.Append<samples::fbs_handle::FbsSumEcho>() //
.Append<clients::dns::Component>() //
.AppendComponentList(clients::http::ComponentList()) //
.Append<samples::fbs_request::FbsRequest>(); //
return utils::DaemonMain(argc, argv, component_list);
}
```

--------------------------------

### Static configuration example for MultiMongo

Source: https://userver.tech/d1/dd7/mongo_2include_2userver_2storages_2mongo_2component_8hpp_source.html

Example YAML configuration for the MultiMongo component, defining connection timeouts, pool sizes, and statistical verbosity.

```yaml
multi-mongo:
  appname: userver-sample
  conn_timeout: 2s
  so_timeout: 10s
  queue_timeout: 1s
  initial_size: 16
  max_size: 128
  idle_limit: 64
  connecting_limit: 8
  local_threshold: 15ms
  stats_verbosity: terse
```

--------------------------------

### Build and run commands

Source: https://userver.tech/d4/d31/md_en_2userver_2tutorial_2postgres__service.html

Commands to compile the service and start it manually.

```bash
mkdir build_release
cd build_release
cmake -DCMAKE_BUILD_TYPE=Release ..
make userver-samples-postgres_service
```

--------------------------------

### Main Entry Point for S3 API Sample

Source: https://userver.tech/d9/d57/samples_2s3api_2main_8cpp-example.html

Initializes the component list with necessary dependencies and starts the daemon.

```cpp
#include <userver/clients/dns/component.hpp>
#include <userver/clients/http/component_list.hpp>
#include <userver/components/minimal_server_component_list.hpp>
#include <userver/server/handlers/tests_control.hpp>
#include <userver/testsuite/testsuite_support.hpp>
#include <userver/utest/using_namespace_userver.hpp>
#include <userver/utils/daemon_run.hpp>
#include <s3api_client.hpp>
int main(int argc, char* argv[]) {
const auto component_list =
components::MinimalServerComponentList()
.Append<clients::dns::Component>()
.Append<components::TestsuiteSupport>()
.Append<server::handlers::TestsControl>()
.AppendComponentList(clients::http::ComponentList())
.Append<samples::S3ApiSampleComponent>();
return utils::DaemonMain(argc, argv, component_list);
}
```

--------------------------------

### StartSession

Source: https://userver.tech/db/d0a/classydb_1_1CoordinationClient.html

Starts a new coordination session with the specified path and settings.

```APIDOC
## StartSession

### Description
Starts a new coordination session. Note that callbacks provided in TSessionSettings (OnStateChanged, OnStopped) are executed on a non-coroutine thread.

### Signature
CoordinationSession StartSession(std::string_view path, const NYdb::NCoordination::TSessionSettings &settings)
```

--------------------------------

### Example GET request response format

Source: https://userver.tech/d6/dc0/dynamic__debug__log_8hpp_source.html

The GET request returns a list of logging locations with their current status, where 1 indicates forced logging is enabled and 0 indicates it is disabled.

```text
project/src/some.cpp:13 0
project/src/some.cpp:23 0
project/src/some.cpp:42 1
project/src/some.cpp:113 0
userver/core/src/server/server.cpp:131 0
```

--------------------------------

### Main Entry Point

Source: https://userver.tech/d0/d8c/samples_2config_service_2main_8cpp-example.html

Initializes the server component list and starts the daemon.

```cpp
int main(int argc, char* argv[]) {
const auto component_list = components::MinimalServerComponentList().Append<samples::ConfigDistributor>();
return utils::DaemonMain(argc, argv, component_list);
}
```

--------------------------------

### Main entry point for HTTP caching sample

Source: https://userver.tech/d1/d3e/samples_2http_caching_2main_8cpp-example.html

Initializes the server component list with necessary dependencies and starts the daemon.

```cpp
int main(int argc, char* argv[]) {
const auto component_list =
components::MinimalServerComponentList()
.Append<samples::http_cache::HttpCachedTranslations>()
.Append<samples::http_cache::GreetUser>()
.Append<components::TestsuiteSupport>()
.Append<server::handlers::TestsControl>()
.Append<clients::dns::Component>()
.AppendComponentList(clients::http::ComponentList());
return utils::DaemonMain(argc, argv, component_list);
}
```

--------------------------------

### Manual Client Initialization

Source: https://userver.tech/dc/dcc/md_en_2userver_2component__system.html

Example of manually instantiating clients and settings for testing purposes.

```cpp
struct SettingsB{ /*...*/ };
class ClientB {
public:
ClientB(SettingsB settings);
};
struct SettingsA{ /*...*/ };
class ClientA {
public:
ClientA(ClientB& b, SettingsA settings);
};
In unit tests you could create the clients and fill the settings manually in code:
ClientB b({.path="/opt/", .timeout=15s});
ClientA a(b, {.ttl=3, .skip={"some"}});
a.DoSomething();
```

--------------------------------

### TrivialSet Deduction Guide

Source: https://userver.tech/d7/d32/trivial__map_8hpp_source.html

Deduction guide for TrivialSet.

```cpp
template <typename BuilderFunc>
TrivialSet(BuilderFunc) -> TrivialSet<BuilderFunc>;
```

--------------------------------

### Start

Source: https://userver.tech/db/dbe/classkafka_1_1ConsumerScope.html

Subscribes for configured topics and starts the consumer polling process.

```APIDOC
## void Start(Callback callback)

### Description
Subscribes for configured topics and starts the consumer polling process. The provided callback is invoked on each polled message batch.

### Parameters
- **callback** (std::function<void(MessageBatchView)>) - Required - The callback function to be invoked for each message batch.
```

--------------------------------

### Registering components in main()

Source: https://userver.tech/d6/d31/md_en_2userver_2tutorial_2digest__auth__postgres.html

Construct the component list and start the daemon, including the necessary authentication and database components.

```cpp
const auto component_list =
components::MinimalServerComponentList()
.Append<components::Postgres>("auth-database")
.Append<samples::digest_auth::Hello>()
.Append<samples::digest_auth::Hello>("handler-hello-proxy")
.Append<components::TestsuiteSupport>()
.AppendComponentList(clients::http::ComponentList())
.Append<server::handlers::TestsControl>()
.Append<clients::dns::Component>()
.Append<components::Secdist>()
.Append<components::DefaultSecdistProvider>()
.Append<server::handlers::auth::digest::AuthCheckerSettingsComponent>("auth-digest-checker-settings-proxy")
.Append<server::handlers::auth::digest::AuthCheckerSettingsComponent>();
return utils::DaemonMain(argc, argv, component_list);
```

--------------------------------

### Start

Source: https://userver.tech/d3/d39/classydb_1_1DistLockedWorker.html

Starts the distributed lock acquisition process and the associated task.

```APIDOC
### Method
void Start()
```

--------------------------------

### Static Configuration Example

Source: https://userver.tech/d1/dd7/mongo_2include_2userver_2storages_2mongo_2component_8hpp_source.html

Example YAML configuration for the MongoDB component.

```yaml
mongo-taxi:
dbalias: taxi
appname: userver-sample
conn_timeout: 2s
so_timeout: 10s
queue_timeout: 1s
initial_size: 16
max_size: 128
idle_limit: 64
connecting_limit: 8
local_threshold: 15ms
maintenance_period: 15s
stats_verbosity: terse
```

--------------------------------

### Initialize and run userver application

Source: https://userver.tech/df/d0a/main_8cpp_source.html

Configures the component list with essential services and starts the daemon using utils::DaemonMain.

```cpp
#include <userver/utest/using_namespace_userver.hpp> // IWYU pragma: keep

#include <userver/clients/dns/component.hpp>
#include <userver/clients/http/component_list.hpp>
#include <userver/components/component.hpp>
#include <userver/components/minimal_server_component_list.hpp>
#include <userver/congestion_control/component.hpp>
#include <userver/server/handlers/tests_control.hpp>
#include <userver/storages/secdist/component.hpp>
#include <userver/storages/secdist/provider_component.hpp>
#include <userver/testsuite/testsuite_support.hpp>
#include <userver/ugrpc/server/component_list.hpp>
#include <userver/ugrpc/server/health/component.hpp>
#include <userver/utils/daemon_run.hpp>

#include <userver/grpc-reflection/reflection_service_component.hpp>

int main(int argc, char* argv[]) {
 const auto component_list =
 components::MinimalServerComponentList()
 .Append<congestion_control::Component>()
 .Append<grpc_reflection::ReflectionServiceComponent>()
 .Append<components::TestsuiteSupport>()
 .Append<server::handlers::TestsControl>()
 .Append<ugrpc::server::HealthComponent>()
 .AppendComponentList(clients::http::ComponentList())
 .AppendComponentList(ugrpc::server::DefaultComponentList())
 .Append<clients::dns::Component>();
 return utils::DaemonMain(argc, argv, component_list);
}
```

--------------------------------

### CMakeLists.txt for static_service

Source: https://userver.tech/df/db8/samples_2static_service_2CMakeLists_8txt-example.html

Configures the project, finds the userver core component, and sets up the executable and testsuite.

```cmake
cmake_minimum_required(VERSION 3.14)
project(userver-samples-static_service CXX)
find_package(
userver
COMPONENTS core
REQUIRED
)
add_executable(${PROJECT_NAME} "main.cpp")
target_link_libraries(${PROJECT_NAME} userver::core)
userver_testsuite_add_simple(WORKING_DIRECTORY testsuite)
```

--------------------------------

### TimeOfDay Formatting Examples

Source: https://userver.tech/d1/d65/universal_2include_2userver_2utils_2time__of__day_8hpp_source.html

Examples of how to format TimeOfDay objects using fmt::format.

```cpp
fmt::format("{}", val)
```

```cpp
fmt:format("{:%H%M%S}", val); // will output HHMMSS without separators
```

--------------------------------

### Initialize and Start Component System

Source: https://userver.tech/db/d69/md_en_2userver_2tutorial_2production__service.html

Uses utils::DaemonMain to initialize the component system with a defined list of components and handlers.

```cpp
#include <userver/components/common_component_list.hpp>
#include <userver/components/common_server_component_list.hpp>
#include <userver/server/handlers/ping.hpp>
#include <userver/storages/secdist/component.hpp>
#include <userver/storages/secdist/provider_component.hpp>
#include <userver/utils/daemon_run.hpp>
int main(int argc, char* argv[]) {
const auto component_list =
components::ComponentList()
.AppendComponentList(components::CommonComponentList())
.AppendComponentList(components::CommonServerComponentList())
.Append<components::Secdist>()
.Append<components::DefaultSecdistProvider>()
.Append<server::handlers::Ping>()
// Put your handlers and components here
;
return utils::DaemonMain(argc, argv, component_list);
}
```

--------------------------------

### HTTP Request Example

Source: https://userver.tech/dc/d8a/md_en_2userver_2tutorial_2http__caching.html

Example curl request to the greeting endpoint and the corresponding server response.

```http
$ curl -X POST http://localhost:8089/samples/greet?username=Dear+Developer  -i
HTTP/1.1 200 OK
Date: Thu, 09 Dec 2021 17:01:44 UTC
Content-Type: text/html; charset=utf-8
X-YaRequestId: 94193f99ebf94eb58252139f2e9dace4
X-YaSpanId: 4e17e02dfa7b8322
X-YaTraceId: 306d2d54fd0543c09376a5c4bb120a88
Server: userver/2.0 (20211209085954; rv:d05d059a3)
Connection: keep-alive
Content-Length: 61
 
Привет, Dear Developer! Добро пожаловать
```

--------------------------------

### UtcStringtime Usage Example

Source: https://userver.tech/db/dec/namespaceutils_1_1datetime.html

Example demonstrating the use of UtcStringtime for parsing UTC time strings.

```cpp
const auto tp = utils::datetime::UtcStringtime("2014-03-17T02:47:07+0000");
EXPECT_EQ(utils::datetime::UtcStringtime("2014-03-17T02:47:07+0000"), tp);
```

--------------------------------

### Define Service Start Timeout

Source: https://userver.tech/dc/d2e/service_8py_source.html

Fixture to specify the maximum time in seconds allowed for the service to start.

```python
@pytest.fixture(scope='session')
def service_start_timeout() -> float:
	"""
	Returns service start timeout in seconds.

	Override this fixture to change the service start timeout.

	@ingroup userver_testsuite_fixtures
	"""

	return 100.0
```

--------------------------------

### Build and Run Commands

Source: https://userver.tech/d9/d1c/md_en_2userver_2tutorial_2kafka__service.html

Commands to build the Kafka service sample and start it with necessary environment variables.

```bash
mkdir build_release
cd build_release
cmake -DCMAKE_BUILD_TYPE=Release ..
make userver-samples-kafka_service
```

```bash
KAFKA_HOME=/etc/kafka TESTSUITE_KAFKA_CUSTOM_TOPICS=test-topic-1:1,test-topic-2:1 make start-userver-samples-kafka_service
```

--------------------------------

### Tracing Manager Configuration Example

Source: https://userver.tech/d6/dbd/manager__component_8hpp_source.html

Example YAML configuration for specifying incoming and outgoing tracing formats.

```yaml
incoming-format: ['opentelemetry', 'taxi']
new-requests-format: ['b3-alternative', 'opentelemetry']
```

--------------------------------

### Solomon JSON Format Example

Source: https://userver.tech/d4/d70/solomon_8hpp_source.html

Example structure of the Solomon JSON format used for statistics output.

```json
{
 "commonLabels": {
 "application": "some-service-name"
 },
 "metrics": [
 {
 "labels": {
 "sensor": "cpu_time_sec"
 },
 "value": 34155.69
 },
 {
 "labels": {
 "sensor": "postgresql.replication-lag.min",
 "postgresql_database": "some_pg_db",
 "postgresql_database_shard": "shard_0",
 "postgresql_cluster_host_type": "slaves",
 "postgresql_instance": "some_host:6432"
 },
 "value": 0
 },
 {
 "labels": {
 "sensor": "http.handler.in-flight",
 "http_path": "/ping",
 "http_handler": "handler-ping"
 },
 "value": 1
 },
 {
 "labels": {
 "sensor": "cache.full.time.last-update-duration-ms",
 "cache_name": "some-cache-name"
 },
 "value": 23
 }
 ]
}
```

--------------------------------

### Build and run the gRPC service

Source: https://userver.tech/d6/daa/md_en_2userver_2tutorial_2grpc__service.html

Commands to build the sample from the userver root directory and start the service.

```bash
mkdir build_release
cd build_release
cmake -DCMAKE_BUILD_TYPE=Release ..
make userver-samples-grpc_service
```

```bash
./samples/grpc_service/userver-samples-grpc_service -c </path/to/static_config.yaml> --config-vars </path/to/config_vars.yaml>
```

--------------------------------

### Constructing a ClickHouse query with ParameterStore

Source: https://userver.tech/dc/d38/classstorages_1_1clickhouse_1_1ParameterStore.html

Demonstrates how to initialize a query with placeholders and populate parameters using the PushBack method.

```cpp
storages::Query q{"SELECT {} FROM {} WHERE id = {}"};
storages::clickhouse::ParameterStore params;
params.PushBack("name");
params.PushBack("users");
params.PushBack(42);
EXPECT_NO_THROW(cluster->Execute(q, params));
```

--------------------------------

### Functional testing setup

Source: https://userver.tech/db/db9/md_en_2userver_2tutorial_2tcp__full.html

Python test setup using pytest and userver fixtures for functional verification.

```python
import asyncio
import socket
import pytest
from pytest_userver import chaos
DATA = (
b'Once upon a midnight dreary, while I pondered, weak and weary, ',
b'Over many a quaint and curious volume of forgotten lore - ',
b'While I nodded, nearly napping, suddenly there came a tapping, ',
b'As of some one gently rapping, rapping at my chamber door - ',
b'"Tis some visitor," I muttered, "tapping at my chamber door - ',
b'Only this and nothing more.",
)
DATA_LENGTH = sum(len(x) for x in DATA)
```

--------------------------------

### Main entry point for a production service

Source: https://userver.tech/d2/d94/samples_2production_service_2main_8cpp-example.html

Initializes the component list with common server components, secdist, and a ping handler before starting the daemon.

```cpp
#include <userver/utest/using_namespace_userver.hpp>
#include <userver/components/common_component_list.hpp>
#include <userver/components/common_server_component_list.hpp>
#include <userver/server/handlers/ping.hpp>
#include <userver/storages/secdist/component.hpp>
#include <userver/storages/secdist/provider_component.hpp>
#include <userver/utils/daemon_run.hpp>
int main(int argc, char* argv[]) {
const auto component_list =
components::ComponentList()
.AppendComponentList(components::CommonComponentList())
.AppendComponentList(components::CommonServerComponentList())
.Append<components::Secdist>()
.Append<components::DefaultSecdistProvider>()
.Append<server::handlers::Ping>()
// Put your handlers and components here
;
return utils::DaemonMain(argc, argv, component_list);
}
```

--------------------------------

### Configure and start the Redis service

Source: https://userver.tech/d3/da2/md_en_2userver_2tutorial_2redis__service.html

Registers the Redis component and other necessary services into the component list before starting the daemon.

```cpp
int main(int argc, char* argv[]) {
const auto component_list =
components::MinimalServerComponentList()
.Append<samples::redis::KeyValue>()
.Append<samples::redis::EvalSha>()
.Append<components::Secdist>()
.Append<components::DefaultSecdistProvider>()
.Append<components::Redis>("key-value-database")
.Append<components::TestsuiteSupport>()
.Append<clients::dns::Component>();
return utils::DaemonMain(argc, argv, component_list);
}
```

--------------------------------

### Hello Service Main Function

Source: https://userver.tech/d5/d77/samples_2hello_service_2main_8cpp-example.html

Initializes the server component list with the HelloHandler and starts the daemon process.

```cpp
#include <userver/components/minimal_server_component_list.hpp>
#include <userver/utils/daemon_run.hpp>
// Note: this is for the purposes of tests/samples only
#include <userver/utest/using_namespace_userver.hpp>
#include <hello_handler.hpp>
int main(int argc, char* argv[]) {
auto component_list = components::MinimalServerComponentList().Append<samples::hello::HelloHandler>();
return utils::DaemonMain(argc, argv, component_list);
}
```

--------------------------------

### Static Service Implementation

Source: https://userver.tech/d9/dfb/samples_2static_service_2main_8cpp-example.html

A complete example showing a custom JSON handler and the main entry point for a userver-based service.

```cpp
#include <userver/utest/using_namespace_userver.hpp>
#include <userver/components/fs_cache.hpp>
#include <userver/components/minimal_server_component_list.hpp>
#include <userver/concurrent/variable.hpp>
#include <userver/formats/serialize/common_containers.hpp>
#include <userver/server/handlers/http_handler_json_base.hpp>
#include <userver/server/handlers/http_handler_static.hpp>
#include <userver/utils/daemon_run.hpp>
struct Message {
std::string name;
std::string message;
};
Message Parse(formats::json::Value json, formats::parse::To<Message>) {
Message result;
result.name = json["name"].As<std::string>();
result.message = json["message"].As<std::string>();
return result;
}
formats::json::Value Serialize(const Message& value, formats::serialize::To<formats::json::Value>) {
formats::json::ValueBuilder json;
json["name"] = value.name;
json["message"] = value.message;
return json.ExtractValue();
}
class MessagesHandler final : public server::handlers::HttpHandlerJsonBase {
public:
using HttpHandlerJsonBase::HttpHandlerJsonBase;
Value HandleRequestJsonThrow(const HttpRequest& request, const Value& json, RequestContext&) const override {
if (request.GetMethod() == server::http::HttpMethod::kPost) {
auto message = json.As<Message>();
auto locked_data = messages_.Lock();
locked_data->push_back(std::move(message));
return {};
}
std::vector<Message> snapshot;
{
auto locked_data = messages_.Lock();
snapshot = *locked_data;
}
return formats::json::ValueBuilder(snapshot).ExtractValue();
}
private:
mutable concurrent::Variable<std::vector<Message>> messages_;
};
int main(int argc, char* argv[]) {
const auto component_list =
components::MinimalServerComponentList()
.Append<MessagesHandler>("handler-messages")
.Append<components::FsCache>("fs-cache-main")
.Append<server::handlers::HttpHandlerStatic>();
return utils::DaemonMain(argc, argv, component_list);
}
```

--------------------------------

### REDIS_COMMANDS_BUFFERING_SETTINGS Schema Example

Source: https://userver.tech/d2/d11/md_en_2dynamic__configs_2REDIS__COMMANDS__BUFFERING__SETTINGS.html

Example JSON configuration for enabling Redis command buffering with a threshold and timer interval.

```json
{
  "buffering_enabled": true,
  "commands_buffering_threshold": 10,
  "watch_command_timer_interval_us": 1000
}
```

```json
{
"buffering_enabled": true,
"commands_buffering_threshold": 10,
"watch_command_timer_interval_us": 1000
}
```

--------------------------------

### Create a Simple HTTP Service with Database Access

Source: https://userver.tech/index.html

Demonstrates a basic HTTP service using userver that handles requests to /kv and queries a PostgreSQL database.

```cpp
#include <userver/easy.hpp>

// schemas::KeyRequest and parsers+serializers generated from JSON schema
#include "schemas/key_value.hpp"

int main(int argc, char* argv[]) {
    using namespace userver;

    easy::HttpWith<easy::PgDep>(argc, argv)
        // Handles multiple HTTP requests to `/kv` URL concurrently
        .Get("/kv", [](schemas::KeyRequest&& request, const easy::PgDep& dep) {
            // Asynchronous execution of the SQL query in transaction. Current thread
            // handles other requests while the response from the DB is being received:
            auto res = dep.pg().Execute(
                storages::postgres::ClusterHostType::kSlave,
                // Query is converted into a prepared statement. Subsequent requests
                // send only parameters in a binary form and meta information is
                // discarded on the DB side, significantly saving network bandwidth.
                "SELECT value FROM key_value_table WHERE key=$1", request.key
            );

            return schemas::KeyValue{
                .key=std::move(request.key),
                .value=res[0][0].As<std::string>(),
            };
        });
}
```

--------------------------------

### Retrieve data via HTTP GET

Source: https://userver.tech/dc/d8a/md_en_2userver_2tutorial_2http__caching.html

Performs a standard HTTP GET request with retries and timeout settings.

```cpp
formats::json::Value HttpCachedTranslations::GetAllData() const {
auto response =
http_client_.CreateRequest()
.get(translations_url_) // HTTP GET translations_url_ URL
.retry(2) // retry once in case of error
.timeout(std::chrono::milliseconds{500})
.perform(); // start performing the request
response->raise_for_status();
return formats::json::FromString(response->body_view());
}
```

--------------------------------

### Example Configuration JSON

Source: https://userver.tech/d4/d7a/md_en_2dynamic__configs_2POSTGRES__QUERIES__COMMAND__CONTROL.html

A sample JSON configuration object demonstrating how to set timeouts for specific query names.

```json
{
"cleanup_processed_data": {
"network_timeout_ms": 92000,
"statement_timeout_ms": 90000
},
"select_recent_users": {
"network_timeout_ms": 70,
"statement_timeout_ms": 30
}
}
```

--------------------------------

### Install Servicer Mock

Source: https://userver.tech/dd/d10/grpc_2____init_____8py_source.html

Installs a mock handler for a given gRPC servicer, allowing interception of service methods.

```python
base_servicer_classes = [cls for cls in inspect.getmro(type(servicer)) if _is_servicer_class(cls)]
if not base_servicer_classes:
raise ValueError(f"Given object's type ({type(servicer)}) is not inherited from any grpc *Servicer class")
proxy = _MockProxy(servicer)
for servicer_class in base_servicer_classes:
mock = self._get_service_mock(servicer_class)
for python_method_name in mock.known_methods:
if _get_class_that_defined_method(type(servicer), python_method_name) not in base_servicer_classes:
handler_func: types.MethodType = getattr(servicer, python_method_name)
callqueue = mock.install_handler(python_method_name, token=self._token)(handler_func)
object.__setattr__(proxy, python_method_name, callqueue)
return typing.cast(Servicer, proxy)
```

--------------------------------

### Easy PG Service Template Implementation

Source: https://userver.tech/dc/d0d/samples_2easy_25_pg_service_template_2src_2main_8cpp-example.html

A complete example showing a custom component, dependency management, and a main function using the easy library.

```cpp
#include <userver/utest/using_namespace_userver.hpp> // Note: this is for the purposes of samples only
#include <userver/easy.hpp>
#include <userver/yaml_config/merge_schemas.hpp>
#include <userver/clients/http/component.hpp>
#include <userver/components/component_context.hpp>
class ActionClient : public components::ComponentBase {
public:
static constexpr std::string_view kName = "action-client";
ActionClient(const components::ComponentConfig& config, const components::ComponentContext& context)
: ComponentBase{config, context},
service_url_(config["service-url"].As<std::string>()),
http_client_(context.FindComponent<components::HttpClient>().GetHttpClient())
{}
auto CreateHttpRequest(std::string action) const {
return http_client_.CreateRequest().url(service_url_).post().data(std::move(action)).perform();
}
static yaml_config::Schema GetStaticConfigSchema() {
return yaml_config::MergeSchemas<components::ComponentBase>(R"(
type: object
description: My dependencies schema
additionalProperties: false
properties:
service-url:
type: string
description: URL of the service to send the actions to
)");
}
private:
const std::string service_url_;
clients::http::Client& http_client_;
};
class ActionDep {
public:
explicit ActionDep(const components::ComponentContext& config)
: component_{config.FindComponent<ActionClient>()}
{}
auto CreateActionRequest(std::string action) const { return component_.CreateHttpRequest(std::move(action)); }
static void RegisterOn(easy::HttpBase& app) {
app.TryAddComponent<ActionClient>(ActionClient::kName, "service-url: http://some-service.example/v1/action");
easy::HttpDep::RegisterOn(app);
}
private:
ActionClient& component_;
};
int main(int argc, char* argv[]) {
using Deps = easy::Dependencies<ActionDep, easy::PgDep>;
easy::HttpWith<Deps>(argc, argv)
.DefaultContentType(http::content_type::kTextPlain)
.Post("/log", [](const server::http::HttpRequest& req, const Deps& deps) {
const auto& action = req.GetArg("action");
deps.pg().Execute(
storages::postgres::ClusterHostType::kMaster,
"INSERT INTO events_table(action) VALUES($1)",
action
);
return deps.CreateActionRequest(action)->body();
});
}
```

--------------------------------

### Starting a PeriodicTask in a Component

Source: https://userver.tech/d7/dc4/md_en_2userver_2periodics.html

Demonstrates initializing and starting a periodic task within a component constructor, including testsuite registration.

```cpp
Component::Component(...)
{
std::chrono::seconds interval{40}; // every 40 seconds
PeriodicTask::Settings settings{interval};
syncer_.Start("task_name", settings, [this]{ DoSomeWork(); });
// Register itself in testsuite
periodic_task_.RegisterInTestsuite(
context.FindComponent<::components::TestsuiteSupport>()
.GetPeriodicTaskControl());
}
```

--------------------------------

### Update CMake environment setup

Source: https://userver.tech/dd/d6f/md_en_2userver_2roadmap__and__changelog__v1.html

Shows the transition from the old manual inclusion method to the new userver_setup_environment function.

```cmake
include(third_party/userver/cmake/SetupEnvironment.cmake)
add_subdirectory(third_party/userver)
```

```cmake
add_subdirectory(third_party/userver)
userver_setup_environment()
```

--------------------------------

### Retrieve incremental data via HTTP GET

Source: https://userver.tech/dc/d8a/md_en_2userver_2tutorial_2http__caching.html

Performs an HTTP GET request with a query parameter for incremental updates.

```cpp
formats::json::Value HttpCachedTranslations::GetUpdatedData() const {
const auto url = http::MakeUrl(translations_url_, {{"last_update", last_update_remote_}});
auto response = http_client_.CreateRequest().get(url).retry(2).timeout(std::chrono::milliseconds{500}).perform();
response->raise_for_status();
return formats::json::FromString(response->body_view());
}
```

--------------------------------

### ScyllaDB Service Main Includes

Source: https://userver.tech/d3/d66/samples_2scylla_service_2src_2main_8cpp-example.html

Initial includes and namespace setup for the ScyllaDB service sample application.

```cpp
#include <chrono>
#include <cstddef>
#include <cstdint>
#include <string>
#include <string_view>
#include <utility>
#include <vector>
#include <fmt/format.h>
#include <userver/clients/dns/component.hpp>
#include <userver/components/component.hpp>
#include <userver/components/minimal_server_component_list.hpp>
#include <userver/formats/json/inline.hpp>
#include <userver/formats/json/value.hpp>
#include <userver/formats/json/value_builder.hpp>
#include <userver/server/handlers/http_handler_base.hpp>
#include <userver/storages/scylla/component.hpp>
#include <userver/storages/scylla/operations.hpp>
#include <userver/storages/scylla/session.hpp>
#include <userver/storages/secdist/component.hpp>
#include <userver/storages/secdist/provider_component.hpp>
#include <userver/utest/using_namespace_userver.hpp>
#include <userver/utils/daemon_run.hpp>
#include "helpers.hpp"
namespace samples::scylladb {
namespace {
```

--------------------------------

### Initialize and Start Consumer in Component

Source: https://userver.tech/d9/d1c/md_en_2userver_2tutorial_2kafka__service.html

Retrieve the consumer instance and start asynchronous processing with a callback for message handling and offset committing.

```cpp
ConsumerHandler::ConsumerHandler(const components::ComponentConfig& config, const components::ComponentContext& context)
: components::ComponentBase{config, context},
consumer_{context.FindComponent<kafka::ConsumerComponent>().GetConsumer()}
{
consumer_.Start([this](kafka::MessageBatchView messages) {
Consume(messages);
consumer_.AsyncCommit();
});
}
```

--------------------------------

### Instantiate and use ClusterPgClient

Source: https://userver.tech/d6/de0/md_en_2userver_2sql__files.html

Demonstrates initializing a ClusterPgClient from a component context and executing a select query.

```cpp
KeyValue::KeyValue(const components::ComponentConfig& config, const components::ComponentContext& context)
: HttpHandlerBase(config, context),
pg_client_(context.FindComponent<components::Postgres>("key-value-database").GetCluster())
{}
std::string KeyValue::GetValue(std::string_view key, const server::http::HttpRequest& request) const {
const auto rows = pg_client_.SelectValue(storages::postgres::ClusterHostType::kSlave, std::string{key});
if (rows.empty() || !rows.front().has_value()) {
request.SetResponseStatus(server::http::HttpStatus::kNotFound);
return {};
}
return *rows.front();
}
```

--------------------------------

### YDB Functional Test Examples

Source: https://userver.tech/d9/d0b/md_en_2userver_2tutorial_2ydb__service.html

Examples of using service_client, ydb, and testpoint fixtures to verify YDB operations and service responses.

```python
async def test_upsert_row(service_client, ydb):
response = await service_client.post(
'ydb/upsert-row',
json={
'id': 'id-upsert',
'name': 'name-upsert',
'service': 'srv',
'channel': 123,
},
)
assert response.status_code == 200
assert 'application/json' in response.headers['Content-Type']
assert response.json() == {}
cursor = ydb.execute('SELECT * FROM events WHERE id = "id-upsert"')
assert len(cursor) == 1
assert len(cursor[0].rows) == 1
row = cursor[0].rows[0]
assert row.pop('created') > 0
assert row == {
'id': b'id-upsert',
'name': 'name-upsert',
'service': b'srv',
'channel': 123,
'state': None,
}
```

```python
@pytest.mark.ydb(files=['fill_events.sql'])
async def test_select_rows(service_client):
response = await service_client.post(
'ydb/select-rows',
json={
'service': 'srv',
'channels': [1, 2, 3],
'created': '2019-10-30T11:20:00+00:00',
},
)
assert response.status_code == 200
assert 'application/json' in response.headers['Content-Type']
assert response.json() == {
'items': [
{
'id': 'id-1',
'name': 'name-1',
'service': 'srv',
'channel': 1,
'created': '2019-10-31T11:20:00+00:00',
},
],
}
```

```python
@pytest.mark.ydb(files=['fill_orders.sql'])
async def test_bson_reading(service_client):
response = await service_client.post(
'ydb/bson-reading',
params={'id': 'id1'},
)
assert response.status_code == 200
raw_bson = bson.BSON(response.content).decode()
res = raw_bson['doc']
assert res == {
'h': {'e': {'l': {'l': '0'}}},
'w': {'o': {'r': {'l': 'd'}}},
}
```

```python
async def test_ok(service_client, ydb):
```

--------------------------------

### Main Entry Point for Chaos Handler

Source: https://userver.tech/d6/d91/postgresql_2functional_tests_2basic_chaos_2postgres_service_8cpp-example.html

Initializes the server components and starts the daemon with the PostgresHandler.

```cpp
int main(int argc, char* argv[]) {
const auto component_list =
components::MinimalServerComponentList()
.AppendComponentList(USERVER_NAMESPACE::dynamic_config::updater::ComponentList())
.Append<chaos::PostgresHandler>()
.Append<server::handlers::ServerMonitor>()
.AppendComponentList(clients::http::ComponentList())
.Append<components::Postgres>("key-value-database")
.Append<components::TestsuiteSupport>()
.Append<server::handlers::TestsControl>()
.Append<clients::dns::Component>();
return utils::DaemonMain(argc, argv, component_list);
}
```

--------------------------------

### Define multiline logging macro example

Source: https://userver.tech/d1/d57/md_en_2dynamic__configs_2USERVER__LOG__DYNAMIC__DEBUG.html

Example of a multiline logging macro where line numbering behavior may vary between compilers.

```cpp
#299
#300    LOG_INFO(
#301        "Do not send '{}', instead send the '{}' command",
#302        incoming,
#303        correct_data
#304    );
#305
```

--------------------------------

### Creating a RichStatus with ResourceInfo

Source: https://userver.tech/d3/d30/structugrpc_1_1ResourceInfo.html

Demonstrates how to initialize a ugrpc::RichStatus object containing a ResourceInfo detail.

```cpp
ugrpc::RichStatus status{
grpc::StatusCode::NOT_FOUND,
"Resource not found",
ugrpc::ResourceInfo{
"storage.bucket",
"projects/my-project/buckets/my-bucket",
"user:alice@example.com",
"Private user bucket",
},
};
```

--------------------------------

### Build and Run Commands

Source: https://userver.tech/dc/d8a/md_en_2userver_2tutorial_2http__caching.html

Commands to build the HTTP caching sample from the userver root directory.

```bash
mkdir build_release
cd build_release
cmake -DCMAKE_BUILD_TYPE=Release ..
make userver-samples-http_caching
```

--------------------------------

### Static YAML Configuration Example

Source: https://userver.tech/df/d08/postgresql_2include_2userver_2storages_2postgres_2component_8hpp_source.html

Example configuration for the PostgreSQL component in a YAML file. Requires specifying either dbalias or dbconnection and a blocking_task_processor.

```yaml
postgres-taxi:
  dbalias: taxi
  blocking_task_processor: task-processor-name
  max_replication_lag: 60s
  min_pool_size: 4
  max_pool_size: 15
  max_queue_size: 200
  max_statement_metrics: 50
```

--------------------------------

### PostgreSQL Connection Pool Settings Schema Example

Source: https://userver.tech/d0/db5/md_en_2dynamic__configs_2POSTGRES__CONNECTION__POOL__SETTINGS.html

Example configuration structure for defining pool settings for specific components and a default fallback.

```json
{
    // Settings for a specific component.
    "postgresql-orders": {
        "min_pool_size": 8,
        "max_pool_size": 50,
        "max_queue_size": 200,
        "connecting_limit": 10,
        "connecting_interval_ms": 200
    },
    // All other components.
    "__default__": {
        "min_pool_size": 4,
        "max_pool_size": 15,
        "max_queue_size": 200,
        "connecting_limit": 8,
        "connecting_interval_ms": 500
    }
}
```

```json
{
// Settings for a specific component.
"postgresql-orders": {
"min_pool_size": 8,
"max_pool_size": 50,
"max_queue_size": 200,
"connecting_limit": 10,
"connecting_interval_ms": 200
},
// All other components.
"__default__": {
"min_pool_size": 4,
"max_pool_size": 15,
"max_queue_size": 200,
"connecting_limit": 8,
"connecting_interval_ms": 500
}
}
```

--------------------------------

### Begin Transaction

Source: https://userver.tech/d0/d3d/mysql_2include_2userver_2storages_2mysql_2cluster_8hpp_source.html

Starts a transaction on a specified host type, optionally with custom CommandControl.

```cpp
Transaction Begin(ClusterHostType host_type) const;
```

```cpp
Transaction Begin(OptionalCommandControl command_control, ClusterHostType host_type) const;
```

--------------------------------

### Instantiate S3 Client

Source: https://userver.tech/d3/d34/md_en_2userver_2tutorial_2s3api.html

Create the S3 client by configuring the connection, setting up authentication, and initializing the client instance.

```cpp
s3api::ClientPtr S3ApiSampleComponent::GetClient() {
// Create connection settings
auto connection_cfg = s3api::ConnectionCfg(
std::chrono::milliseconds{100}, /* timeout */
2, /* retries */
std::nullopt /* proxy */
);
// Create connection object
auto s3_connection = s3api::MakeS3Connection(http_client_, s3api::S3ConnectionType::kHttps, url_, connection_cfg);
// Create authorizer.
auto auth = std::make_shared<s3api::authenticators::AccessKey>("my-access-key", s3api::Secret("my-secret-key"));
// create and return client
return s3api::GetS3Client(std::move(s3_connection), std::move(auth), "mybucket");
}
```

--------------------------------

### Get()

Source: https://userver.tech/d7/dcd/classgrpc__proto__structs_1_1client_1_1StreamReadFuture.html

Await the response from the stream.

```APIDOC
### std::optional< StructsResponse > Get()

Await and return the response from the stream.
```

--------------------------------

### utils::AsyncBackground

Source: https://userver.tech/dc/db7/group__userver__concurrency.html

Starts an asynchronous task without propagating engine::TaskInheritedVariable. tracing::Span and baggage::Baggage are inherited. Task execution may be cancelled before the function starts execution in case of engine::TaskProcessor overload.

```APIDOC
## utils::AsyncBackground

### Signature
`template<typename Function, typename... Args> auto utils::AsyncBackground(std::string name, engine::TaskProcessor& task_processor, Function&& f, Args&&... args)`

### Description
Starts an asynchronous task without propagating engine::TaskInheritedVariable. tracing::Span and baggage::Baggage are inherited. Typically used from a request handler to launch tasks that outlive the request and do not affect its completion.

### Parameters
- **name** (std::string) - The name of the task.
- **task_processor** (engine::TaskProcessor&) - The task processor to run the task on.
- **f** (Function&&) - The function to execute.
- **args** (Args&&...) - Arguments to pass to the function.
```

--------------------------------

### Build and Run Commands

Source: https://userver.tech/d2/d6d/md_en_2userver_2tutorial_2static__content.html

Commands to build the static service from the userver root directory.

```bash
mkdir build_release
cd build_release
cmake -DCMAKE_BUILD_TYPE=Release ..
make userver-samples-static_service
```

--------------------------------

### SpawnTask

Source: https://userver.tech/dd/dc0/classtestsuite_1_1TestsuiteTasks.html

Asynchronously starts a registered task.

```APIDOC
## std::string SpawnTask(const std::string &name)

### Description
Starts a registered task asynchronously and returns a unique task identifier.

### Returns
- **task_id** (std::string) - The identifier for the spawned task.
```

--------------------------------

### Initializing StorageMock from JSON

Source: https://userver.tech/d6/dec/classdynamic__config_1_1StorageMock.html

Shows how to populate StorageMock using a JSON object for configuration values.

```cpp
const auto kJson = formats::json::FromString(R"( {"foo": 42, "bar": "what"} )");
UTEST(DynamicConfig, FromJson) {
const dynamic_config::StorageMock storage{
{kDummyConfig, kJson},
{kIntConfig, 5},
};
const auto config = storage.GetSnapshot();
EXPECT_EQ(config[kDummyConfig].foo, 42);
EXPECT_EQ(config[kDummyConfig].bar, "what");
EXPECT_EQ(config[kIntConfig], 5);
}
```

--------------------------------

### EarlyStartPeriodicUpdates

Source: https://userver.tech/d1/d20/cache__update__trait_8hpp_source.html

Starts periodic updates immediately.

```APIDOC
## void EarlyStartPeriodicUpdates(utils::Flags<Flag> flags)

### Description
Triggers the start of periodic updates immediately, rather than waiting for the default initialization sequence.

### Parameters
- **flags** (utils::Flags<Flag>) - The flags to use for starting the updates.
```

--------------------------------

### Begin

Source: https://userver.tech/d1/d08/classstorages_1_1mysql_1_1Cluster.html

Begins a transaction on a specified host type.

```APIDOC
## Begin

### Description
Begins a transaction on the specified host type. The deadline is transaction-wide.

### Signature
`Transaction Begin(ClusterHostType host_type) const`
`Transaction Begin(OptionalCommandControl command_control, ClusterHostType host_type) const`

### Parameters
- **command_control** (OptionalCommandControl) - Optional request QOS overrides.
- **host_type** (ClusterHostType) - Host type on which to execute the transaction.
```

--------------------------------

### Retrieve Minimal Server Component List

Source: https://userver.tech/db/dbf/minimal__server__component__list_8hpp_source.html

Returns a ComponentList containing the minimal set of components required to start a basic HTTP server.

```cpp
#pragma once

/// @file userver/components/minimal_server_component_list.hpp
/// @brief @copybrief components::MinimalServerComponentList()

#include <userver/components/component_list.hpp>

USERVER_NAMESPACE_BEGIN

namespace components {

/// @ingroup userver_components
///
/// @brief Returns a list of components to start a basic HTTP server.
///
/// The list contains:
/// * all of components::MinimalComponentList
/// * components::Server
/// * components::AuthCheckerSettings
ComponentList MinimalServerComponentList();

} // namespace components

USERVER_NAMESPACE_END
```

--------------------------------

### Get()

Source: https://userver.tech/d9/d80/classrcu_1_1WritablePtr.html

Retrieves a pointer to the underlying data.

```APIDOC
## T* Get()

### Description
Returns a pointer to the object being modified.
```

--------------------------------

### BackgroundTaskStorage Usage Synopsis

Source: https://userver.tech/d5/dbc/background__task__storage_8hpp_source.html

Basic example demonstrating the initialization and usage of BackgroundTaskStorage.

```cpp
@snippet concurrent/background_task_storage_test.cpp Sample
```

--------------------------------

### Get()

Source: https://userver.tech/d9/d80/classrcu_1_1WritablePtr.html

Accesses the underlying value for modification.

```APIDOC
### T* Get() &
### T* Get() &&

Returns a pointer to the value being modified. This allows direct mutation of the object.
```

--------------------------------

### Get()

Source: https://userver.tech/d4/dde/classcache_1_1NWayLRU.html

Retrieves a value from the cache by its key.

```APIDOC
## Method: Get(const T& key)

### Description
Returns the cached value associated with the provided key if it exists in the cache; otherwise, returns std::nullopt.

### Parameters
- **key** (const T&) - The key to look up in the cache.

### Returns
- **std::optional<U>** - The cached value if present, otherwise std::nullopt.
```

--------------------------------

### components::CommonServerComponentList()

Source: https://userver.tech/dc/dec/common__server__component__list_8hpp.html

Returns the most common list of components to start a fully functional server.

```APIDOC
## components::CommonServerComponentList()

### Description
Returns the most common list of components to start a fully functional server. This function is used to initialize the standard set of components required for a userver-based service.

### Signature
`components::ComponentList components::CommonServerComponentList()`

### Returns
- **ComponentList** - A collection of components configured for a standard server environment.
```

--------------------------------

### Mockserver.install_servicer

Source: https://userver.tech/dd/d10/grpc_2____init_____8py_source.html

Installs a servicer instance as a mock.

```APIDOC
## install_servicer(servicer)

### Description
Installs as a mock `servicer`, the class of which should inherit from a generated `*Servicer` class.
```
Tokens:
Raw