service_helper.hpp

#pragma once
 
#include <type_traits>
 
#include <boost/config.hpp>
#include <grpcpp/support/status.h>
 
#include <viam/sdk/common/grpc_fwd.hpp>
 
#include <viam/sdk/resource/resource_server_base.hpp>
#include <viam/sdk/rpc/private/grpc_context_observer.hpp>
#include <viam/sdk/tracing/private/span_guard.hpp>
 
namespace viam {
namespace sdk {
 
class ServiceHelperBase {
   public:
    ::grpc::Status fail(::grpc::StatusCode code, const char* message) const noexcept;
 
    ::grpc::Status failNoContext() const noexcept;
 
    ::grpc::Status failNoRequest() const noexcept;
 
    ::grpc::Status failNoResource(const std::string& name) const noexcept;
 
    ::grpc::Status failStdException(const std::exception& xcp) const noexcept;
 
    ::grpc::Status failUnknownException() const noexcept;
 
   protected:
    explicit ServiceHelperBase(const char* method) noexcept : method_{method} {}
 
    const char* method_name() const noexcept {
        return method_;
    }
 
   private:
    const char* method_;
};
 
template <typename ServiceType, typename RequestType>
class ServiceHelper : public ServiceHelperBase {
   public:
    ServiceHelper(const char* method,
                  ResourceServer* rs,
                  const GrpcServerContext* context,
                  RequestType* request) noexcept
        : ServiceHelperBase{method}, rs_{rs}, context_{context}, request_{request} {};
 
    template <typename Callable>
    BOOST_ATTRIBUTE_NODISCARD ::grpc::Status operator()(Callable&& callable) const noexcept try {
        if (!context_) {
            return failNoContext();
        }
        if (!request_) {
            return failNoRequest();
        }
        const auto resource = rs_->resource_manager()->resource<ServiceType>(request_->name());
        if (!resource) {
            return failNoResource(request_->name());
        }
        const GrpcContextObserver::Enable enable{*context_};
        impl::ServerSpanGuard span_guard{context_, method_name()};
 
        // This is kind of hideous but automates the process of recording exception
        // info in the active span in case of failure.
        try {
            return span_guard.commit(
                invoke_(std::forward<Callable>(callable), std::move(resource)));
        } catch (const std::exception& xcp) {
            span_guard.record_exception(xcp);
            throw;
        } catch (...) {
            span_guard.record_unknown_exception();
            throw;
        }
    } catch (const std::exception& xcp) {
        return failStdException(xcp);
    } catch (...) {
        return failUnknownException();
    }
 
    auto getExtra() const {
        return request_->has_extra() ? from_proto(request_->extra()) : ProtoStruct{};
    }
 
   private:
#if __cplusplus >= 201703L
    template <typename Callable, typename... Args>
    using is_void_result = std::is_void<std::invoke_result_t<Callable, Args...>>;
#else
    template <typename Callable, typename... Args>
    using is_void_result = std::is_void<std::result_of_t<Callable(Args...)>>;
#endif
 
    // Implementation of `invoke_` for a Callable returning non-void,
    // presumably an error return, which we return as a
    // ::grpc::Status.
    template <typename Callable,
              typename ResourcePtrType,
              std::enable_if_t<!is_void_result<Callable, ServiceHelper&, ResourcePtrType&&>::value,
                               bool> = true>
    ::grpc::Status invoke_(Callable&& callable, ResourcePtrType&& resource) const {
        return std::forward<Callable>(callable)(*this, std::forward<ResourcePtrType>(resource));
    }
 
    // Implementation of `invoke_` for a Callable returning void,
    // which is therefore either non-failing or communicates errors by
    // throwing exceptions. We return an OK status automatically.
    template <typename Callable,
              typename ResourcePtrType,
              std::enable_if_t<is_void_result<Callable, ServiceHelper&, ResourcePtrType&&>::value,
                               bool> = true>
    ::grpc::Status invoke_(Callable&& callable, ResourcePtrType&& resource) const {
        std::forward<Callable>(callable)(*this, std::forward<ResourcePtrType>(resource));
        return {};
    }
 
    ResourceServer* rs_;
    const GrpcServerContext* context_;
    RequestType* request_;
};
 
template <typename ServiceType, typename RequestType>
BOOST_ATTRIBUTE_NODISCARD auto make_service_helper(const char* method,
                                                   ResourceServer* rs,
                                                   GrpcServerContext* context,
                                                   RequestType* request) {
    return ServiceHelper<ServiceType, RequestType>{method, rs, context, request};
}
 
}  // namespace sdk
}  // namespace viam