grpc 1.43.1 → 1.44.0.pre2

data/src/core/ext/transport/chttp2/transport/writing.cc

@@ -25,7 +25,6 @@
 #include "src/core/ext/transport/chttp2/transport/chttp2_transport.h"
 #include "src/core/ext/transport/chttp2/transport/context_list.h"
 #include "src/core/ext/transport/chttp2/transport/internal.h"
-#include "src/core/lib/compression/stream_compression.h"
 #include "src/core/lib/debug/stats.h"
 #include "src/core/lib/profiling/timers.h"
 #include "src/core/lib/slice/slice_internal.h"
@@ -164,16 +163,10 @@ static void report_stall(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
         "%s:%p stream %d moved to stalled list by %s. This is FULLY expected "
         "to happen in a healthy program that is not seeing flow control stalls."
         " However, if you know that there are unwanted stalls, here is some "
-        "helpful data: [fc:pending=%" PRIdPTR ":pending-compressed=%" PRIdPTR
-        ":flowed=%" PRId64 ":peer_initwin=%d:t_win=%" PRId64
-        ":s_win=%d:s_delta=%" PRId64 "]",
+        "helpful data: [fc:pending=%" PRIdPTR ":flowed=%" PRId64
+        ":peer_initwin=%d:t_win=%" PRId64 ":s_win=%d:s_delta=%" PRId64 "]",
         t->peer_string.c_str(), t, s->id, staller,
-        s->flow_controlled_buffer.length,
-        s->stream_compression_method ==
-                GRPC_STREAM_COMPRESSION_IDENTITY_COMPRESS
-            ? 0
-            : s->compressed_data_buffer.length,
-        s->flow_controlled_bytes_flowed,
+        s->flow_controlled_buffer.length, s->flow_controlled_bytes_flowed,
         t->settings[GRPC_ACKED_SETTINGS]
                    [GRPC_CHTTP2_SETTINGS_INITIAL_WINDOW_SIZE],
         t->flow_control->remote_window(),
@@ -192,10 +185,30 @@ static uint32_t target_write_size(grpc_chttp2_transport* /*t*/) {
   return 1024 * 1024;
 }
 
+namespace {
+
+class CountDefaultMetadataEncoder {
+ public:
+  size_t count() const { return count_; }
+
+  void Encode(const grpc_core::Slice&, const grpc_core::Slice&) {}
+
+  template <typename Which>
+  void Encode(Which, const typename Which::ValueType&) {
+    count_++;
+  }
+
+ private:
+  size_t count_ = 0;
+};
+
+}  // namespace
+
 // Returns true if initial_metadata contains only default headers.
 static bool is_default_initial_metadata(grpc_metadata_batch* initial_metadata) {
-  return initial_metadata->default_count() ==
-         initial_metadata->non_deadline_count();
+  CountDefaultMetadataEncoder enc;
+  initial_metadata->Encode(&enc);
+  return enc.count() == initial_metadata->count();
 }
 
 namespace {
@@ -344,7 +357,7 @@ class DataSendContext {
 
   bool AnyOutgoing() const { return max_outgoing() > 0; }
 
-  void FlushUncompressedBytes() {
+  void FlushBytes() {
     uint32_t send_bytes = static_cast<uint32_t>(
         std::min(size_t(max_outgoing()), s_->flow_controlled_buffer.length));
     is_last_frame_ = send_bytes == s_->flow_controlled_buffer.length &&
@@ -357,60 +370,6 @@ class DataSendContext {
     s_->sending_bytes += send_bytes;
   }
 
-  void FlushCompressedBytes() {
-    GPR_DEBUG_ASSERT(s_->stream_compression_method !=
-                     GRPC_STREAM_COMPRESSION_IDENTITY_COMPRESS);
-
-    uint32_t send_bytes = static_cast<uint32_t>(
-        std::min(size_t(max_outgoing()), s_->compressed_data_buffer.length));
-    bool is_last_data_frame =
-        (send_bytes == s_->compressed_data_buffer.length &&
-         s_->flow_controlled_buffer.length == 0 &&
-         s_->fetching_send_message == nullptr);
-    if (is_last_data_frame && s_->send_trailing_metadata != nullptr &&
-        s_->stream_compression_ctx != nullptr) {
-      if (GPR_UNLIKELY(!grpc_stream_compress(
-              s_->stream_compression_ctx, &s_->flow_controlled_buffer,
-              &s_->compressed_data_buffer, nullptr, MAX_SIZE_T,
-              GRPC_STREAM_COMPRESSION_FLUSH_FINISH))) {
-        gpr_log(GPR_ERROR, "Stream compression failed.");
-      }
-      grpc_stream_compression_context_destroy(s_->stream_compression_ctx);
-      s_->stream_compression_ctx = nullptr;
-      /* After finish, bytes in s->compressed_data_buffer may be
-       * more than max_outgoing. Start another round of the current
-       * while loop so that send_bytes and is_last_data_frame are
-       * recalculated. */
-      return;
-    }
-    is_last_frame_ = is_last_data_frame &&
-                     s_->send_trailing_metadata != nullptr &&
-                     s_->send_trailing_metadata->empty();
-    grpc_chttp2_encode_data(s_->id, &s_->compressed_data_buffer, send_bytes,
-                            is_last_frame_, &s_->stats.outgoing, &t_->outbuf);
-    s_->flow_control->SentData(send_bytes);
-    if (s_->compressed_data_buffer.length == 0) {
-      s_->sending_bytes += s_->uncompressed_data_size;
-    }
-  }
-
-  void CompressMoreBytes() {
-    GPR_DEBUG_ASSERT(s_->stream_compression_method !=
-                     GRPC_STREAM_COMPRESSION_IDENTITY_COMPRESS);
-
-    if (s_->stream_compression_ctx == nullptr) {
-      s_->stream_compression_ctx =
-          grpc_stream_compression_context_create(s_->stream_compression_method);
-    }
-    s_->uncompressed_data_size = s_->flow_controlled_buffer.length;
-    if (GPR_UNLIKELY(!grpc_stream_compress(
-            s_->stream_compression_ctx, &s_->flow_controlled_buffer,
-            &s_->compressed_data_buffer, nullptr, MAX_SIZE_T,
-            GRPC_STREAM_COMPRESSION_FLUSH_SYNC))) {
-      gpr_log(GPR_ERROR, "Stream compression failed.");
-    }
-  }
-
   bool is_last_frame() const { return is_last_frame_; }
 
   void CallCallbacks() {
@@ -455,7 +414,6 @@ class StreamWriteContext {
     // https://github.com/grpc/proposal/blob/master/A6-client-retries.md#when-retries-are-valid
     if (!t_->is_client && s_->fetching_send_message == nullptr &&
         s_->flow_controlled_buffer.length == 0 &&
-        compressed_data_buffer_len() == 0 &&
         s_->send_trailing_metadata != nullptr &&
         is_default_initial_metadata(s_->send_initial_metadata)) {
       ConvertInitialMetadataToTrailingMetadata();
@@ -486,13 +444,6 @@ class StreamWriteContext {
         "send_initial_metadata_finished");
   }
 
-  size_t compressed_data_buffer_len() {
-    return s_->stream_compression_method ==
-                   GRPC_STREAM_COMPRESSION_IDENTITY_COMPRESS
-               ? 0
-               : s_->compressed_data_buffer.length;
-  }
-
   void FlushWindowUpdates() {
     /* send any window updates */
     const uint32_t stream_announce = s_->flow_control->MaybeSendUpdate();
@@ -508,8 +459,7 @@ class StreamWriteContext {
   void FlushData() {
     if (!s_->sent_initial_metadata) return;
 
-    if (s_->flow_controlled_buffer.length == 0 &&
-        compressed_data_buffer_len() == 0) {
+    if (s_->flow_controlled_buffer.length == 0) {
       return;  // early out: nothing to do
     }
 
@@ -526,22 +476,9 @@ class StreamWriteContext {
       return;  // early out: nothing to do
     }
 
-    if (s_->stream_compression_method ==
-        GRPC_STREAM_COMPRESSION_IDENTITY_COMPRESS) {
-      while (s_->flow_controlled_buffer.length > 0 &&
-             data_send_context.max_outgoing() > 0) {
-        data_send_context.FlushUncompressedBytes();
-      }
-    } else {
-      while ((s_->flow_controlled_buffer.length > 0 ||
-              s_->compressed_data_buffer.length > 0) &&
-             data_send_context.max_outgoing() > 0) {
-        if (s_->compressed_data_buffer.length > 0) {
-          data_send_context.FlushCompressedBytes();
-        } else {
-          data_send_context.CompressMoreBytes();
-        }
-      }
+    while (s_->flow_controlled_buffer.length > 0 &&
+           data_send_context.max_outgoing() > 0) {
+      data_send_context.FlushBytes();
     }
     grpc_chttp2_reset_ping_clock(t_);
     if (data_send_context.is_last_frame()) {
@@ -549,8 +486,7 @@ class StreamWriteContext {
     }
     data_send_context.CallCallbacks();
     stream_became_writable_ = true;
-    if (s_->flow_controlled_buffer.length > 0 ||
-        compressed_data_buffer_len() > 0) {
+    if (s_->flow_controlled_buffer.length > 0) {
       GRPC_CHTTP2_STREAM_REF(s_, "chttp2_writing:fork");
       grpc_chttp2_list_add_writable_stream(t_, s_);
     }
@@ -563,13 +499,20 @@ class StreamWriteContext {
     if (s_->send_trailing_metadata == nullptr) return;
     if (s_->fetching_send_message != nullptr) return;
     if (s_->flow_controlled_buffer.length != 0) return;
-    if (compressed_data_buffer_len() != 0) return;
 
     GRPC_CHTTP2_IF_TRACING(gpr_log(GPR_INFO, "sending trailing_metadata"));
     if (s_->send_trailing_metadata->empty()) {
       grpc_chttp2_encode_data(s_->id, &s_->flow_controlled_buffer, 0, true,
                               &s_->stats.outgoing, &t_->outbuf);
     } else {
+      if (send_status_.has_value()) {
+        s_->send_trailing_metadata->Set(grpc_core::HttpStatusMetadata(),
+                                        *send_status_);
+      }
+      if (send_content_type_.has_value()) {
+        s_->send_trailing_metadata->Set(grpc_core::ContentTypeMetadata(),
+                                        *send_content_type_);
+      }
       t_->hpack_compressor.EncodeHeaders(
           grpc_core::HPackCompressor::EncodeHeaderOptions{
               s_->id, true,
@@ -580,12 +523,7 @@ class StreamWriteContext {
               t_->settings[GRPC_PEER_SETTINGS]
                           [GRPC_CHTTP2_SETTINGS_MAX_FRAME_SIZE],
               &s_->stats.outgoing},
-          grpc_core::ConcatMetadata(
-              grpc_core::MetadataArray(
-                  extra_headers_for_trailing_metadata_,
-                  num_extra_headers_for_trailing_metadata_),
-              *s_->send_trailing_metadata),
-          &t_->outbuf);
+          *s_->send_trailing_metadata, &t_->outbuf);
     }
     write_context_->IncTrailingMetadataWrites();
     grpc_chttp2_reset_ping_clock(t_);
@@ -605,18 +543,10 @@ class StreamWriteContext {
         gpr_log(GPR_INFO, "not sending initial_metadata (Trailers-Only)"));
     // When sending Trailers-Only, we need to move the :status and
     // content-type headers to the trailers.
-    if (s_->send_initial_metadata->legacy_index()->named.status != nullptr) {
-      extra_headers_for_trailing_metadata_
-          [num_extra_headers_for_trailing_metadata_++] =
-              &s_->send_initial_metadata->legacy_index()->named.status->md;
-    }
-    if (s_->send_initial_metadata->legacy_index()->named.content_type !=
-        nullptr) {
-      extra_headers_for_trailing_metadata_
-          [num_extra_headers_for_trailing_metadata_++] =
-              &s_->send_initial_metadata->legacy_index()
-                   ->named.content_type->md;
-    }
+    send_status_ =
+        s_->send_initial_metadata->get(grpc_core::HttpStatusMetadata());
+    send_content_type_ =
+        s_->send_initial_metadata->get(grpc_core::ContentTypeMetadata());
   }
 
   void SentLastFrame() {
@@ -641,8 +571,9 @@ class StreamWriteContext {
   grpc_chttp2_transport* const t_;
   grpc_chttp2_stream* const s_;
   bool stream_became_writable_ = false;
-  grpc_mdelem* extra_headers_for_trailing_metadata_[2];
-  size_t num_extra_headers_for_trailing_metadata_ = 0;
+  absl::optional<uint32_t> send_status_;
+  absl::optional<grpc_core::ContentTypeMetadata::ValueType> send_content_type_ =
+      {};
 };
 }  // namespace
 

data/src/core/ext/transport/inproc/inproc_plugin.cc

@@ -22,7 +22,3 @@
 #include "src/core/lib/debug/trace.h"
 
 grpc_core::TraceFlag grpc_inproc_trace(false, "inproc");
-
-void grpc_inproc_plugin_init(void) { grpc_inproc_transport_init(); }
-
-void grpc_inproc_plugin_shutdown(void) { grpc_inproc_transport_shutdown(); }

data/src/core/ext/transport/inproc/inproc_transport.cc

@@ -46,12 +46,6 @@
   } while (0)
 
 namespace {
-grpc_slice g_empty_slice;
-grpc_slice g_fake_path_key;
-grpc_slice g_fake_path_value;
-grpc_slice g_fake_auth_key;
-grpc_slice g_fake_auth_value;
-
 struct inproc_stream;
 bool cancel_stream_locked(inproc_stream* s, grpc_error_handle error);
 void maybe_process_ops_locked(inproc_stream* s, grpc_error_handle error);
@@ -280,13 +274,10 @@ struct inproc_stream {
 
 void log_metadata(const grpc_metadata_batch* md_batch, bool is_client,
                   bool is_initial) {
-  md_batch->ForEach([=](grpc_mdelem md) {
-    char* key = grpc_slice_to_c_string(GRPC_MDKEY(md));
-    char* value = grpc_slice_to_c_string(GRPC_MDVALUE(md));
-    gpr_log(GPR_INFO, "INPROC:%s:%s: %s: %s", is_initial ? "HDR" : "TRL",
-            is_client ? "CLI" : "SVR", key, value);
-    gpr_free(key);
-    gpr_free(value);
+  std::string prefix = absl::StrCat(
+      "INPROC:", is_initial ? "HDR:" : "TRL:", is_client ? "CLI:" : "SVR:");
+  md_batch->Log([&prefix](absl::string_view key, absl::string_view value) {
+    gpr_log(GPR_INFO, "%s", absl::StrCat(prefix, key, ": ", value).c_str());
   });
 }
 
@@ -296,19 +287,9 @@ class CopySink {
  public:
   explicit CopySink(grpc_metadata_batch* dst) : dst_(dst) {}
 
-  void Encode(grpc_mdelem md) {
-    // Differently to grpc_metadata_batch_copy, we always copy slices here so
-    // that we don't need to deal with the plethora of edge cases in that world.
-    // TODO(ctiller): revisit this when deleting mdelem.
-    md = grpc_mdelem_from_slices(grpc_slice_intern(GRPC_MDKEY(md)),
-                                 grpc_slice_copy(GRPC_MDVALUE(md)));
-    // Error unused in non-debug builds.
-    grpc_error_handle GRPC_UNUSED error = dst_->Append(md);
-    // The only way that Append() can fail is if
-    // there's a duplicate entry for a callout.  However, that can't be
-    // the case here, because we would not have been allowed to create
-    // a source batch that had that kind of conflict.
-    GPR_DEBUG_ASSERT(error == GRPC_ERROR_NONE);
+  void Encode(const grpc_core::Slice& key, const grpc_core::Slice& value) {
+    dst_->Append(key.as_string_view(), value.AsOwned(),
+                 [](absl::string_view, const grpc_core::Slice&) {});
   }
 
   template <class T, class V>
@@ -462,14 +443,10 @@ void fail_helper_locked(inproc_stream* s, grpc_error_handle error) {
       // If this is a server, provide initial metadata with a path and authority
       // since it expects that as well as no error yet
       grpc_metadata_batch fake_md(s->arena);
-      grpc_linked_mdelem* path_md =
-          static_cast<grpc_linked_mdelem*>(s->arena->Alloc(sizeof(*path_md)));
-      path_md->md = grpc_mdelem_from_slices(g_fake_path_key, g_fake_path_value);
-      GPR_ASSERT(fake_md.LinkTail(path_md) == GRPC_ERROR_NONE);
-      grpc_linked_mdelem* auth_md =
-          static_cast<grpc_linked_mdelem*>(s->arena->Alloc(sizeof(*auth_md)));
-      auth_md->md = grpc_mdelem_from_slices(g_fake_auth_key, g_fake_auth_value);
-      GPR_ASSERT(fake_md.LinkTail(auth_md) == GRPC_ERROR_NONE);
+      fake_md.Set(grpc_core::HttpPathMetadata(),
+                  grpc_core::Slice::FromStaticString("/"));
+      fake_md.Set(grpc_core::HttpAuthorityMetadata(),
+                  grpc_core::Slice::FromStaticString("inproc-fail"));
 
       (void)fill_in_metadata(
           s, &fake_md, 0,
@@ -1260,26 +1237,6 @@ void inproc_transports_create(grpc_transport** server_transport,
 }
 }  // namespace
 
-/*******************************************************************************
- * GLOBAL INIT AND DESTROY
- */
-void grpc_inproc_transport_init(void) {
-  grpc_core::ExecCtx exec_ctx;
-  g_empty_slice = grpc_core::ExternallyManagedSlice();
-
-  grpc_slice key_tmp = grpc_slice_from_static_string(":path");
-  g_fake_path_key = grpc_slice_intern(key_tmp);
-  grpc_slice_unref_internal(key_tmp);
-
-  g_fake_path_value = grpc_slice_from_static_string("/");
-
-  grpc_slice auth_tmp = grpc_slice_from_static_string(":authority");
-  g_fake_auth_key = grpc_slice_intern(auth_tmp);
-  grpc_slice_unref_internal(auth_tmp);
-
-  g_fake_auth_value = grpc_slice_from_static_string("inproc-fail");
-}
-
 grpc_channel* grpc_inproc_channel_create(grpc_server* server,
                                          const grpc_channel_args* args,
                                          void* /*reserved*/) {
@@ -1358,12 +1315,3 @@ grpc_channel* grpc_inproc_channel_create(grpc_server* server,
 
   return channel;
 }
-
-void grpc_inproc_transport_shutdown(void) {
-  grpc_core::ExecCtx exec_ctx;
-  grpc_slice_unref_internal(g_empty_slice);
-  grpc_slice_unref_internal(g_fake_path_key);
-  grpc_slice_unref_internal(g_fake_path_value);
-  grpc_slice_unref_internal(g_fake_auth_key);
-  grpc_slice_unref_internal(g_fake_auth_value);
-}

data/src/core/ext/transport/inproc/inproc_transport.h

@@ -29,7 +29,4 @@ grpc_channel* grpc_inproc_channel_create(grpc_server* server,
 
 extern grpc_core::TraceFlag grpc_inproc_trace;
 
-void grpc_inproc_transport_init(void);
-void grpc_inproc_transport_shutdown(void);
-
 #endif /* GRPC_CORE_EXT_TRANSPORT_INPROC_INPROC_TRANSPORT_H */

data/src/core/ext/upb-generated/envoy/extensions/filters/http/rbac/v3/rbac.upb.c

@@ -0,0 +1,61 @@
+/* This file was generated by upbc (the upb compiler) from the input
+ * file:
+ *
+ *     envoy/extensions/filters/http/rbac/v3/rbac.proto
+ *
+ * Do not edit -- your changes will be discarded when the file is
+ * regenerated. */
+
+#include <stddef.h>
+#include "upb/msg_internal.h"
+#include "envoy/extensions/filters/http/rbac/v3/rbac.upb.h"
+#include "envoy/config/rbac/v3/rbac.upb.h"
+#include "udpa/annotations/status.upb.h"
+#include "udpa/annotations/versioning.upb.h"
+
+#include "upb/port_def.inc"
+
+static const upb_msglayout_sub envoy_extensions_filters_http_rbac_v3_RBAC_submsgs[1] = {
+  {.submsg = &envoy_config_rbac_v3_RBAC_msginit},
+};
+
+static const upb_msglayout_field envoy_extensions_filters_http_rbac_v3_RBAC__fields[3] = {
+  {1, UPB_SIZE(12, 24), 1, 0, 11, _UPB_MODE_SCALAR | (_UPB_REP_PTR << _UPB_REP_SHIFT)},
+  {2, UPB_SIZE(16, 32), 2, 0, 11, _UPB_MODE_SCALAR | (_UPB_REP_PTR << _UPB_REP_SHIFT)},
+  {3, UPB_SIZE(4, 8), 0, 0, 9, _UPB_MODE_SCALAR | (_UPB_REP_STRVIEW << _UPB_REP_SHIFT)},
+};
+
+const upb_msglayout envoy_extensions_filters_http_rbac_v3_RBAC_msginit = {
+  &envoy_extensions_filters_http_rbac_v3_RBAC_submsgs[0],
+  &envoy_extensions_filters_http_rbac_v3_RBAC__fields[0],
+  UPB_SIZE(24, 48), 3, _UPB_MSGEXT_NONE, 3, 255,
+};
+
+static const upb_msglayout_sub envoy_extensions_filters_http_rbac_v3_RBACPerRoute_submsgs[1] = {
+  {.submsg = &envoy_extensions_filters_http_rbac_v3_RBAC_msginit},
+};
+
+static const upb_msglayout_field envoy_extensions_filters_http_rbac_v3_RBACPerRoute__fields[1] = {
+  {2, UPB_SIZE(4, 8), 1, 0, 11, _UPB_MODE_SCALAR | (_UPB_REP_PTR << _UPB_REP_SHIFT)},
+};
+
+const upb_msglayout envoy_extensions_filters_http_rbac_v3_RBACPerRoute_msginit = {
+  &envoy_extensions_filters_http_rbac_v3_RBACPerRoute_submsgs[0],
+  &envoy_extensions_filters_http_rbac_v3_RBACPerRoute__fields[0],
+  UPB_SIZE(8, 16), 1, _UPB_MSGEXT_NONE, 0, 255,
+};
+
+static const upb_msglayout *messages_layout[2] = {
+  &envoy_extensions_filters_http_rbac_v3_RBAC_msginit,
+  &envoy_extensions_filters_http_rbac_v3_RBACPerRoute_msginit,
+};
+
+const upb_msglayout_file envoy_extensions_filters_http_rbac_v3_rbac_proto_upb_file_layout = {
+  messages_layout,
+  NULL,
+  2,
+  0,
+};
+
+#include "upb/port_undef.inc"
+

data/src/core/ext/upb-generated/envoy/extensions/filters/http/rbac/v3/rbac.upb.h

@@ -0,0 +1,146 @@
+/* This file was generated by upbc (the upb compiler) from the input
+ * file:
+ *
+ *     envoy/extensions/filters/http/rbac/v3/rbac.proto
+ *
+ * Do not edit -- your changes will be discarded when the file is
+ * regenerated. */
+
+#ifndef ENVOY_EXTENSIONS_FILTERS_HTTP_RBAC_V3_RBAC_PROTO_UPB_H_
+#define ENVOY_EXTENSIONS_FILTERS_HTTP_RBAC_V3_RBAC_PROTO_UPB_H_
+
+#include "upb/msg_internal.h"
+#include "upb/decode.h"
+#include "upb/decode_fast.h"
+#include "upb/encode.h"
+
+#include "upb/port_def.inc"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct envoy_extensions_filters_http_rbac_v3_RBAC;
+struct envoy_extensions_filters_http_rbac_v3_RBACPerRoute;
+typedef struct envoy_extensions_filters_http_rbac_v3_RBAC envoy_extensions_filters_http_rbac_v3_RBAC;
+typedef struct envoy_extensions_filters_http_rbac_v3_RBACPerRoute envoy_extensions_filters_http_rbac_v3_RBACPerRoute;
+extern const upb_msglayout envoy_extensions_filters_http_rbac_v3_RBAC_msginit;
+extern const upb_msglayout envoy_extensions_filters_http_rbac_v3_RBACPerRoute_msginit;
+struct envoy_config_rbac_v3_RBAC;
+extern const upb_msglayout envoy_config_rbac_v3_RBAC_msginit;
+
+
+/* envoy.extensions.filters.http.rbac.v3.RBAC */
+
+UPB_INLINE envoy_extensions_filters_http_rbac_v3_RBAC *envoy_extensions_filters_http_rbac_v3_RBAC_new(upb_arena *arena) {
+  return (envoy_extensions_filters_http_rbac_v3_RBAC *)_upb_msg_new(&envoy_extensions_filters_http_rbac_v3_RBAC_msginit, arena);
+}
+UPB_INLINE envoy_extensions_filters_http_rbac_v3_RBAC *envoy_extensions_filters_http_rbac_v3_RBAC_parse(const char *buf, size_t size,
+                        upb_arena *arena) {
+  envoy_extensions_filters_http_rbac_v3_RBAC *ret = envoy_extensions_filters_http_rbac_v3_RBAC_new(arena);
+  if (!ret) return NULL;
+  if (!upb_decode(buf, size, ret, &envoy_extensions_filters_http_rbac_v3_RBAC_msginit, arena)) return NULL;
+  return ret;
+}
+UPB_INLINE envoy_extensions_filters_http_rbac_v3_RBAC *envoy_extensions_filters_http_rbac_v3_RBAC_parse_ex(const char *buf, size_t size,
+                           const upb_extreg *extreg, int options,
+                           upb_arena *arena) {
+  envoy_extensions_filters_http_rbac_v3_RBAC *ret = envoy_extensions_filters_http_rbac_v3_RBAC_new(arena);
+  if (!ret) return NULL;
+  if (!_upb_decode(buf, size, ret, &envoy_extensions_filters_http_rbac_v3_RBAC_msginit, extreg, options, arena)) {
+    return NULL;
+  }
+  return ret;
+}
+UPB_INLINE char *envoy_extensions_filters_http_rbac_v3_RBAC_serialize(const envoy_extensions_filters_http_rbac_v3_RBAC *msg, upb_arena *arena, size_t *len) {
+  return upb_encode(msg, &envoy_extensions_filters_http_rbac_v3_RBAC_msginit, arena, len);
+}
+
+UPB_INLINE bool envoy_extensions_filters_http_rbac_v3_RBAC_has_rules(const envoy_extensions_filters_http_rbac_v3_RBAC *msg) { return _upb_hasbit(msg, 1); }
+UPB_INLINE const struct envoy_config_rbac_v3_RBAC* envoy_extensions_filters_http_rbac_v3_RBAC_rules(const envoy_extensions_filters_http_rbac_v3_RBAC *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(12, 24), const struct envoy_config_rbac_v3_RBAC*); }
+UPB_INLINE bool envoy_extensions_filters_http_rbac_v3_RBAC_has_shadow_rules(const envoy_extensions_filters_http_rbac_v3_RBAC *msg) { return _upb_hasbit(msg, 2); }
+UPB_INLINE const struct envoy_config_rbac_v3_RBAC* envoy_extensions_filters_http_rbac_v3_RBAC_shadow_rules(const envoy_extensions_filters_http_rbac_v3_RBAC *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(16, 32), const struct envoy_config_rbac_v3_RBAC*); }
+UPB_INLINE upb_strview envoy_extensions_filters_http_rbac_v3_RBAC_shadow_rules_stat_prefix(const envoy_extensions_filters_http_rbac_v3_RBAC *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(4, 8), upb_strview); }
+
+UPB_INLINE void envoy_extensions_filters_http_rbac_v3_RBAC_set_rules(envoy_extensions_filters_http_rbac_v3_RBAC *msg, struct envoy_config_rbac_v3_RBAC* value) {
+  _upb_sethas(msg, 1);
+  *UPB_PTR_AT(msg, UPB_SIZE(12, 24), struct envoy_config_rbac_v3_RBAC*) = value;
+}
+UPB_INLINE struct envoy_config_rbac_v3_RBAC* envoy_extensions_filters_http_rbac_v3_RBAC_mutable_rules(envoy_extensions_filters_http_rbac_v3_RBAC *msg, upb_arena *arena) {
+  struct envoy_config_rbac_v3_RBAC* sub = (struct envoy_config_rbac_v3_RBAC*)envoy_extensions_filters_http_rbac_v3_RBAC_rules(msg);
+  if (sub == NULL) {
+    sub = (struct envoy_config_rbac_v3_RBAC*)_upb_msg_new(&envoy_config_rbac_v3_RBAC_msginit, arena);
+    if (!sub) return NULL;
+    envoy_extensions_filters_http_rbac_v3_RBAC_set_rules(msg, sub);
+  }
+  return sub;
+}
+UPB_INLINE void envoy_extensions_filters_http_rbac_v3_RBAC_set_shadow_rules(envoy_extensions_filters_http_rbac_v3_RBAC *msg, struct envoy_config_rbac_v3_RBAC* value) {
+  _upb_sethas(msg, 2);
+  *UPB_PTR_AT(msg, UPB_SIZE(16, 32), struct envoy_config_rbac_v3_RBAC*) = value;
+}
+UPB_INLINE struct envoy_config_rbac_v3_RBAC* envoy_extensions_filters_http_rbac_v3_RBAC_mutable_shadow_rules(envoy_extensions_filters_http_rbac_v3_RBAC *msg, upb_arena *arena) {
+  struct envoy_config_rbac_v3_RBAC* sub = (struct envoy_config_rbac_v3_RBAC*)envoy_extensions_filters_http_rbac_v3_RBAC_shadow_rules(msg);
+  if (sub == NULL) {
+    sub = (struct envoy_config_rbac_v3_RBAC*)_upb_msg_new(&envoy_config_rbac_v3_RBAC_msginit, arena);
+    if (!sub) return NULL;
+    envoy_extensions_filters_http_rbac_v3_RBAC_set_shadow_rules(msg, sub);
+  }
+  return sub;
+}
+UPB_INLINE void envoy_extensions_filters_http_rbac_v3_RBAC_set_shadow_rules_stat_prefix(envoy_extensions_filters_http_rbac_v3_RBAC *msg, upb_strview value) {
+  *UPB_PTR_AT(msg, UPB_SIZE(4, 8), upb_strview) = value;
+}
+
+/* envoy.extensions.filters.http.rbac.v3.RBACPerRoute */
+
+UPB_INLINE envoy_extensions_filters_http_rbac_v3_RBACPerRoute *envoy_extensions_filters_http_rbac_v3_RBACPerRoute_new(upb_arena *arena) {
+  return (envoy_extensions_filters_http_rbac_v3_RBACPerRoute *)_upb_msg_new(&envoy_extensions_filters_http_rbac_v3_RBACPerRoute_msginit, arena);
+}
+UPB_INLINE envoy_extensions_filters_http_rbac_v3_RBACPerRoute *envoy_extensions_filters_http_rbac_v3_RBACPerRoute_parse(const char *buf, size_t size,
+                        upb_arena *arena) {
+  envoy_extensions_filters_http_rbac_v3_RBACPerRoute *ret = envoy_extensions_filters_http_rbac_v3_RBACPerRoute_new(arena);
+  if (!ret) return NULL;
+  if (!upb_decode(buf, size, ret, &envoy_extensions_filters_http_rbac_v3_RBACPerRoute_msginit, arena)) return NULL;
+  return ret;
+}
+UPB_INLINE envoy_extensions_filters_http_rbac_v3_RBACPerRoute *envoy_extensions_filters_http_rbac_v3_RBACPerRoute_parse_ex(const char *buf, size_t size,
+                           const upb_extreg *extreg, int options,
+                           upb_arena *arena) {
+  envoy_extensions_filters_http_rbac_v3_RBACPerRoute *ret = envoy_extensions_filters_http_rbac_v3_RBACPerRoute_new(arena);
+  if (!ret) return NULL;
+  if (!_upb_decode(buf, size, ret, &envoy_extensions_filters_http_rbac_v3_RBACPerRoute_msginit, extreg, options, arena)) {
+    return NULL;
+  }
+  return ret;
+}
+UPB_INLINE char *envoy_extensions_filters_http_rbac_v3_RBACPerRoute_serialize(const envoy_extensions_filters_http_rbac_v3_RBACPerRoute *msg, upb_arena *arena, size_t *len) {
+  return upb_encode(msg, &envoy_extensions_filters_http_rbac_v3_RBACPerRoute_msginit, arena, len);
+}
+
+UPB_INLINE bool envoy_extensions_filters_http_rbac_v3_RBACPerRoute_has_rbac(const envoy_extensions_filters_http_rbac_v3_RBACPerRoute *msg) { return _upb_hasbit(msg, 1); }
+UPB_INLINE const envoy_extensions_filters_http_rbac_v3_RBAC* envoy_extensions_filters_http_rbac_v3_RBACPerRoute_rbac(const envoy_extensions_filters_http_rbac_v3_RBACPerRoute *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(4, 8), const envoy_extensions_filters_http_rbac_v3_RBAC*); }
+
+UPB_INLINE void envoy_extensions_filters_http_rbac_v3_RBACPerRoute_set_rbac(envoy_extensions_filters_http_rbac_v3_RBACPerRoute *msg, envoy_extensions_filters_http_rbac_v3_RBAC* value) {
+  _upb_sethas(msg, 1);
+  *UPB_PTR_AT(msg, UPB_SIZE(4, 8), envoy_extensions_filters_http_rbac_v3_RBAC*) = value;
+}
+UPB_INLINE struct envoy_extensions_filters_http_rbac_v3_RBAC* envoy_extensions_filters_http_rbac_v3_RBACPerRoute_mutable_rbac(envoy_extensions_filters_http_rbac_v3_RBACPerRoute *msg, upb_arena *arena) {
+  struct envoy_extensions_filters_http_rbac_v3_RBAC* sub = (struct envoy_extensions_filters_http_rbac_v3_RBAC*)envoy_extensions_filters_http_rbac_v3_RBACPerRoute_rbac(msg);
+  if (sub == NULL) {
+    sub = (struct envoy_extensions_filters_http_rbac_v3_RBAC*)_upb_msg_new(&envoy_extensions_filters_http_rbac_v3_RBAC_msginit, arena);
+    if (!sub) return NULL;
+    envoy_extensions_filters_http_rbac_v3_RBACPerRoute_set_rbac(msg, sub);
+  }
+  return sub;
+}
+
+extern const upb_msglayout_file envoy_extensions_filters_http_rbac_v3_rbac_proto_upb_file_layout;
+
+#ifdef __cplusplus
+}  /* extern "C" */
+#endif
+
+#include "upb/port_undef.inc"
+
+#endif  /* ENVOY_EXTENSIONS_FILTERS_HTTP_RBAC_V3_RBAC_PROTO_UPB_H_ */