RSDK-6374 Add wrappers for the generic service (viamrobotics#203)

src/viam/api/CMakeLists.txt

@@ -192,6 +192,10 @@ if (VIAMCPPSDK_USE_DYNAMIC_PROTOS)
     ${PROTO_GEN_DIR}/robot/v1/robot.grpc.pb.h
     ${PROTO_GEN_DIR}/robot/v1/robot.pb.cc
     ${PROTO_GEN_DIR}/robot/v1/robot.pb.h
+    ${PROTO_GEN_DIR}/service/generic/v1/generic.grpc.pb.cc
+    ${PROTO_GEN_DIR}/service/generic/v1/generic.grpc.pb.h
+    ${PROTO_GEN_DIR}/service/generic/v1/generic.pb.cc
+    ${PROTO_GEN_DIR}/service/generic/v1/generic.pb.h
     ${PROTO_GEN_DIR}/service/mlmodel/v1/mlmodel.grpc.pb.cc
     ${PROTO_GEN_DIR}/service/mlmodel/v1/mlmodel.grpc.pb.h
     ${PROTO_GEN_DIR}/service/mlmodel/v1/mlmodel.pb.cc
@@ -287,6 +291,8 @@ target_sources(viamapi
     ${PROTO_GEN_DIR}/module/v1/module.pb.cc
     ${PROTO_GEN_DIR}/robot/v1/robot.grpc.pb.cc
     ${PROTO_GEN_DIR}/robot/v1/robot.pb.cc
+    ${PROTO_GEN_DIR}/service/generic/v1/generic.grpc.pb.cc
+    ${PROTO_GEN_DIR}/service/generic/v1/generic.pb.cc
     ${PROTO_GEN_DIR}/service/mlmodel/v1/mlmodel.grpc.pb.cc
     ${PROTO_GEN_DIR}/service/mlmodel/v1/mlmodel.pb.cc
     ${PROTO_GEN_DIR}/service/motion/v1/motion.grpc.pb.cc
@@ -332,6 +338,8 @@ target_sources(viamapi
       ${PROTO_GEN_DIR}/../../viam/api/robot/v1/robot.grpc.pb.h
       ${PROTO_GEN_DIR}/../../viam/api/robot/v1/robot.pb.h
       ${PROTO_GEN_DIR}/../../viam/api/tagger/v1/tagger.grpc.pb.h
+      ${PROTO_GEN_DIR}/../../viam/api/service/generic/v1/generic.grpc.pb.h
+      ${PROTO_GEN_DIR}/../../viam/api/service/generic/v1/generic.pb.h
       ${PROTO_GEN_DIR}/../../viam/api/service/mlmodel/v1/mlmodel.grpc.pb.h
       ${PROTO_GEN_DIR}/../../viam/api/service/mlmodel/v1/mlmodel.pb.h
       ${PROTO_GEN_DIR}/../../viam/api/service/motion/v1/motion.grpc.pb.h

src/viam/examples/dial/example_dial.cpp

@@ -63,9 +63,9 @@ int main() {
     }
 
     // ensure we can create clients to the robot
-    auto gc = robot->resource_by_name<Generic>("generic1");
+    auto gc = robot->resource_by_name<GenericComponent>("generic1");
     if (gc) {
-        std::cout << "got generic client named " << gc->name() << std::endl;
+        std::cout << "got generic component client named " << gc->name() << std::endl;
     }
 
     return EXIT_SUCCESS;

src/viam/examples/modules/simple/main.cpp

@@ -8,25 +8,25 @@
 #include <grpcpp/server_context.h>
 
 #include <viam/api/common/v1/common.grpc.pb.h>
-#include <viam/api/component/generic/v1/generic.grpc.pb.h>
 #include <viam/api/robot/v1/robot.pb.h>
+#include <viam/api/service/generic/v1/generic.grpc.pb.h>
 
-#include <viam/sdk/components/component.hpp>
-#include <viam/sdk/components/generic/generic.hpp>
 #include <viam/sdk/config/resource.hpp>
 #include <viam/sdk/module/module.hpp>
 #include <viam/sdk/module/service.hpp>
 #include <viam/sdk/registry/registry.hpp>
 #include <viam/sdk/resource/resource.hpp>
 #include <viam/sdk/rpc/dial.hpp>
 #include <viam/sdk/rpc/server.hpp>
+#include <viam/sdk/services/generic/generic.hpp>
+#include <viam/sdk/services/service.hpp>
 
 using namespace viam::sdk;
 
 // Printer is a modular resource that can print a to_print value to STDOUT when
 // a DoCommand request is received or when reconfiguring. The to_print value
 // must be provided as an attribute in the config.
-class Printer : public Generic {
+class Printer : public GenericService {
    public:
     void reconfigure(Dependencies deps, ResourceConfig cfg) {
         std::cout << "Printer " << Resource::name() << " is reconfiguring" << std::endl;
@@ -37,7 +37,7 @@ class Printer : public Generic {
         std::cout << "Printer " << Resource::name() << " will now print " << to_print_ << std::endl;
     }
 
-    Printer(Dependencies deps, ResourceConfig cfg) : Generic(cfg.name()) {
+    Printer(Dependencies deps, ResourceConfig cfg) : GenericService(cfg.name()) {
         std::cout << "Creating Printer " + Resource::name() << std::endl;
         to_print_ = find_to_print(cfg);
         std::cout << "Printer " << Resource::name() << " will print " << to_print_ << std::endl;
@@ -49,10 +49,6 @@ class Printer : public Generic {
         return command;
     }
 
-    std::vector<GeometryConfig> get_geometries(const AttributeMap& extra) {
-        return std::vector<GeometryConfig>();
-    }
-
     static std::string find_to_print(ResourceConfig cfg) {
         auto& printer_name = cfg.name();
         auto to_print = cfg.attributes()->find("to_print");
@@ -77,7 +73,7 @@ class Printer : public Generic {
 };
 
 int main(int argc, char** argv) {
-    API generic = API::get<Generic>();
+    API generic = API::get<GenericService>();
     Model m("viam", "generic", "printer");
 
     std::shared_ptr<ModelRegistration> mr = std::make_shared<ModelRegistration>(

src/viam/sdk/CMakeLists.txt

@@ -96,6 +96,9 @@ target_sources(viamsdk
     robot/service.cpp
     rpc/dial.cpp
     rpc/server.cpp
+    services/generic/client.cpp
+    services/generic/generic.cpp
+    services/generic/server.cpp
     services/mlmodel/client.cpp
     services/mlmodel/mlmodel.cpp
     services/mlmodel/private/proto.cpp
@@ -165,6 +168,9 @@ target_sources(viamsdk
       ../../viam/sdk/robot/service.hpp
       ../../viam/sdk/rpc/dial.hpp
       ../../viam/sdk/rpc/server.hpp
+      ../../viam/sdk/services/generic/client.hpp
+      ../../viam/sdk/services/generic/generic.hpp
+      ../../viam/sdk/services/generic/server.hpp
       ../../viam/sdk/services/mlmodel/client.hpp
       ../../viam/sdk/services/mlmodel/mlmodel.hpp
       ../../viam/sdk/services/mlmodel/server.hpp

src/viam/sdk/components/generic/client.cpp

@@ -14,18 +14,19 @@
 namespace viam {
 namespace sdk {
 
-GenericClient::GenericClient(std::string name, std::shared_ptr<grpc::Channel> channel)
-    : Generic(std::move(name)),
+GenericComponentClient::GenericComponentClient(std::string name,
+                                               std::shared_ptr<grpc::Channel> channel)
+    : GenericComponent(std::move(name)),
       stub_(viam::component::generic::v1::GenericService::NewStub(channel)),
       channel_(std::move(channel)){};
 
-AttributeMap GenericClient::do_command(AttributeMap command) {
+AttributeMap GenericComponentClient::do_command(AttributeMap command) {
     return make_client_helper(this, *stub_, &StubType::DoCommand)
         .with([&](auto& request) { *request.mutable_command() = map_to_struct(command); })
         .invoke([](auto& response) { return struct_to_map(response.result()); });
 }
 
-std::vector<GeometryConfig> GenericClient::get_geometries(const AttributeMap& extra) {
+std::vector<GeometryConfig> GenericComponentClient::get_geometries(const AttributeMap& extra) {
     return make_client_helper(this, *stub_, &StubType::GetGeometries)
         .with(extra)
         .invoke([](auto& response) { return GeometryConfig::from_proto(response); });

src/viam/sdk/components/generic/client.hpp

@@ -1,6 +1,6 @@
 /// @file components/generic/client.hpp
 ///
-/// @brief Implements a gRPC client for the `Generic` component.
+/// @brief Implements a gRPC client for the `GenericComponent`.
 #pragma once
 
 #include <grpcpp/channel.h>
@@ -13,22 +13,23 @@
 namespace viam {
 namespace sdk {
 
-/// @class GenericClient
-/// @brief gRPC client implementation of a `Generic` component.
-/// @ingroup Generic
-class GenericClient : public Generic {
+/// @class GenericComponentClient
+/// @brief gRPC client implementation of a `GenericComponent`.
+/// @ingroup GenericComponent
+class GenericComponentClient : public GenericComponent {
    public:
-    GenericClient(std::string name, std::shared_ptr<grpc::Channel> channel);
+    GenericComponentClient(std::string name, std::shared_ptr<grpc::Channel> channel);
     AttributeMap do_command(AttributeMap command) override;
     std::vector<GeometryConfig> get_geometries(const AttributeMap& extra) override;
 
    protected:
     // This constructor leaves the `channel_` as a nullptr. This is useful for testing
     // purposes, but renders it unusable for production use. Care should be taken to
     // avoid use of this constructor outside of tests.
-    GenericClient(std::string name,
-                  std::unique_ptr<viam::component::generic::v1::GenericService::StubInterface> stub)
-        : Generic(std::move(name)), stub_(std::move(stub)){};
+    GenericComponentClient(
+        std::string name,
+        std::unique_ptr<viam::component::generic::v1::GenericService::StubInterface> stub)
+        : GenericComponent(std::move(name)), stub_(std::move(stub)){};
 
    private:
     using StubType = viam::component::generic::v1::GenericService::StubInterface;

src/viam/sdk/components/generic/generic.cpp

@@ -15,45 +15,47 @@
 namespace viam {
 namespace sdk {
 
-GenericRegistration::GenericRegistration(
+GenericComponentRegistration::GenericComponentRegistration(
     const google::protobuf::ServiceDescriptor* service_descriptor)
     : ResourceRegistration(service_descriptor){};
 
-std::shared_ptr<ResourceServer> GenericRegistration::create_resource_server(
+std::shared_ptr<ResourceServer> GenericComponentRegistration::create_resource_server(
     std::shared_ptr<ResourceManager> manager, Server& server) {
-    auto gs = std::make_shared<GenericServer>(std::move(manager));
+    auto gs = std::make_shared<GenericComponentServer>(std::move(manager));
     server.register_service(gs.get());
     return gs;
 };
 
-std::shared_ptr<Resource> GenericRegistration::create_rpc_client(
+std::shared_ptr<Resource> GenericComponentRegistration::create_rpc_client(
     std::string name, std::shared_ptr<grpc::Channel> chan) {
-    return std::make_shared<GenericClient>(std::move(name), std::move(chan));
+    return std::make_shared<GenericComponentClient>(std::move(name), std::move(chan));
 };
 
-std::shared_ptr<ResourceRegistration> Generic::resource_registration() {
+std::shared_ptr<ResourceRegistration> GenericComponent::resource_registration() {
     const google::protobuf::DescriptorPool* p = google::protobuf::DescriptorPool::generated_pool();
     const google::protobuf::ServiceDescriptor* sd =
         p->FindServiceByName(viam::component::generic::v1::GenericService::service_full_name());
     if (!sd) {
-        throw std::runtime_error("Unable to get service descriptor for the generic service");
+        throw std::runtime_error(
+            "Unable to get service descriptor for the generic component service");
     }
-    return std::make_shared<GenericRegistration>(sd);
+    return std::make_shared<GenericComponentRegistration>(sd);
 }
 
-API Generic::api() const {
-    return API::get<Generic>();
+API GenericComponent::api() const {
+    return API::get<GenericComponent>();
 }
 
-API API::traits<Generic>::api() {
+API API::traits<GenericComponent>::api() {
     return {kRDK, kComponent, "generic"};
 }
 
-Generic::Generic(std::string name) : Component(std::move(name)){};
+GenericComponent::GenericComponent(std::string name) : Component(std::move(name)){};
 
 namespace {
 bool init() {
-    Registry::register_resource(API::get<Generic>(), Generic::resource_registration());
+    Registry::register_resource(API::get<GenericComponent>(),
+                                GenericComponent::resource_registration());
     return true;
 };
 

src/viam/sdk/components/generic/generic.hpp

@@ -1,6 +1,7 @@
 /// @file generic/generic.hpp
 ///
-/// @brief Defines `Generic` subtype and component class capable of executing arbitrary commands.
+/// @brief Defines `GenericComponent` subtype and component class capable of executing arbitrary
+/// commands.
 #pragma once
 
 #include <google/protobuf/descriptor.h>
@@ -14,34 +15,33 @@
 namespace viam {
 namespace sdk {
 
-// TODO(RSDK-1742): one class per header
-/// @defgroup Generic Classes related to the Generic component.
+// TODO(RSDK-3030): one class per header
+/// @defgroup GenericComponent Classes related to the generic component.
 
-/// @class GenericRegistration
-/// @brief Defines a `ResourceRegistration` for the `Generic` component.
-/// @ingroup Generic
-class GenericRegistration : public ResourceRegistration {
+/// @class GenericComponentRegistration
+/// @brief Defines a `ResourceRegistration` for the generic component.
+/// @ingroup GenericComponent
+class GenericComponentRegistration : public ResourceRegistration {
    public:
-    explicit GenericRegistration(const google::protobuf::ServiceDescriptor* service_descriptor);
+    explicit GenericComponentRegistration(
+        const google::protobuf::ServiceDescriptor* service_descriptor);
     std::shared_ptr<ResourceServer> create_resource_server(std::shared_ptr<ResourceManager> manager,
                                                            Server& server) override;
     std::shared_ptr<Resource> create_rpc_client(std::string name,
                                                 std::shared_ptr<grpc::Channel> chan) override;
 };
 
-/// @class Generic generic.hpp "components/generic/generic.hpp"
-/// @brief A `Generic` represents any component that can execute arbitrary commands.
-/// @ingroup Generic
+/// @class GenericComponent generic.hpp "components/generic/generic.hpp"
+/// @brief A `GenericComponent` represents any component that can execute arbitrary commands.
+/// @ingroup GenericComponent
 ///
 /// This acts as an abstract base class to be inherited from by any drivers representing
 /// specific generic implementations. This class cannot be used on its own.
-class Generic : public Component {
+class GenericComponent : public Component {
    public:
-    /// @brief Creates a `ResourceRegistration` for the `Generic` component.
+    /// @brief Creates a `ResourceRegistration` for `GenericComponent`.
     static std::shared_ptr<ResourceRegistration> resource_registration();
 
-    /// @brief Creates a `Generic` `API`.
-
     /// @brief Send/receive arbitrary commands to the resource.
     /// @param command the command to execute.
     /// @return The result of the executed command.
@@ -55,14 +55,15 @@ class Generic : public Component {
 
     virtual std::vector<GeometryConfig> get_geometries(const AttributeMap& extra) = 0;
 
+    /// @brief Creates a `GenericComponent` `API`.
     API api() const override;
 
    protected:
-    explicit Generic(std::string name);
+    explicit GenericComponent(std::string name);
 };
 
 template <>
-struct API::traits<Generic> {
+struct API::traits<GenericComponent> {
     static API api();
 };
 

src/viam/sdk/components/generic/server.cpp

@@ -7,24 +7,25 @@
 namespace viam {
 namespace sdk {
 
-GenericServer::GenericServer(std::shared_ptr<ResourceManager> manager)
+GenericComponentServer::GenericComponentServer(std::shared_ptr<ResourceManager> manager)
     : ResourceServer(std::move(manager)){};
 
-::grpc::Status GenericServer::DoCommand(::grpc::ServerContext* context,
-                                        const ::viam::common::v1::DoCommandRequest* request,
-                                        ::viam::common::v1::DoCommandResponse* response) noexcept {
-    return make_service_helper<Generic>(
-        "GenericServer::DoCommand", this, request)([&](auto& helper, auto& generic) {
+::grpc::Status GenericComponentServer::DoCommand(
+    ::grpc::ServerContext* context,
+    const ::viam::common::v1::DoCommandRequest* request,
+    ::viam::common::v1::DoCommandResponse* response) noexcept {
+    return make_service_helper<GenericComponent>(
+        "GenericComponentServer::DoCommand", this, request)([&](auto& helper, auto& generic) {
         const AttributeMap result = generic->do_command(struct_to_map(request->command()));
         *response->mutable_result() = map_to_struct(result);
     });
 }
-::grpc::Status GenericServer::GetGeometries(
+::grpc::Status GenericComponentServer::GetGeometries(
     ::grpc::ServerContext* context,
     const ::viam::common::v1::GetGeometriesRequest* request,
     ::viam::common::v1::GetGeometriesResponse* response) noexcept {
-    return make_service_helper<Generic>(
-        "GenericServer::GetGeometries", this, request)([&](auto& helper, auto& generic) {
+    return make_service_helper<GenericComponent>(
+        "GenericComponentServer::GetGeometries", this, request)([&](auto& helper, auto& generic) {
         const std::vector<GeometryConfig> geometries = generic->get_geometries(helper.getExtra());
         for (const auto& geometry : geometries) {
             *response->mutable_geometries()->Add() = geometry.to_proto();

src/viam/sdk/components/generic/server.hpp

@@ -1,6 +1,6 @@
 /// @file components/generic/server.hpp
 ///
-/// @brief Implements a gRPC server for the `Generic` component.
+/// @brief Implements a gRPC server for the `GenericComponent`.
 #pragma once
 
 #include <viam/api/common/v1/common.grpc.pb.h>
@@ -12,13 +12,13 @@
 namespace viam {
 namespace sdk {
 
-/// @class GenericServer
-/// @brief gRPC server implementation of a `Generic` component.
-/// @ingroup Generic
-class GenericServer : public ResourceServer,
-                      public viam::component::generic::v1::GenericService::Service {
+/// @class GenericComponentServer
+/// @brief gRPC server implementation of a `GenericComponent`.
+/// @ingroup GenericComponent
+class GenericComponentServer : public ResourceServer,
+                               public viam::component::generic::v1::GenericService::Service {
    public:
-    explicit GenericServer(std::shared_ptr<ResourceManager> manager);
+    explicit GenericComponentServer(std::shared_ptr<ResourceManager> manager);
 
     ::grpc::Status DoCommand(::grpc::ServerContext* context,
                              const ::viam::common::v1::DoCommandRequest* request,