feat grpc: resolve a dependency cycle in server middlewares

`ugrpc::server::ServerComponent` previously called `FindComponent` for all the specified `service-defaults.middlewares`. It could lead to a dependency cycle:

```
grpc-server -> middleware -> something -> grpc-server
```

This PR breaks the `grpc-server -> middleware` dependency. The new components dependency structure looks like this:

```
service-component -> grpc-server
       v
    middleware -> something -> grpc-server
```

Fixes: userver-framework#432
Closes: userver-framework#435

grpc/src/ugrpc/server/impl/parse_config.cpp

@@ -1,8 +1,11 @@
 #include <ugrpc/server/impl/parse_config.hpp>
 
+#include <boost/range/adaptor/transformed.hpp>
+
 #include <userver/logging/component.hpp>
 #include <userver/logging/level_serialization.hpp>
 #include <userver/logging/null_logger.hpp>
+#include <userver/utils/algo.hpp>
 
 #include <userver/ugrpc/server/middlewares/base.hpp>
 
@@ -44,16 +47,19 @@ engine::TaskProcessor& ParseTaskProcessor(
   return context.GetTaskProcessor(field.As<std::string>());
 }
 
-Middlewares ParseMiddlewares(const yaml_config::YamlConfig& field,
-                             const components::ComponentContext& context) {
-  Middlewares middlewares;
-  middlewares.reserve(field.GetSize());
-  for (const auto& name_yaml : field) {
-    const auto name = name_yaml.As<std::string>();
-    auto& component = context.FindComponent<MiddlewareComponentBase>(name);
-    middlewares.push_back(component.GetMiddleware());
-  }
-  return middlewares;
+std::vector<std::string> ParseMiddlewares(
+    const yaml_config::YamlConfig& field,
+    const components::ComponentContext& /*context*/) {
+  return field.As<std::vector<std::string>>();
+}
+
+Middlewares FindMiddlewares(const std::vector<std::string>& names,
+                            const components::ComponentContext& context) {
+  return utils::AsContainer<Middlewares>(
+      names | boost::adaptors::transformed([&](const std::string& name) {
+        return context.FindComponent<MiddlewareComponentBase>(name)
+            .GetMiddleware();
+      }));
 }
 
 }  // namespace
@@ -62,7 +68,9 @@ ServiceDefaults ParseServiceDefaults(
     const yaml_config::YamlConfig& value,
     const components::ComponentContext& context) {
   return ServiceDefaults{
-      ParseOptional(value[kTaskProcessorKey], context, ParseTaskProcessor),
+      /*task_processor=*/ParseOptional(value[kTaskProcessorKey], context,
+                                       ParseTaskProcessor),
+      /*middleware_names=*/
       ParseOptional(value[kMiddlewaresKey], context, ParseMiddlewares),
   };
 }
@@ -72,10 +80,14 @@ server::ServiceConfig ParseServiceConfig(
     const components::ComponentContext& context,
     const ServiceDefaults& defaults) {
   return server::ServiceConfig{
-      MergeField(value[kTaskProcessorKey], defaults.task_processor, context,
-                 ParseTaskProcessor),
-      MergeField(value[kMiddlewaresKey], defaults.middlewares, context,
-                 ParseMiddlewares),
+      /*task_processor=*/MergeField(value[kTaskProcessorKey],
+                                    defaults.task_processor, context,
+                                    ParseTaskProcessor),
+      /*middlewares=*/
+      FindMiddlewares(
+          MergeField(value[kMiddlewaresKey], defaults.middleware_names, context,
+                     ParseMiddlewares),
+          context),
   };
 }
 

grpc/src/ugrpc/server/impl/service_defaults.hpp

@@ -1,21 +1,20 @@
 #pragma once
 
-#include <optional>
+#include <string>
+#include <vector>
 
 #include <boost/optional/optional.hpp>
 
 #include <userver/engine/task/task_processor_fwd.hpp>
 
-#include <userver/ugrpc/server/middlewares/fwd.hpp>
-
 USERVER_NAMESPACE_BEGIN
 
 namespace ugrpc::server::impl {
 
 struct ServiceDefaults final {
   // using boost::optional to easily generalize to references
   boost::optional<engine::TaskProcessor&> task_processor;
-  boost::optional<Middlewares> middlewares;
+  boost::optional<std::vector<std::string>> middleware_names;
 };
 
 }  // namespace ugrpc::server::impl