Method request_service

implementation/routing/src/routing_manager_client.cpp:367–400

}

void routing_manager_client::request_service([[maybe_unused]] client_t _client, service_t _service, instance_t _instance,
                                             major_version_t _major, minor_version_t _minor) {

    {
        size_t request_debouncing_time = configuration_->get_request_debounce_time(host_->get_name());
        protocol::service request = {_service, _instance, _major, _minor};
        std::scoped_lock its_lock{consumer_mutex_};
        if (requests_.contains(request) || requests_to_debounce_.contains(request)) {
            return;
        }
        if (!request_debouncing_time) {
            // order matters:
            // 1. Ensure that the set contains this request
            // 2. Try to send if we are registered
            // If exchanged the sending after the registration is going to race with
            // the subsequent logic.
            requests_.insert(request);
            if (state_machine_->state() == routing_client_state_e::ST_REGISTERED) {
                std::set<protocol::service> requests;
                requests.insert(request);
                send_request_services(requests);
            }
        } else {
            requests_to_debounce_.insert(request);
            if (!request_debounce_timer_running_) {
                request_debounce_timer_running_ = true;
                request_debounce_timer_.expires_after(std::chrono::milliseconds(request_debouncing_time));
                request_debounce_timer_.async_wait(std::bind(&routing_manager_client::request_debounce_timeout_cbk,
                                                             std::dynamic_pointer_cast<routing_manager_client>(shared_from_this()),
                                                             std::placeholders::_1));
            }
        }
    }
}

void routing_manager_client::release_service(client_t _client, service_t _service, instance_t _instance) {
    bool pending(false);