grpc 1.50.0.pre1 → 1.52.0.pre2

data/src/core/lib/channel/channel_args.cc

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
+//
+//
+// Copyright 2015 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
 
 #include <grpc/support/port_platform.h>
 
@@ -33,7 +33,6 @@
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
 
-#include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
@@ -393,8 +392,8 @@ static int cmp_arg(const grpc_arg* a, const grpc_arg* b) {
   GPR_UNREACHABLE_CODE(return 0);
 }
 
-/* stabilizing comparison function: since channel_args ordering matters for
- * keys with the same name, we need to preserve that ordering */
+// stabilizing comparison function: since channel_args ordering matters for
+// keys with the same name, we need to preserve that ordering
 static int cmp_key_stable(const void* ap, const void* bp) {
   const grpc_arg* const* a = static_cast<const grpc_arg* const*>(ap);
   const grpc_arg* const* b = static_cast<const grpc_arg* const*>(bp);

data/src/core/lib/channel/channel_args.h

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
+//
+//
+// Copyright 2015 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
 
 #ifndef GRPC_CORE_LIB_CHANNEL_CHANNEL_ARGS_H
 #define GRPC_CORE_LIB_CHANNEL_CHANNEL_ARGS_H
@@ -27,6 +27,7 @@
 #include <iosfwd>
 #include <memory>
 #include <string>
+#include <type_traits>
 #include <utility>
 
 #include "absl/meta/type_traits.h"
@@ -34,7 +35,8 @@
 #include "absl/types/optional.h"
 #include "absl/types/variant.h"
 
-#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/event_engine/event_engine.h>
+#include <grpc/grpc.h>
 
 #include "src/core/lib/avl/avl.h"
 #include "src/core/lib/gpr/useful.h"
@@ -45,6 +47,11 @@
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 
+// TODO(hork): When we're ready to allow setting via a channel arg from the
+// application, replace this with a macro in
+// include/grpc/impl/codegen/grpc_types.h.
+#define GRPC_INTERNAL_ARG_EVENT_ENGINE "grpc.internal.event_engine"
+
 // Channel args are intentionally immutable, to avoid the need for locking.
 
 namespace grpc_core {
@@ -170,6 +177,9 @@ template <typename T>
 struct WrapInSharedPtr
     : std::integral_constant<
           bool, std::is_base_of<std::enable_shared_from_this<T>, T>::value> {};
+template <>
+struct WrapInSharedPtr<grpc_event_engine::experimental::EventEngine>
+    : std::true_type {};
 template <typename T, typename Ignored = void /* for SFINAE */>
 struct GetObjectImpl;
 // std::shared_ptr implementation
@@ -213,7 +223,13 @@ template <typename T>
 struct ChannelArgNameTraits<std::shared_ptr<T>> {
   static absl::string_view ChannelArgName() { return T::ChannelArgName(); }
 };
-
+// Specialization for the EventEngine
+template <>
+struct ChannelArgNameTraits<grpc_event_engine::experimental::EventEngine> {
+  static absl::string_view ChannelArgName() {
+    return GRPC_INTERNAL_ARG_EVENT_ENGINE;
+  }
+};
 class ChannelArgs {
  public:
   class Pointer {
@@ -416,34 +432,34 @@ std::ostream& operator<<(std::ostream& out, const ChannelArgs& args);
 
 }  // namespace grpc_core
 
-/** Copy the arguments in \a src into a new instance */
+/// Copy the arguments in \a src into a new instance
 grpc_channel_args* grpc_channel_args_copy(const grpc_channel_args* src);
 
-/** Copy the arguments in \a src into a new instance, stably sorting keys */
+/// Copy the arguments in \a src into a new instance, stably sorting keys
 grpc_channel_args* grpc_channel_args_normalize(const grpc_channel_args* src);
 
-/** Copy the arguments in \a src and append \a to_add. If \a to_add is NULL, it
- * is equivalent to calling \a grpc_channel_args_copy. */
+/// Copy the arguments in \a src and append \a to_add. If \a to_add is NULL, it
+/// is equivalent to calling \a grpc_channel_args_copy.
 grpc_channel_args* grpc_channel_args_copy_and_add(const grpc_channel_args* src,
                                                   const grpc_arg* to_add,
                                                   size_t num_to_add);
 
-/** Copies the arguments in \a src except for those whose keys are in
-    \a to_remove. */
+/// Copies the arguments in \a src except for those whose keys are in
+/// \a to_remove.
 grpc_channel_args* grpc_channel_args_copy_and_remove(
     const grpc_channel_args* src, const char** to_remove, size_t num_to_remove);
 
-/** Copies the arguments from \a src except for those whose keys are in
-    \a to_remove and appends the arguments in \a to_add. */
+/// Copies the arguments from \a src except for those whose keys are in
+/// \a to_remove and appends the arguments in \a to_add.
 grpc_channel_args* grpc_channel_args_copy_and_add_and_remove(
     const grpc_channel_args* src, const char** to_remove, size_t num_to_remove,
     const grpc_arg* to_add, size_t num_to_add);
 
-/** Perform the union of \a a and \a b, prioritizing \a a entries */
+/// Perform the union of \a a and \a b, prioritizing \a a entries
 grpc_channel_args* grpc_channel_args_union(const grpc_channel_args* a,
                                            const grpc_channel_args* b);
 
-/** Destroy arguments created by \a grpc_channel_args_copy */
+/// Destroy arguments created by \a grpc_channel_args_copy
 void grpc_channel_args_destroy(grpc_channel_args* a);
 inline void grpc_channel_args_destroy(const grpc_channel_args* a) {
   grpc_channel_args_destroy(const_cast<grpc_channel_args*>(a));
@@ -452,7 +468,7 @@ inline void grpc_channel_args_destroy(const grpc_channel_args* a) {
 int grpc_channel_args_compare(const grpc_channel_args* a,
                               const grpc_channel_args* b);
 
-/** Returns the value of argument \a name from \a args, or NULL if not found. */
+/// Returns the value of argument \a name from \a args, or NULL if not found.
 const grpc_arg* grpc_channel_args_find(const grpc_channel_args* args,
                                        const char* name);
 
@@ -464,28 +480,28 @@ typedef struct grpc_integer_options {
   int max_value;
 } grpc_integer_options;
 
-/** Returns the value of \a arg, subject to the constraints in \a options. */
+/// Returns the value of \a arg, subject to the constraints in \a options.
 int grpc_channel_arg_get_integer(const grpc_arg* arg,
                                  const grpc_integer_options options);
-/** Similar to the above, but needs to find the arg from \a args by the name
- * first. */
+/// Similar to the above, but needs to find the arg from \a args by the name
+/// first.
 int grpc_channel_args_find_integer(const grpc_channel_args* args,
                                    const char* name,
                                    const grpc_integer_options options);
 
-/** Returns the value of \a arg if \a arg is of type GRPC_ARG_STRING.
-    Otherwise, emits a warning log, and returns nullptr.
-    If arg is nullptr, returns nullptr, and does not emit a warning. */
+/// Returns the value of \a arg if \a arg is of type GRPC_ARG_STRING.
+/// Otherwise, emits a warning log, and returns nullptr.
+/// If arg is nullptr, returns nullptr, and does not emit a warning.
 char* grpc_channel_arg_get_string(const grpc_arg* arg);
-/** Similar to the above, but needs to find the arg from \a args by the name
- * first. */
+/// Similar to the above, but needs to find the arg from \a args by the name
+/// first.
 char* grpc_channel_args_find_string(const grpc_channel_args* args,
                                     const char* name);
-/** If \a arg is of type GRPC_ARG_INTEGER, returns true if it's non-zero.
- * Returns \a default_value if \a arg is of other types. */
+/// If \a arg is of type GRPC_ARG_INTEGER, returns true if it's non-zero.
+/// Returns \a default_value if \a arg is of other types.
 bool grpc_channel_arg_get_bool(const grpc_arg* arg, bool default_value);
-/** Similar to the above, but needs to find the arg from \a args by the name
- * first. */
+/// Similar to the above, but needs to find the arg from \a args by the name
+/// first.
 bool grpc_channel_args_find_bool(const grpc_channel_args* args,
                                  const char* name, bool default_value);
 
@@ -526,4 +542,4 @@ void grpc_channel_args_set_client_channel_creation_mutator(
 grpc_channel_args_client_channel_creation_mutator
 grpc_channel_args_get_client_channel_creation_mutator();
 
-#endif /* GRPC_CORE_LIB_CHANNEL_CHANNEL_ARGS_H */
+#endif  // GRPC_CORE_LIB_CHANNEL_CHANNEL_ARGS_H

data/src/core/lib/channel/channel_args_preconditioning.h

@@ -20,7 +20,7 @@
 #include <functional>
 #include <vector>
 
-#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/grpc.h>
 
 #include "src/core/lib/channel/channel_args.h"
 

data/src/core/lib/channel/channel_stack.cc

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
+//
+//
+// Copyright 2015 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
 
 #include <grpc/support/port_platform.h>
 
@@ -22,34 +22,38 @@
 
 #include <stdint.h>
 
+#include <memory>
 #include <utility>
 
 #include <grpc/support/log.h>
 
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/alloc.h"
 
+using grpc_event_engine::experimental::EventEngine;
+
 grpc_core::TraceFlag grpc_trace_channel(false, "channel");
 grpc_core::TraceFlag grpc_trace_channel_stack(false, "channel_stack");
 
-/* Memory layouts.
+// Memory layouts.
 
-   Channel stack is laid out as: {
-     grpc_channel_stack stk;
-     padding to GPR_MAX_ALIGNMENT
-     grpc_channel_element[stk.count];
-     per-filter memory, aligned to GPR_MAX_ALIGNMENT
-   }
+// Channel stack is laid out as: {
+//   grpc_channel_stack stk;
+//   padding to GPR_MAX_ALIGNMENT
+//   grpc_channel_element[stk.count];
+//   per-filter memory, aligned to GPR_MAX_ALIGNMENT
+// }
 
-   Call stack is laid out as: {
-     grpc_call_stack stk;
-     padding to GPR_MAX_ALIGNMENT
-     grpc_call_element[stk.count];
-     per-filter memory, aligned to GPR_MAX_ALIGNMENT
-   } */
+// Call stack is laid out as: {
+//   grpc_call_stack stk;
+//   padding to GPR_MAX_ALIGNMENT
+//   grpc_call_element[stk.count];
+//   per-filter memory, aligned to GPR_MAX_ALIGNMENT
+// }
 
 size_t grpc_channel_stack_size(const grpc_channel_filter** filters,
                                size_t filter_count) {
-  /* always need the header, and size for the channel elements */
+  // always need the header, and size for the channel elements
   size_t size = GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(grpc_channel_stack)) +
                 GPR_ROUND_UP_TO_ALIGNMENT_SIZE(filter_count *
                                                sizeof(grpc_channel_element));
@@ -58,7 +62,7 @@ size_t grpc_channel_stack_size(const grpc_channel_filter** filters,
   GPR_ASSERT((GPR_MAX_ALIGNMENT & (GPR_MAX_ALIGNMENT - 1)) == 0 &&
              "GPR_MAX_ALIGNMENT must be a power of two");
 
-  /* add the size for each filter */
+  // add the size for each filter
   for (i = 0; i < filter_count; i++) {
     size += GPR_ROUND_UP_TO_ALIGNMENT_SIZE(filters[i]->sizeof_channel_data);
   }
@@ -104,16 +108,18 @@ grpc_call_element* grpc_call_stack_element(grpc_call_stack* call_stack,
 grpc_error_handle grpc_channel_stack_init(
     int initial_refs, grpc_iomgr_cb_func destroy, void* destroy_arg,
     const grpc_channel_filter** filters, size_t filter_count,
-    const grpc_channel_args* channel_args, const char* name,
+    const grpc_core::ChannelArgs& channel_args, const char* name,
     grpc_channel_stack* stack) {
   if (grpc_trace_channel_stack.enabled()) {
     gpr_log(GPR_INFO, "CHANNEL_STACK: init %s", name);
     for (size_t i = 0; i < filter_count; i++) {
-      gpr_log(GPR_INFO, "CHANNEL_STACK:   filter %s", filters[i]->name);
+      gpr_log(GPR_INFO, "CHANNEL_STACK:   filter %s%s", filters[i]->name,
+              filters[i]->make_call_promise ? " [promise-capable]" : "");
     }
   }
 
   stack->on_destroy.Init([]() {});
+  stack->event_engine.Init(channel_args.GetObjectRef<EventEngine>());
 
   size_t call_size =
       GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(grpc_call_stack)) +
@@ -131,22 +137,21 @@ grpc_error_handle grpc_channel_stack_init(
               GPR_ROUND_UP_TO_ALIGNMENT_SIZE(filter_count *
                                              sizeof(grpc_channel_element));
 
-  /* init per-filter data */
-  grpc_error_handle first_error = GRPC_ERROR_NONE;
+  // init per-filter data
+  grpc_error_handle first_error;
+  auto c_channel_args = channel_args.ToC();
   for (i = 0; i < filter_count; i++) {
     args.channel_stack = stack;
-    args.channel_args = channel_args;
+    args.channel_args = c_channel_args.get();
     args.is_first = i == 0;
     args.is_last = i == (filter_count - 1);
     elems[i].filter = filters[i];
     elems[i].channel_data = user_data;
     grpc_error_handle error =
         elems[i].filter->init_channel_elem(&elems[i], &args);
-    if (!GRPC_ERROR_IS_NONE(error)) {
-      if (GRPC_ERROR_IS_NONE(first_error)) {
+    if (!error.ok()) {
+      if (first_error.ok()) {
         first_error = error;
-      } else {
-        GRPC_ERROR_UNREF(error);
       }
     }
     user_data +=
@@ -167,13 +172,14 @@ void grpc_channel_stack_destroy(grpc_channel_stack* stack) {
   size_t count = stack->count;
   size_t i;
 
-  /* destroy per-filter data */
+  // destroy per-filter data
   for (i = 0; i < count; i++) {
     channel_elems[i].filter->destroy_channel_elem(&channel_elems[i]);
   }
 
   (*stack->on_destroy)();
   stack->on_destroy.Destroy();
+  stack->event_engine.Destroy();
 }
 
 grpc_error_handle grpc_call_stack_init(
@@ -192,8 +198,8 @@ grpc_error_handle grpc_call_stack_init(
   user_data = (reinterpret_cast<char*>(call_elems)) +
               GPR_ROUND_UP_TO_ALIGNMENT_SIZE(count * sizeof(grpc_call_element));
 
-  /* init per-filter data */
-  grpc_error_handle first_error = GRPC_ERROR_NONE;
+  // init per-filter data
+  grpc_error_handle first_error;
   for (size_t i = 0; i < count; i++) {
     call_elems[i].filter = channel_elems[i].filter;
     call_elems[i].channel_data = channel_elems[i].channel_data;
@@ -204,11 +210,9 @@ grpc_error_handle grpc_call_stack_init(
   for (size_t i = 0; i < count; i++) {
     grpc_error_handle error =
         call_elems[i].filter->init_call_elem(&call_elems[i], elem_args);
-    if (!GRPC_ERROR_IS_NONE(error)) {
-      if (GRPC_ERROR_IS_NONE(first_error)) {
+    if (!error.ok()) {
+      if (first_error.ok()) {
         first_error = error;
-      } else {
-        GRPC_ERROR_UNREF(error);
       }
     }
   }
@@ -223,7 +227,7 @@ void grpc_call_stack_set_pollset_or_pollset_set(grpc_call_stack* call_stack,
 
   call_elems = CALL_ELEMS_FROM_STACK(call_stack);
 
-  /* init per-filter data */
+  // init per-filter data
   for (i = 0; i < count; i++) {
     call_elems[i].filter->set_pollset_or_pollset_set(&call_elems[i], pollent);
   }
@@ -239,7 +243,7 @@ void grpc_call_stack_destroy(grpc_call_stack* stack,
   size_t count = stack->count;
   size_t i;
 
-  /* destroy per-filter data */
+  // destroy per-filter data
   for (i = 0; i < count; i++) {
     elems[i].filter->destroy_call_elem(
         &elems[i], final_info,
@@ -300,12 +304,12 @@ grpc_core::NextPromiseFactory ServerNext(grpc_channel_element* elem) {
 }  // namespace
 
 grpc_core::ArenaPromise<grpc_core::ServerMetadataHandle>
-grpc_channel_stack::MakeCallPromise(grpc_core::CallArgs call_args) {
-  if (is_client) {
-    return ClientNext(grpc_channel_stack_element(this, 0))(
-        std::move(call_args));
-  } else {
-    return ServerNext(grpc_channel_stack_element(this, this->count - 1))(
-        std::move(call_args));
-  }
+grpc_channel_stack::MakeClientCallPromise(grpc_core::CallArgs call_args) {
+  return ClientNext(grpc_channel_stack_element(this, 0))(std::move(call_args));
+}
+
+grpc_core::ArenaPromise<grpc_core::ServerMetadataHandle>
+grpc_channel_stack::MakeServerCallPromise(grpc_core::CallArgs call_args) {
+  return ServerNext(grpc_channel_stack_element(this, this->count - 1))(
+      std::move(call_args));
 }