grpc 1.41.1 → 1.44.0.pre2

data/src/core/{ext/filters/client_channel → lib/service_config}/service_config.cc

@@ -16,7 +16,7 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/ext/filters/client_channel/service_config.h"
+#include "src/core/lib/service_config/service_config.h"
 
 #include <string>
 
@@ -24,8 +24,8 @@
 
 #include <grpc/support/log.h>
 
-#include "src/core/ext/filters/client_channel/service_config_parser.h"
 #include "src/core/lib/json/json.h"
+#include "src/core/lib/service_config/service_config_parser.h"
 #include "src/core/lib/slice/slice_internal.h"
 
 namespace grpc_core {

data/src/core/{ext/filters/client_channel → lib/service_config}/service_config.h

@@ -14,8 +14,8 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SERVICE_CONFIG_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SERVICE_CONFIG_H
+#ifndef GRPC_CORE_LIB_SERVICE_CONFIG_SERVICE_CONFIG_H
+#define GRPC_CORE_LIB_SERVICE_CONFIG_SERVICE_CONFIG_H
 
 #include <grpc/support/port_platform.h>
 
@@ -26,11 +26,11 @@
 #include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/support/string_util.h>
 
-#include "src/core/ext/filters/client_channel/service_config_parser.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/json/json.h"
+#include "src/core/lib/service_config/service_config_parser.h"
 #include "src/core/lib/slice/slice_internal.h"
 
 // The main purpose of the code here is to parse the service config in
@@ -124,4 +124,4 @@ class ServiceConfig : public RefCounted<ServiceConfig> {
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SERVICE_CONFIG_H */
+#endif /* GRPC_CORE_LIB_SERVICE_CONFIG_SERVICE_CONFIG_H */

data/src/core/lib/service_config/service_config_call_data.h

@@ -0,0 +1,72 @@
+//
+// Copyright 2016 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_SERVICE_CONFIG_SERVICE_CONFIG_CALL_DATA_H
+#define GRPC_CORE_LIB_SERVICE_CONFIG_SERVICE_CONFIG_CALL_DATA_H
+
+#include <grpc/support/port_platform.h>
+
+#include <map>
+
+#include "absl/strings/string_view.h"
+
+#include "src/core/lib/channel/context.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/service_config/service_config.h"
+#include "src/core/lib/service_config/service_config_parser.h"
+
+namespace grpc_core {
+
+/// Stores the service config data associated with an individual call.
+/// A pointer to this object is stored in the call_context
+/// GRPC_CONTEXT_SERVICE_CONFIG_CALL_DATA element, so that filters can
+/// easily access method and global parameters for the call.
+class ServiceConfigCallData {
+ public:
+  using CallAttributes = std::map<const char*, absl::string_view>;
+
+  ServiceConfigCallData() : method_configs_(nullptr) {}
+
+  ServiceConfigCallData(
+      RefCountedPtr<ServiceConfig> service_config,
+      const ServiceConfigParser::ParsedConfigVector* method_configs,
+      CallAttributes call_attributes)
+      : service_config_(std::move(service_config)),
+        method_configs_(method_configs),
+        call_attributes_(std::move(call_attributes)) {}
+
+  ServiceConfig* service_config() { return service_config_.get(); }
+
+  ServiceConfigParser::ParsedConfig* GetMethodParsedConfig(size_t index) const {
+    return method_configs_ != nullptr ? (*method_configs_)[index].get()
+                                      : nullptr;
+  }
+
+  ServiceConfigParser::ParsedConfig* GetGlobalParsedConfig(size_t index) const {
+    return service_config_->GetGlobalParsedConfig(index);
+  }
+
+  const CallAttributes& call_attributes() const { return call_attributes_; }
+
+ private:
+  RefCountedPtr<ServiceConfig> service_config_;
+  const ServiceConfigParser::ParsedConfigVector* method_configs_;
+  CallAttributes call_attributes_;
+};
+
+}  // namespace grpc_core
+
+#endif /* GRPC_CORE_LIB_SERVICE_CONFIG_SERVICE_CONFIG_CALL_DATA_H */

data/src/core/{ext/filters/client_channel → lib/service_config}/service_config_parser.cc

@@ -16,7 +16,7 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/ext/filters/client_channel/service_config_parser.h"
+#include "src/core/lib/service_config/service_config_parser.h"
 
 #include <grpc/support/log.h>
 
@@ -29,12 +29,12 @@ typedef absl::InlinedVector<std::unique_ptr<ServiceConfigParser::Parser>,
 ServiceConfigParserList* g_registered_parsers;
 }  // namespace
 
-void ServiceConfigParser::Init() {
+void ServiceConfigParserInit() {
   GPR_ASSERT(g_registered_parsers == nullptr);
   g_registered_parsers = new ServiceConfigParserList();
 }
 
-void ServiceConfigParser::Shutdown() {
+void ServiceConfigParserShutdown() {
   delete g_registered_parsers;
   g_registered_parsers = nullptr;
 }

data/src/core/{ext/filters/client_channel → lib/service_config}/service_config_parser.h

@@ -14,8 +14,8 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SERVICE_CONFIG_PARSER_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SERVICE_CONFIG_PARSER_H
+#ifndef GRPC_CORE_LIB_SERVICE_CONFIG_SERVICE_CONFIG_PARSER_H
+#define GRPC_CORE_LIB_SERVICE_CONFIG_SERVICE_CONFIG_PARSER_H
 
 #include <grpc/support/port_platform.h>
 
@@ -30,6 +30,11 @@
 
 namespace grpc_core {
 
+// Initialization functions for ServiceConfigParser. ServiceConfigParser should
+// be initialized before any parser implementation is registered.
+void ServiceConfigParserInit();
+void ServiceConfigParserShutdown();
+
 // Service config parser registry.
 // See service_config.h for more information.
 class ServiceConfigParser {
@@ -70,9 +75,6 @@ class ServiceConfigParser {
                               kNumPreallocatedParsers>
       ParsedConfigVector;
 
-  static void Init();
-  static void Shutdown();
-
   /// Globally register a service config parser. On successful registration, it
   /// returns the index at which the parser was registered. On failure, -1 is
   /// returned. Each new service config update will go through all the
@@ -92,4 +94,4 @@ class ServiceConfigParser {
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SERVICE_CONFIG_PARSER_H */
+#endif /* GRPC_CORE_LIB_SERVICE_CONFIG_SERVICE_CONFIG_PARSER_H */

data/src/core/lib/slice/percent_encoding.cc

@@ -51,7 +51,7 @@ class UrlTable : public BitSet<256> {
   }
 };
 
-static GRPC_PCTENCODE_CONSTEXPR_VALUE UrlTable g_url_table;
+GRPC_PCTENCODE_CONSTEXPR_VALUE UrlTable g_url_table;
 
 class CompatibleTable : public BitSet<256> {
  public:
@@ -63,7 +63,7 @@ class CompatibleTable : public BitSet<256> {
   }
 };
 
-static GRPC_PCTENCODE_CONSTEXPR_VALUE CompatibleTable g_compatible_table;
+GRPC_PCTENCODE_CONSTEXPR_VALUE CompatibleTable g_compatible_table;
 
 // Map PercentEncodingType to a lookup table of legal symbols for that encoding.
 const BitSet<256>& LookupTableForPercentEncodingType(PercentEncodingType type) {
@@ -78,135 +78,79 @@ const BitSet<256>& LookupTableForPercentEncodingType(PercentEncodingType type) {
 }
 }  // namespace
 
-grpc_slice PercentEncodeSlice(const grpc_slice& slice,
-                              PercentEncodingType type) {
+Slice PercentEncodeSlice(Slice slice, PercentEncodingType type) {
   static const uint8_t hex[] = "0123456789ABCDEF";
 
   const BitSet<256>& lut = LookupTableForPercentEncodingType(type);
 
   // first pass: count the number of bytes needed to output this string
   size_t output_length = 0;
-  const uint8_t* slice_start = GRPC_SLICE_START_PTR(slice);
-  const uint8_t* slice_end = GRPC_SLICE_END_PTR(slice);
-  const uint8_t* p;
   bool any_reserved_bytes = false;
-  for (p = slice_start; p < slice_end; p++) {
-    bool unres = lut.is_set(*p);
+  for (uint8_t c : slice) {
+    bool unres = lut.is_set(c);
     output_length += unres ? 1 : 3;
     any_reserved_bytes |= !unres;
   }
   // no unreserved bytes: return the string unmodified
   if (!any_reserved_bytes) {
-    return grpc_slice_ref_internal(slice);
+    return slice;
   }
   // second pass: actually encode
-  grpc_slice out = GRPC_SLICE_MALLOC(output_length);
-  uint8_t* q = GRPC_SLICE_START_PTR(out);
-  for (p = slice_start; p < slice_end; p++) {
-    if (lut.is_set(*p)) {
-      *q++ = *p;
+  auto out = MutableSlice::CreateUninitialized(output_length);
+  uint8_t* q = out.begin();
+  for (uint8_t c : slice) {
+    if (lut.is_set(c)) {
+      *q++ = c;
     } else {
       *q++ = '%';
-      *q++ = hex[*p >> 4];
-      *q++ = hex[*p & 15];
+      *q++ = hex[c >> 4];
+      *q++ = hex[c & 15];
     }
   }
-  GPR_ASSERT(q == GRPC_SLICE_END_PTR(out));
-  return out;
+  GPR_ASSERT(q == out.end());
+  return Slice(std::move(out));
 }
 
-static bool valid_hex(const uint8_t* p, const uint8_t* end) {
+static bool ValidHex(const uint8_t* p, const uint8_t* end) {
   if (p >= end) return false;
   return (*p >= '0' && *p <= '9') || (*p >= 'a' && *p <= 'f') ||
          (*p >= 'A' && *p <= 'F');
 }
 
-static uint8_t dehex(uint8_t c) {
+static uint8_t DeHex(uint8_t c) {
   if (c >= '0' && c <= '9') return static_cast<uint8_t>(c - '0');
   if (c >= 'A' && c <= 'F') return static_cast<uint8_t>(c - 'A' + 10);
   if (c >= 'a' && c <= 'f') return static_cast<uint8_t>(c - 'a' + 10);
   GPR_UNREACHABLE_CODE(return 255);
 }
 
-absl::optional<grpc_slice> PercentDecodeSlice(const grpc_slice& slice_in,
-                                              PercentEncodingType type) {
-  const uint8_t* p = GRPC_SLICE_START_PTR(slice_in);
-  const uint8_t* in_end = GRPC_SLICE_END_PTR(slice_in);
-  size_t out_length = 0;
+Slice PermissivePercentDecodeSlice(Slice slice_in) {
   bool any_percent_encoded_stuff = false;
-  const BitSet<256>& lut = LookupTableForPercentEncodingType(type);
-  while (p != in_end) {
-    if (*p == '%') {
-      if (!valid_hex(++p, in_end)) return {};
-      if (!valid_hex(++p, in_end)) return {};
-      p++;
-      out_length++;
+  for (uint8_t c : slice_in) {
+    if (c == '%') {
       any_percent_encoded_stuff = true;
-    } else if (lut.is_set(*p)) {
-      p++;
-      out_length++;
-    } else {
-      return {};
-    }
-  }
-  if (!any_percent_encoded_stuff) {
-    return grpc_slice_ref_internal(slice_in);
-  }
-  p = GRPC_SLICE_START_PTR(slice_in);
-  grpc_slice slice_out = GRPC_SLICE_MALLOC(out_length);
-  uint8_t* q = GRPC_SLICE_START_PTR(slice_out);
-  while (p != in_end) {
-    if (*p == '%') {
-      *q++ = static_cast<uint8_t>(dehex(p[1]) << 4) | (dehex(p[2]));
-      p += 3;
-    } else {
-      *q++ = *p++;
+      break;
     }
   }
-  GPR_ASSERT(q == GRPC_SLICE_END_PTR(slice_out));
-  return slice_out;
-}
+  if (!any_percent_encoded_stuff) return slice_in;
 
-grpc_slice PermissivePercentDecodeSlice(const grpc_slice& slice_in) {
-  const uint8_t* p = GRPC_SLICE_START_PTR(slice_in);
-  const uint8_t* in_end = GRPC_SLICE_END_PTR(slice_in);
-  size_t out_length = 0;
-  bool any_percent_encoded_stuff = false;
-  while (p != in_end) {
-    if (*p == '%') {
-      if (!valid_hex(p + 1, in_end) || !valid_hex(p + 2, in_end)) {
-        p++;
-        out_length++;
-      } else {
-        p += 3;
-        out_length++;
-        any_percent_encoded_stuff = true;
-      }
-    } else {
-      p++;
-      out_length++;
-    }
-  }
-  if (!any_percent_encoded_stuff) {
-    return grpc_slice_ref_internal(slice_in);
-  }
-  p = GRPC_SLICE_START_PTR(slice_in);
-  grpc_slice out = GRPC_SLICE_MALLOC(out_length);
-  uint8_t* q = GRPC_SLICE_START_PTR(out);
-  while (p != in_end) {
+  MutableSlice out = slice_in.TakeMutable();
+  uint8_t* q = out.begin();
+  const uint8_t* p = out.begin();
+  const uint8_t* end = out.end();
+  while (p != end) {
     if (*p == '%') {
-      if (!valid_hex(p + 1, in_end) || !valid_hex(p + 2, in_end)) {
+      if (!ValidHex(p + 1, end) || !ValidHex(p + 2, end)) {
         *q++ = *p++;
       } else {
-        *q++ = static_cast<uint8_t>(dehex(p[1]) << 4) | (dehex(p[2]));
+        *q++ = static_cast<uint8_t>(DeHex(p[1]) << 4) | (DeHex(p[2]));
         p += 3;
       }
     } else {
       *q++ = *p++;
     }
   }
-  GPR_ASSERT(q == GRPC_SLICE_END_PTR(out));
-  return out;
+  return Slice(out.TakeSubSlice(0, q - out.begin()));
 }
 
 }  // namespace grpc_core

data/src/core/lib/slice/percent_encoding.h

@@ -34,32 +34,26 @@
 
 #include <grpc/slice.h>
 
+#include "src/core/lib/slice/slice.h"
+
 namespace grpc_core {
 
 enum class PercentEncodingType {
   // Flags [A-Za-z0-9-_.~] as unreserved bytes for the percent encoding routines
   URL,
   // Flags ascii7 non-control characters excluding '%' as unreserved bytes for
-  // the
-  // percent encoding routines
+  // the percent encoding routines
   Compatible
 };
 
 // Percent-encode a slice, returning the new slice (this cannot fail):
 // unreserved_bytes is a bitfield indicating which bytes are considered
 // unreserved and thus do not need percent encoding
-grpc_slice PercentEncodeSlice(const grpc_slice& slice,
-                              PercentEncodingType type);
-// Percent-decode a slice, strictly.
-// If the input is legal (contains no unreserved bytes, and legal % encodings),
-// returns the decoded slice.
-// If the input is not legal, returns {}.
-absl::optional<grpc_slice> PercentDecodeSlice(const grpc_slice& slice_in,
-                                              PercentEncodingType type);
+Slice PercentEncodeSlice(Slice slice, PercentEncodingType type);
 // Percent-decode a slice, permissively.
 // If a % triplet can not be decoded, pass it through verbatim.
 // This cannot fail.
-grpc_slice PermissivePercentDecodeSlice(const grpc_slice& slice_in);
+Slice PermissivePercentDecodeSlice(Slice slice_in);
 
 }  // namespace grpc_core
 

data/src/core/lib/slice/slice.cc

@@ -26,7 +26,6 @@
 
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/ref_counted.h"
-#include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/slice/slice_internal.h"
 
 char* grpc_slice_to_c_string(grpc_slice slice) {
@@ -45,21 +44,6 @@ grpc_slice grpc_slice_copy(grpc_slice s) {
   return out;
 }
 
-/* Public API */
-grpc_slice grpc_slice_ref(grpc_slice slice) {
-  return grpc_slice_ref_internal(slice);
-}
-
-/* Public API */
-void grpc_slice_unref(grpc_slice slice) {
-  if (grpc_core::ExecCtx::Get() == nullptr) {
-    grpc_core::ExecCtx exec_ctx;
-    grpc_slice_unref_internal(slice);
-  } else {
-    grpc_slice_unref_internal(slice);
-  }
-}
-
 namespace grpc_core {
 
 /* grpc_slice_from_static_string support structure - a refcount that does
@@ -85,7 +69,7 @@ class NewSliceRefcount {
 
  private:
   grpc_slice_refcount base_;
-  RefCount refs_;
+  std::atomic<size_t> refs_{1};
   void (*user_destroy_)(void*);
   void* user_data_;
 };
@@ -146,7 +130,7 @@ class NewWithLenSliceRefcount {
 
  private:
   grpc_slice_refcount base_;
-  RefCount refs_;
+  std::atomic<size_t> refs_{1};
   void* user_data_;
   size_t user_length_;
   void (*user_destroy_)(void*, size_t);
@@ -155,7 +139,7 @@ class NewWithLenSliceRefcount {
 /** grpc_slice_from_moved_(string|buffer) ref count .*/
 class MovedStringSliceRefCount {
  public:
-  explicit MovedStringSliceRefCount(grpc_core::UniquePtr<char>&& str)
+  explicit MovedStringSliceRefCount(UniquePtr<char>&& str)
       : base_(grpc_slice_refcount::Type::REGULAR, &refs_, Destroy, this,
               &base_),
         str_(std::move(str)) {}
@@ -168,8 +152,8 @@ class MovedStringSliceRefCount {
   }
 
   grpc_slice_refcount base_;
-  grpc_core::RefCount refs_;
-  grpc_core::UniquePtr<char> str_;
+  std::atomic<size_t> refs_{1};
+  UniquePtr<char> str_;
 };
 
 // grpc_slice_from_cpp_string() ref count.
@@ -188,7 +172,7 @@ class MovedCppStringSliceRefCount {
   }
 
   grpc_slice_refcount base_;
-  grpc_core::RefCount refs_;
+  std::atomic<size_t> refs_{1};
   std::string str_;
 };
 
@@ -231,7 +215,9 @@ grpc_slice grpc_slice_from_copied_buffer(const char* source, size_t length) {
     slice = grpc_core::UnmanagedMemorySlice(
         length, grpc_core::UnmanagedMemorySlice::ForceHeapAllocation());
   }
-  memcpy(GRPC_SLICE_START_PTR(slice), source, length);
+  if (length > 0) {
+    memcpy(GRPC_SLICE_START_PTR(slice), source, length);
+  }
   return slice;
 }
 
@@ -297,7 +283,7 @@ class MallocRefCount {
 
  private:
   grpc_slice_refcount base_;
-  grpc_core::RefCount refs_;
+  std::atomic<size_t> refs_{1};
 };
 
 }  // namespace