grpc 1.50.0 → 1.52.0.pre2

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

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2017 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 2017 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,7 +22,11 @@
 
 #include <string.h>
 
+#include <algorithm>
+#include <vector>
+
 #include "absl/strings/str_cat.h"
+#include "absl/strings/str_join.h"
 
 #include "src/core/lib/gpr/useful.h"
 
@@ -114,6 +118,20 @@ bool grpc_status_code_from_int(int status_int, grpc_status_code* status) {
 
 namespace grpc_core {
 
+namespace internal {
+
+std::string StatusCodeSet::ToString() const {
+  std::vector<absl::string_view> codes;
+  for (size_t i = 0; i < GPR_ARRAY_SIZE(g_status_string_entries); ++i) {
+    if (Contains(g_status_string_entries[i].status)) {
+      codes.emplace_back(g_status_string_entries[i].str);
+    }
+  }
+  return absl::StrCat("{", absl::StrJoin(codes, ","), "}");
+}
+
+}  // namespace internal
+
 absl::Status MaybeRewriteIllegalStatusCode(absl::Status status,
                                            absl::string_view source) {
   switch (status.code()) {

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

@@ -1,26 +1,28 @@
-/*
- *
- * Copyright 2017 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 2017 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_STATUS_UTIL_H
 #define GRPC_CORE_LIB_CHANNEL_STATUS_UTIL_H
 
 #include <grpc/support/port_platform.h>
 
+#include <string>
+
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
 
@@ -47,7 +49,10 @@ class StatusCodeSet {
  public:
   bool Empty() const { return status_code_mask_ == 0; }
 
-  void Add(grpc_status_code status) { status_code_mask_ |= (1 << status); }
+  StatusCodeSet& Add(grpc_status_code status) {
+    status_code_mask_ |= (1 << status);
+    return *this;
+  }
 
   bool Contains(grpc_status_code status) const {
     return status_code_mask_ & (1 << status);
@@ -57,6 +62,8 @@ class StatusCodeSet {
     return status_code_mask_ == other.status_code_mask_;
   }
 
+  std::string ToString() const;
+
  private:
   int status_code_mask_ = 0;  // A bitfield of status codes in the set.
 };
@@ -71,4 +78,4 @@ absl::Status MaybeRewriteIllegalStatusCode(absl::Status status,
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_LIB_CHANNEL_STATUS_UTIL_H */
+#endif  // GRPC_CORE_LIB_CHANNEL_STATUS_UTIL_H

data/src/core/lib/compression/compression.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>
 
@@ -24,7 +24,7 @@
 #include "absl/types/optional.h"
 
 #include <grpc/compression.h>
-#include <grpc/impl/codegen/compression_types.h>
+#include <grpc/impl/compression_types.h>
 #include <grpc/slice.h>
 
 #include "src/core/lib/compression/compression_internal.h"
@@ -73,7 +73,7 @@ grpc_compression_algorithm grpc_compression_algorithm_for_level(
 
 void grpc_compression_options_init(grpc_compression_options* opts) {
   memset(opts, 0, sizeof(*opts));
-  /* all enabled by default */
+  // all enabled by default
   opts->enabled_algorithms_bitset = (1u << GRPC_COMPRESS_ALGORITHMS_COUNT) - 1;
 }
 

data/src/core/lib/compression/compression_internal.cc

@@ -1,36 +1,40 @@
-/*
- *
- * 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>
 
 #include "src/core/lib/compression/compression_internal.h"
 
 #include <stdlib.h>
-#include <string.h>
+
+#include <string>
 
 #include "absl/container/inlined_vector.h"
 #include "absl/strings/ascii.h"
+#include "absl/strings/str_format.h"
 #include "absl/strings/str_split.h"
+#include "absl/types/variant.h"
 
 #include <grpc/support/log.h>
 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
+#include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/surface/api_trace.h"
 
 namespace grpc_core {
@@ -110,9 +114,8 @@ CompressionAlgorithmSet::CompressionAlgorithmForLevel(
   GRPC_API_TRACE("grpc_message_compression_algorithm_for_level(level=%d)", 1,
                  ((int)level));
   if (level > GRPC_COMPRESS_LEVEL_HIGH) {
-    gpr_log(GPR_ERROR, "Unknown message compression level %d.",
-            static_cast<int>(level));
-    abort();
+    Crash(absl::StrFormat("Unknown message compression level %d.",
+                          static_cast<int>(level)));
   }
 
   if (level == GRPC_COMPRESS_LEVEL_NONE) {
@@ -121,10 +124,10 @@ CompressionAlgorithmSet::CompressionAlgorithmForLevel(
 
   GPR_ASSERT(level > 0);
 
-  /* Establish a "ranking" or compression algorithms in increasing order of
-   * compression.
-   * This is simplistic and we will probably want to introduce other dimensions
-   * in the future (cpu/memory cost, etc). */
+  // Establish a "ranking" or compression algorithms in increasing order of
+  // compression.
+  // This is simplistic and we will probably want to introduce other dimensions
+  // in the future (cpu/memory cost, etc).
   absl::InlinedVector<grpc_compression_algorithm,
                       GRPC_COMPRESS_ALGORITHMS_COUNT>
       algos;
@@ -140,7 +143,7 @@ CompressionAlgorithmSet::CompressionAlgorithmForLevel(
 
   switch (level) {
     case GRPC_COMPRESS_LEVEL_NONE:
-      abort(); /* should have been handled already */
+      abort();  // should have been handled already
     case GRPC_COMPRESS_LEVEL_LOW:
       return algos[0];
     case GRPC_COMPRESS_LEVEL_MED:
@@ -163,19 +166,13 @@ CompressionAlgorithmSet CompressionAlgorithmSet::FromUint32(uint32_t value) {
 }
 
 CompressionAlgorithmSet CompressionAlgorithmSet::FromChannelArgs(
-    const grpc_channel_args* args) {
+    const ChannelArgs& args) {
   CompressionAlgorithmSet set;
   static const uint32_t kEverything =
       (1u << GRPC_COMPRESS_ALGORITHMS_COUNT) - 1;
-  if (args != nullptr) {
-    set = CompressionAlgorithmSet::FromUint32(grpc_channel_args_find_integer(
-        args, GRPC_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET,
-        grpc_integer_options{kEverything, 0, kEverything}));
-    set.Set(GRPC_COMPRESS_NONE);
-  } else {
-    set = CompressionAlgorithmSet::FromUint32(kEverything);
-  }
-  return set;
+  return CompressionAlgorithmSet::FromUint32(
+      args.GetInt(GRPC_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET)
+          .value_or(kEverything));
 }
 
 CompressionAlgorithmSet::CompressionAlgorithmSet() = default;
@@ -230,18 +227,14 @@ uint32_t CompressionAlgorithmSet::ToLegacyBitmask() const {
 }
 
 absl::optional<grpc_compression_algorithm>
-DefaultCompressionAlgorithmFromChannelArgs(const grpc_channel_args* args) {
-  if (args == nullptr) return absl::nullopt;
-  for (size_t i = 0; i < args->num_args; i++) {
-    if (strcmp(args->args[i].key, GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM) ==
-        0) {
-      if (args->args[i].type == GRPC_ARG_INTEGER) {
-        return static_cast<grpc_compression_algorithm>(
-            args->args[i].value.integer);
-      } else if (args->args[i].type == GRPC_ARG_STRING) {
-        return ParseCompressionAlgorithm(args->args[i].value.string);
-      }
-    }
+DefaultCompressionAlgorithmFromChannelArgs(const ChannelArgs& args) {
+  auto* value = args.Get(GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM);
+  if (value == nullptr) return absl::nullopt;
+  if (auto* p = absl::get_if<int>(value)) {
+    return static_cast<grpc_compression_algorithm>(*p);
+  }
+  if (auto* p = absl::get_if<std::string>(value)) {
+    return ParseCompressionAlgorithm(*p);
   }
   return absl::nullopt;
 }

data/src/core/lib/compression/compression_internal.h

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2017 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 2017 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_COMPRESSION_COMPRESSION_INTERNAL_H
 #define GRPC_CORE_LIB_COMPRESSION_COMPRESSION_INTERNAL_H
@@ -28,9 +28,9 @@
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
-#include <grpc/impl/codegen/compression_types.h>
-#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/impl/compression_types.h>
 
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gprpp/bitset.h"
 #include "src/core/lib/slice/slice.h"
 
@@ -46,7 +46,7 @@ const char* CompressionAlgorithmAsString(grpc_compression_algorithm algorithm);
 // Retrieve the default compression algorithm from channel args, return nullopt
 // if not found.
 absl::optional<grpc_compression_algorithm>
-DefaultCompressionAlgorithmFromChannelArgs(const grpc_channel_args* args);
+DefaultCompressionAlgorithmFromChannelArgs(const ChannelArgs& args);
 
 // A set of grpc_compression_algorithm values.
 class CompressionAlgorithmSet {
@@ -55,7 +55,7 @@ class CompressionAlgorithmSet {
   // algorithm 1, etc.
   static CompressionAlgorithmSet FromUint32(uint32_t value);
   // Locate in channel args and construct from the found value.
-  static CompressionAlgorithmSet FromChannelArgs(const grpc_channel_args* args);
+  static CompressionAlgorithmSet FromChannelArgs(const ChannelArgs& args);
   // Parse a string of comma-separated compression algorithms.
   static CompressionAlgorithmSet FromString(absl::string_view str);
   // Construct an empty set.
@@ -90,4 +90,4 @@ class CompressionAlgorithmSet {
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_LIB_COMPRESSION_COMPRESSION_INTERNAL_H */
+#endif  // GRPC_CORE_LIB_COMPRESSION_COMPRESSION_INTERNAL_H

data/src/core/lib/compression/message_compress.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>
 
@@ -29,18 +29,18 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-#include "src/core/lib/slice/slice_refcount.h"
+#include "src/core/lib/slice/slice.h"
 
 #define OUTPUT_BLOCK_SIZE 1024
 
 static int zlib_body(z_stream* zs, grpc_slice_buffer* input,
                      grpc_slice_buffer* output,
                      int (*flate)(z_stream* zs, int flush)) {
-  int r = Z_STREAM_END; /* Do not fail on an empty input. */
+  int r = Z_STREAM_END;  // Do not fail on an empty input.
   int flush;
   size_t i;
   grpc_slice outbuf = GRPC_SLICE_MALLOC(OUTPUT_BLOCK_SIZE);
-  const uInt uint_max = ~static_cast<uInt>(0);
+  const uInt uint_max = ~uInt{0};
 
   GPR_ASSERT(GRPC_SLICE_LENGTH(outbuf) <= uint_max);
   zs->avail_out = static_cast<uInt> GRPC_SLICE_LENGTH(outbuf);
@@ -82,7 +82,7 @@ static int zlib_body(z_stream* zs, grpc_slice_buffer* input,
   return 1;
 
 error:
-  grpc_slice_unref_internal(outbuf);
+  grpc_core::CSliceUnref(outbuf);
   return 0;
 }
 
@@ -109,7 +109,7 @@ static int zlib_compress(grpc_slice_buffer* input, grpc_slice_buffer* output,
   r = zlib_body(&zs, input, output, deflate) && output->length < input->length;
   if (!r) {
     for (i = count_before; i < output->count; i++) {
-      grpc_slice_unref_internal(output->slices[i]);
+      grpc_core::CSliceUnref(output->slices[i]);
     }
     output->count = count_before;
     output->length = length_before;
@@ -133,7 +133,7 @@ static int zlib_decompress(grpc_slice_buffer* input, grpc_slice_buffer* output,
   r = zlib_body(&zs, input, output, inflate);
   if (!r) {
     for (i = count_before; i < output->count; i++) {
-      grpc_slice_unref_internal(output->slices[i]);
+      grpc_core::CSliceUnref(output->slices[i]);
     }
     output->count = count_before;
     output->length = length_before;
@@ -145,7 +145,7 @@ static int zlib_decompress(grpc_slice_buffer* input, grpc_slice_buffer* output,
 static int copy(grpc_slice_buffer* input, grpc_slice_buffer* output) {
   size_t i;
   for (i = 0; i < input->count; i++) {
-    grpc_slice_buffer_add(output, grpc_slice_ref_internal(input->slices[i]));
+    grpc_slice_buffer_add(output, grpc_core::CSliceRef(input->slices[i]));
   }
   return 1;
 }
@@ -154,8 +154,8 @@ static int compress_inner(grpc_compression_algorithm algorithm,
                           grpc_slice_buffer* input, grpc_slice_buffer* output) {
   switch (algorithm) {
     case GRPC_COMPRESS_NONE:
-      /* the fallback path always needs to be send uncompressed: we simply
-         rely on that here */
+      // the fallback path always needs to be send uncompressed: we simply
+      // rely on that here
       return 0;
     case GRPC_COMPRESS_DEFLATE:
       return zlib_compress(input, output, 0);

data/src/core/lib/compression/message_compress.h

@@ -1,39 +1,39 @@
-/*
- *
- * 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_COMPRESSION_MESSAGE_COMPRESS_H
 #define GRPC_CORE_LIB_COMPRESSION_MESSAGE_COMPRESS_H
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/impl/codegen/compression_types.h>
+#include <grpc/impl/compression_types.h>
 #include <grpc/slice.h>
 
-/* compress 'input' to 'output' using 'algorithm'.
-   On success, appends compressed slices to output and returns 1.
-   On failure, appends uncompressed slices to output and returns 0. */
+// compress 'input' to 'output' using 'algorithm'.
+// On success, appends compressed slices to output and returns 1.
+// On failure, appends uncompressed slices to output and returns 0.
 int grpc_msg_compress(grpc_compression_algorithm algorithm,
                       grpc_slice_buffer* input, grpc_slice_buffer* output);
 
-/* decompress 'input' to 'output' using 'algorithm'.
-   On success, appends slices to output and returns 1.
-   On failure, output is unchanged, and returns 0. */
+// decompress 'input' to 'output' using 'algorithm'.
+// On success, appends slices to output and returns 1.
+// On failure, output is unchanged, and returns 0.
 int grpc_msg_decompress(grpc_compression_algorithm algorithm,
                         grpc_slice_buffer* input, grpc_slice_buffer* output);
 
-#endif /* GRPC_CORE_LIB_COMPRESSION_MESSAGE_COMPRESS_H */
+#endif  // GRPC_CORE_LIB_COMPRESSION_MESSAGE_COMPRESS_H

data/src/core/lib/config/core_configuration.h

@@ -240,4 +240,4 @@ extern void BuildCoreConfiguration(CoreConfiguration::Builder* builder);
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_LIB_CONFIG_CORE_CONFIGURATION_H */
+#endif  // GRPC_CORE_LIB_CONFIG_CORE_CONFIGURATION_H