grpc 1.43.1 → 1.44.0.pre2

data/src/core/ext/transport/chttp2/transport/popularity_count.h

@@ -1,60 +0,0 @@
-// Copyright 2021 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_EXT_TRANSPORT_CHTTP2_TRANSPORT_POPULARITY_COUNT_H
-#define GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_POPULARITY_COUNT_H
-
-#include <grpc/support/port_platform.h>
-
-namespace grpc_core {
-
-// filter tables for elems: this tables provides an approximate
-// popularity count for particular hashes, and are used to determine whether
-// a new literal should be added to the compression table or not.
-// They track a single integer that counts how often a particular value has
-// been seen. When that count reaches max (255), all values are halved. */
-template <uint8_t kElems>
-class PopularityCount {
- public:
-  PopularityCount() : sum_{0}, elems_{} {}
-
-  // increment a filter count, halve all counts if one element reaches max
-  // return true if this element seems to be popular, false otherwise
-  bool AddElement(uint8_t idx) {
-    elems_[idx]++;
-    if (GPR_LIKELY(elems_[idx] < 255)) {
-      sum_++;
-    } else {
-      HalveFilter();
-    }
-    return elems_[idx] >= 2 * sum_ / kElems;
-  }
-
- private:
-  // halve all counts because an element reached max
-  void HalveFilter() {
-    sum_ = 0;
-    for (int i = 0; i < kElems; i++) {
-      elems_[i] /= 2;
-      sum_ += elems_[i];
-    }
-  }
-
-  uint32_t sum_;
-  uint8_t elems_[kElems];
-};
-
-}  // namespace grpc_core
-
-#endif /* GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_POPULARITY_COUNT_H */

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

@@ -1,62 +0,0 @@
-/*
- *
- * 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_ALGORITHM_METADATA_H
-#define GRPC_CORE_LIB_COMPRESSION_ALGORITHM_METADATA_H
-
-#include <grpc/support/port_platform.h>
-
-#include <grpc/compression.h>
-
-#include "src/core/lib/compression/compression_internal.h"
-#include "src/core/lib/transport/metadata.h"
-
-/** Return compression algorithm based metadata value */
-grpc_slice grpc_compression_algorithm_slice(
-    grpc_compression_algorithm algorithm);
-
-/** Find compression algorithm based on passed in mdstr - returns
- *  GRPC_COMPRESS_ALGORITHM_COUNT on failure */
-grpc_compression_algorithm grpc_compression_algorithm_from_slice(
-    const grpc_slice& str);
-
-/** Return compression algorithm based metadata element */
-grpc_mdelem grpc_compression_encoding_mdelem(
-    grpc_compression_algorithm algorithm);
-
-/** Return message compression algorithm based metadata element (grpc-encoding:
- * xxx) */
-grpc_mdelem grpc_message_compression_encoding_mdelem(
-    grpc_message_compression_algorithm algorithm);
-
-/** Return stream compression algorithm based metadata element
- * (content-encoding: xxx) */
-grpc_mdelem grpc_stream_compression_encoding_mdelem(
-    grpc_stream_compression_algorithm algorithm);
-
-/** Find compression algorithm based on passed in mdstr - returns
- * GRPC_COMPRESS_ALGORITHM_COUNT on failure */
-grpc_message_compression_algorithm
-grpc_message_compression_algorithm_from_slice(const grpc_slice& str);
-
-/** Find stream compression algorithm based on passed in mdstr - returns
- * GRPC_STREAM_COMPRESS_ALGORITHM_COUNT on failure */
-grpc_stream_compression_algorithm grpc_stream_compression_algorithm_from_slice(
-    const grpc_slice& str);
-
-#endif /* GRPC_CORE_LIB_COMPRESSION_ALGORITHM_METADATA_H */

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

@@ -1,140 +0,0 @@
-/*
- *
- * 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_args.h"
-
-#include <limits.h>
-#include <string.h>
-
-#include <grpc/compression.h>
-#include <grpc/grpc.h>
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
-
-#include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/gpr/string.h"
-#include "src/core/lib/gpr/useful.h"
-
-grpc_compression_algorithm
-grpc_channel_args_get_channel_default_compression_algorithm(
-    const grpc_channel_args* a) {
-  size_t i;
-  if (a == nullptr) return GRPC_COMPRESS_NONE;
-  for (i = 0; i < a->num_args; ++i) {
-    if (a->args[i].type == GRPC_ARG_INTEGER &&
-        !strcmp(GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM, a->args[i].key)) {
-      grpc_compression_algorithm default_algorithm =
-          static_cast<grpc_compression_algorithm>(a->args[i].value.integer);
-      return default_algorithm < GRPC_COMPRESS_ALGORITHMS_COUNT
-                 ? default_algorithm
-                 : GRPC_COMPRESS_NONE;
-    }
-  }
-  return GRPC_COMPRESS_NONE;
-}
-
-const grpc_channel_args*
-grpc_channel_args_set_channel_default_compression_algorithm(
-    const grpc_channel_args* a, grpc_compression_algorithm algorithm) {
-  GPR_ASSERT(algorithm < GRPC_COMPRESS_ALGORITHMS_COUNT);
-  grpc_arg tmp;
-  tmp.type = GRPC_ARG_INTEGER;
-  tmp.key = const_cast<char*>(GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM);
-  tmp.value.integer = algorithm;
-  return grpc_channel_args_copy_and_add(a, &tmp, 1);
-}
-
-/** Returns 1 if the argument for compression algorithm's enabled states bitset
- * was found in \a a, returning the arg's value in \a states. Otherwise, returns
- * 0. */
-static int find_compression_algorithm_states_bitset(const grpc_channel_args* a,
-                                                    int** states_arg) {
-  if (a != nullptr) {
-    size_t i;
-    for (i = 0; i < a->num_args; ++i) {
-      if (a->args[i].type == GRPC_ARG_INTEGER &&
-          !strcmp(GRPC_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET,
-                  a->args[i].key)) {
-        *states_arg = &a->args[i].value.integer;
-        **states_arg =
-            (**states_arg & ((1 << GRPC_COMPRESS_ALGORITHMS_COUNT) - 1)) |
-            0x1; /* forcefully enable support for no compression */
-        return 1;
-      }
-    }
-  }
-  return 0; /* GPR_FALSE */
-}
-
-const grpc_channel_args* grpc_channel_args_compression_algorithm_set_state(
-    const grpc_channel_args** a, grpc_compression_algorithm algorithm,
-    int state) {
-  int* states_arg = nullptr;
-  const grpc_channel_args* result = *a;
-  const int states_arg_found =
-      find_compression_algorithm_states_bitset(*a, &states_arg);
-
-  if (grpc_channel_args_get_channel_default_compression_algorithm(*a) ==
-          algorithm &&
-      state == 0) {
-    const char* algo_name = nullptr;
-    GPR_ASSERT(grpc_compression_algorithm_name(algorithm, &algo_name) != 0);
-    gpr_log(GPR_ERROR,
-            "Tried to disable default compression algorithm '%s'. The "
-            "operation has been ignored.",
-            algo_name);
-  } else if (states_arg_found) {
-    if (state != 0) {
-      grpc_core::SetBit(reinterpret_cast<unsigned*>(states_arg), algorithm);
-    } else if (algorithm != GRPC_COMPRESS_NONE) {
-      grpc_core::ClearBit(reinterpret_cast<unsigned*>(states_arg), algorithm);
-    }
-  } else {
-    /* create a new arg */
-    grpc_arg tmp;
-    tmp.type = GRPC_ARG_INTEGER;
-    tmp.key =
-        const_cast<char*>(GRPC_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET);
-    /* all enabled by default */
-    tmp.value.integer = (1u << GRPC_COMPRESS_ALGORITHMS_COUNT) - 1;
-    if (state != 0) {
-      grpc_core::SetBit(reinterpret_cast<unsigned*>(&tmp.value.integer),
-                        algorithm);
-    } else if (algorithm != GRPC_COMPRESS_NONE) {
-      grpc_core::ClearBit(reinterpret_cast<unsigned*>(&tmp.value.integer),
-                          algorithm);
-    }
-    result = grpc_channel_args_copy_and_add(*a, &tmp, 1);
-    grpc_channel_args_destroy(*a);
-    *a = result;
-  }
-  return result;
-}
-
-uint32_t grpc_channel_args_compression_algorithm_get_states(
-    const grpc_channel_args* a) {
-  int* states_arg;
-  if (find_compression_algorithm_states_bitset(a, &states_arg)) {
-    return static_cast<uint32_t>(*states_arg);
-  } else {
-    return (1u << GRPC_COMPRESS_ALGORITHMS_COUNT) - 1; /* All algs. enabled */
-  }
-}

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

@@ -1,58 +0,0 @@
-/*
- *
- * 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_COMPRESSION_ARGS_H
-#define GRPC_CORE_LIB_COMPRESSION_COMPRESSION_ARGS_H
-
-#include <grpc/support/port_platform.h>
-
-#include <grpc/compression.h>
-#include <grpc/impl/codegen/grpc_types.h>
-
-/** Returns the compression algorithm set in \a a. */
-grpc_compression_algorithm
-grpc_channel_args_get_channel_default_compression_algorithm(
-    const grpc_channel_args* a);
-
-/** Returns a channel arg instance with compression enabled. If \a a is
- * non-NULL, its args are copied. N.B. GRPC_COMPRESS_NONE disables compression
- * for the channel. */
-const grpc_channel_args*
-grpc_channel_args_set_channel_default_compression_algorithm(
-    const grpc_channel_args* a, grpc_compression_algorithm algorithm);
-
-/** Sets the support for the given compression algorithm. By default, all
- * compression algorithms are enabled. It's an error to disable an algorithm set
- * by grpc_channel_args_set_compression_algorithm.
- *
- * Returns an instance with the updated algorithm states. The \a a pointer is
- * modified to point to the returned instance (which may be different from the
- * input value of \a a). */
-const grpc_channel_args* grpc_channel_args_compression_algorithm_set_state(
-    const grpc_channel_args** a, grpc_compression_algorithm algorithm,
-    int state);
-
-/** Returns the bitset representing the support state (true for enabled, false
- * for disabled) for compression algorithms.
- *
- * The i-th bit of the returned bitset corresponds to the i-th entry in the
- * grpc_compression_algorithm enum. */
-uint32_t grpc_channel_args_compression_algorithm_get_states(
-    const grpc_channel_args* a);
-
-#endif /* GRPC_CORE_LIB_COMPRESSION_COMPRESSION_ARGS_H */

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

@@ -1,81 +0,0 @@
-/*
- *
- * 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>
-
-#include "src/core/lib/compression/stream_compression.h"
-
-#include <grpc/support/log.h>
-
-#include "src/core/lib/compression/stream_compression_gzip.h"
-#include "src/core/lib/slice/slice_utils.h"
-
-extern const grpc_stream_compression_vtable
-    grpc_stream_compression_identity_vtable;
-
-bool grpc_stream_compress(grpc_stream_compression_context* ctx,
-                          grpc_slice_buffer* in, grpc_slice_buffer* out,
-                          size_t* output_size, size_t max_output_size,
-                          grpc_stream_compression_flush flush) {
-  return ctx->vtable->compress(ctx, in, out, output_size, max_output_size,
-                               flush);
-}
-
-bool grpc_stream_decompress(grpc_stream_compression_context* ctx,
-                            grpc_slice_buffer* in, grpc_slice_buffer* out,
-                            size_t* output_size, size_t max_output_size,
-                            bool* end_of_context) {
-  return ctx->vtable->decompress(ctx, in, out, output_size, max_output_size,
-                                 end_of_context);
-}
-
-grpc_stream_compression_context* grpc_stream_compression_context_create(
-    grpc_stream_compression_method method) {
-  switch (method) {
-    case GRPC_STREAM_COMPRESSION_IDENTITY_COMPRESS:
-    case GRPC_STREAM_COMPRESSION_IDENTITY_DECOMPRESS:
-      return grpc_stream_compression_identity_vtable.context_create(method);
-    case GRPC_STREAM_COMPRESSION_GZIP_COMPRESS:
-    case GRPC_STREAM_COMPRESSION_GZIP_DECOMPRESS:
-      return grpc_stream_compression_gzip_vtable.context_create(method);
-    default:
-      gpr_log(GPR_ERROR, "Unknown stream compression method: %d", method);
-      return nullptr;
-  }
-}
-
-void grpc_stream_compression_context_destroy(
-    grpc_stream_compression_context* ctx) {
-  ctx->vtable->context_destroy(ctx);
-}
-
-int grpc_stream_compression_method_parse(
-    grpc_slice value, bool is_compress,
-    grpc_stream_compression_method* method) {
-  if (grpc_slice_eq_static_interned(value, GRPC_MDSTR_IDENTITY)) {
-    *method = is_compress ? GRPC_STREAM_COMPRESSION_IDENTITY_COMPRESS
-                          : GRPC_STREAM_COMPRESSION_IDENTITY_DECOMPRESS;
-    return 1;
-  } else if (grpc_slice_eq_static_interned(value, GRPC_MDSTR_GZIP)) {
-    *method = is_compress ? GRPC_STREAM_COMPRESSION_GZIP_COMPRESS
-                          : GRPC_STREAM_COMPRESSION_GZIP_DECOMPRESS;
-    return 1;
-  } else {
-    return 0;
-  }
-}

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

@@ -1,117 +0,0 @@
-/*
- *
- * 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_STREAM_COMPRESSION_H
-#define GRPC_CORE_LIB_COMPRESSION_STREAM_COMPRESSION_H
-
-#include <grpc/support/port_platform.h>
-
-#include <stdbool.h>
-
-#include <zlib.h>
-
-#include <grpc/slice_buffer.h>
-
-#include "src/core/lib/transport/static_metadata.h"
-
-typedef struct grpc_stream_compression_vtable grpc_stream_compression_vtable;
-
-/* Stream compression/decompression context */
-typedef struct grpc_stream_compression_context {
-  const grpc_stream_compression_vtable* vtable;
-} grpc_stream_compression_context;
-
-typedef enum grpc_stream_compression_method {
-  GRPC_STREAM_COMPRESSION_IDENTITY_COMPRESS = 0,
-  GRPC_STREAM_COMPRESSION_IDENTITY_DECOMPRESS,
-  GRPC_STREAM_COMPRESSION_GZIP_COMPRESS,
-  GRPC_STREAM_COMPRESSION_GZIP_DECOMPRESS,
-  GRPC_STREAM_COMPRESSION_METHOD_COUNT
-} grpc_stream_compression_method;
-
-typedef enum grpc_stream_compression_flush {
-  GRPC_STREAM_COMPRESSION_FLUSH_NONE = 0,
-  GRPC_STREAM_COMPRESSION_FLUSH_SYNC,
-  GRPC_STREAM_COMPRESSION_FLUSH_FINISH,
-  GRPC_STREAM_COMPRESSION_FLUSH_COUNT
-} grpc_stream_compression_flush;
-
-struct grpc_stream_compression_vtable {
-  bool (*compress)(grpc_stream_compression_context* ctx, grpc_slice_buffer* in,
-                   grpc_slice_buffer* out, size_t* output_size,
-                   size_t max_output_size, grpc_stream_compression_flush flush);
-  bool (*decompress)(grpc_stream_compression_context* ctx,
-                     grpc_slice_buffer* in, grpc_slice_buffer* out,
-                     size_t* output_size, size_t max_output_size,
-                     bool* end_of_context);
-  grpc_stream_compression_context* (*context_create)(
-      grpc_stream_compression_method method);
-  void (*context_destroy)(grpc_stream_compression_context* ctx);
-};
-
-/**
- * Compress bytes provided in \a in with a given context, with an optional flush
- * at the end of compression. Emits at most \a max_output_size compressed bytes
- * into \a out. If all the bytes in input buffer \a in are depleted and \a flush
- * is not GRPC_STREAM_COMPRESSION_FLUSH_NONE, the corresponding flush method is
- * executed. The total number of bytes emitted is outputted in \a output_size.
- *
- * A SYNC flush indicates that the entire messages in \a in can be decompressed
- * from \a out. A FINISH flush implies a SYNC flush, and that any further
- * compression will not be dependent on the state of the current context and any
- * previous compressed bytes. It allows corresponding decompression context to
- * be dropped when reaching this boundary.
- */
-bool grpc_stream_compress(grpc_stream_compression_context* ctx,
-                          grpc_slice_buffer* in, grpc_slice_buffer* out,
-                          size_t* output_size, size_t max_output_size,
-                          grpc_stream_compression_flush flush);
-
-/**
- * Decompress bytes provided in \a in with a given context. Emits at most \a
- * max_output_size decompressed bytes into \a out. If decompression process
- * reached the end of a gzip stream, \a end_of_context is set to true; otherwise
- * it is set to false. The total number of bytes emitted is outputted in \a
- * output_size.
- */
-bool grpc_stream_decompress(grpc_stream_compression_context* ctx,
-                            grpc_slice_buffer* in, grpc_slice_buffer* out,
-                            size_t* output_size, size_t max_output_size,
-                            bool* end_of_context);
-
-/**
- * Creates a stream compression context. \a pending_bytes_buffer is the input
- * buffer for compression/decompression operations. \a method specifies whether
- * the context is for compression or decompression.
- */
-grpc_stream_compression_context* grpc_stream_compression_context_create(
-    grpc_stream_compression_method method);
-
-/**
- * Destroys a stream compression context.
- */
-void grpc_stream_compression_context_destroy(
-    grpc_stream_compression_context* ctx);
-
-/**
- * Parse stream compression method based on algorithm name
- */
-int grpc_stream_compression_method_parse(
-    grpc_slice value, bool is_compress, grpc_stream_compression_method* method);
-
-#endif  // GRPC_CORE_LIB_COMPRESSION_STREAM_COMPRESSION_H