Chiebot-Mirror
/
grpc
mirror of https://github.com/grpc/grpc.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

Change C core surface API

Browse Source
reviewable/pr12708/r1
Muxi Yan 7 years ago
parent e29d497fa9
commit e6d888d0a0
34 changed files with 1394 additions and 1279 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      BUILD
  2. 2
      build.yaml
  3. 31
      include/grpc/compression.h
  4. 79
      include/grpc/impl/codegen/compression_types.h
  5. 4
      include/grpc/impl/codegen/grpc_types.h
  6. 129
      src/core/ext/filters/http/message_compress/message_compress_filter.c
  7. 98
      src/core/lib/channel/channel_args.c
  8. 31
      src/core/lib/channel/channel_args.h
  9. 18
      src/core/lib/compression/algorithm_metadata.h
  10. 281
      src/core/lib/compression/compression.c
  11. 310
      src/core/lib/compression/compression_internal.c
  12. 110
      src/core/lib/compression/compression_internal.h
  13. 22
      src/core/lib/compression/message_compress.c
  14. 7
      src/core/lib/compression/message_compress.h
  15. 2
      src/core/lib/surface/byte_buffer_reader.c
  16. 279
      src/core/lib/surface/call.c
  17. 14
      src/core/lib/surface/call_test_only.h
  18. 29
      src/core/lib/surface/channel.c
  19. 587
      src/core/lib/transport/static_metadata.c
  20. 150
      src/core/lib/transport/static_metadata.h
  21. 25
      test/core/channel/channel_args_test.c
  22. 12
      test/core/compression/BUILD
  23. 16
      test/core/compression/algorithm_test.c
  24. 178
      test/core/compression/compression_test.c
  25. 34
      test/core/compression/message_compress_test.c
  26. 4
      test/core/end2end/fixtures/h2_compress.c
  27. 3
      test/core/end2end/fuzzers/hpack.dictionary
  28. 37
      test/core/end2end/tests/compressed_payload.c
  29. 104
      test/core/end2end/tests/stream_compression_compressed_payload.c
  30. 10
      test/core/end2end/tests/stream_compression_payload.c
  31. 10
      test/core/end2end/tests/stream_compression_ping_pong_streaming.c
  32. 13
      test/core/end2end/tests/workaround_cronet_compression.c
  33. 8
      test/core/surface/byte_buffer_reader_test.c
  34. 4
      tools/codegen/core/gen_static_metadata.py

2
BUILD
Unescape View File

@ -572,6 +572,7 @@ grpc_cc_library(
"src/core/lib/channel/handshaker_factory.c",
"src/core/lib/channel/handshaker_registry.c",
"src/core/lib/compression/compression.c",
"src/core/lib/compression/compression_internal.c",
"src/core/lib/compression/message_compress.c",
"src/core/lib/compression/stream_compression.c",
"src/core/lib/http/format_request.c",
@ -703,6 +704,7 @@ grpc_cc_library(
"src/core/lib/channel/handshaker_factory.h",
"src/core/lib/channel/handshaker_registry.h",
"src/core/lib/compression/algorithm_metadata.h",
"src/core/lib/compression/compression_internal.h",
"src/core/lib/compression/message_compress.h",
"src/core/lib/compression/stream_compression.h",
"src/core/lib/http/format_request.h",

2
build.yaml
Unescape View File

@ -193,6 +193,7 @@ filegroups:
- src/core/lib/channel/handshaker_factory.c
- src/core/lib/channel/handshaker_registry.c
- src/core/lib/compression/compression.c
- src/core/lib/compression/compression_internal.c
- src/core/lib/compression/message_compress.c
- src/core/lib/compression/stream_compression.c
- src/core/lib/debug/stats.c
@ -344,6 +345,7 @@ filegroups:
- src/core/lib/channel/handshaker_factory.h
- src/core/lib/channel/handshaker_registry.h
- src/core/lib/compression/algorithm_metadata.h
- src/core/lib/compression/compression_internal.h
- src/core/lib/compression/message_compress.h
- src/core/lib/compression/stream_compression.h
- src/core/lib/debug/stats.h

31
include/grpc/compression.h
Unescape View File

@ -30,28 +30,25 @@
extern "C" {
#endif
/** Return if an algorithm is message compression algorithm. */
GRPCAPI int grpc_compression_algorithm_is_message(
grpc_compression_algorithm algorithm);
/** Return if an algorithm is stream compression algorithm. */
GRPCAPI int grpc_compression_algorithm_is_stream(
grpc_compression_algorithm algorithm);
/** Parses the \a slice as a grpc_compression_algorithm instance and updating \a
* algorithm. Returns 1 upon success, 0 otherwise. */
GRPCAPI int grpc_compression_algorithm_parse(
grpc_slice value, grpc_compression_algorithm *algorithm);
/** Parses the \a slice as a grpc_stream_compression_algorithm instance and
* updating \a algorithm. Returns 1 upon success, 0 otherwise. */
int grpc_stream_compression_algorithm_parse(
grpc_slice name, grpc_stream_compression_algorithm *algorithm);
/** Updates \a name with the encoding name corresponding to a valid \a
* algorithm. Note that \a name is statically allocated and must *not* be freed.
* Returns 1 upon success, 0 otherwise. */
GRPCAPI int grpc_compression_algorithm_name(
grpc_compression_algorithm algorithm, char **name);
/** Updates \a name with the encoding name corresponding to a valid \a
* algorithm. Note that \a name is statically allocated and must *not* be freed.
* Returns 1 upon success, 0 otherwise. */
GRPCAPI int grpc_stream_compression_algorithm_name(
grpc_stream_compression_algorithm algorithm, char **name);
/** Returns the compression algorithm corresponding to \a level for the
* compression algorithms encoded in the \a accepted_encodings bitset.
*
@ -59,13 +56,6 @@ GRPCAPI int grpc_stream_compression_algorithm_name(
GRPCAPI grpc_compression_algorithm grpc_compression_algorithm_for_level(
grpc_compression_level level, uint32_t accepted_encodings);
/** Returns the stream compression algorithm corresponding to \a level for the
* compression algorithms encoded in the \a accepted_stream_encodings bitset.
* It abort()s for unknown levels. */
GRPCAPI grpc_stream_compression_algorithm
grpc_stream_compression_algorithm_for_level(grpc_stream_compression_level level,
uint32_t accepted_stream_encodings);
GRPCAPI void grpc_compression_options_init(grpc_compression_options *opts);
/** Mark \a algorithm as enabled in \a opts. */
@ -80,11 +70,6 @@ GRPCAPI void grpc_compression_options_disable_algorithm(
GRPCAPI int grpc_compression_options_is_algorithm_enabled(
const grpc_compression_options *opts, grpc_compression_algorithm algorithm);
/** Returns true if \a algorithm is marked as enabled in \a opts. */
GRPCAPI int grpc_compression_options_is_stream_compression_algorithm_enabled(
const grpc_compression_options *opts,
grpc_stream_compression_algorithm algorithm);
#ifdef __cplusplus
}
#endif

79
include/grpc/impl/codegen/compression_types.h
Unescape View File

@ -29,11 +29,6 @@ extern "C" {
* algorithm */
#define GRPC_COMPRESSION_REQUEST_ALGORITHM_MD_KEY \
"grpc-internal-encoding-request"
/** To be used as initial metadata key for the request of a concrete stream
* compression
* algorithm */
#define GRPC_STREAM_COMPRESSION_REQUEST_ALGORITHM_MD_KEY \
"grpc-internal-stream-encoding-request"
/** To be used in channel arguments.
*
@ -43,17 +38,9 @@ extern "C" {
* Its value is an int from the \a grpc_compression_algorithm enum. */
#define GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM \
"grpc.default_compression_algorithm"
/** Default stream compression algorithm for the channel.
* Its value is an int from the \a grpc_stream_compression_algorithm enum. */
#define GRPC_STREAM_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM \
"grpc.default_stream_compression_algorithm"
/** Default compression level for the channel.
* Its value is an int from the \a grpc_compression_level enum. */
#define GRPC_COMPRESSION_CHANNEL_DEFAULT_LEVEL "grpc.default_compression_level"
/** Default stream compression level for the channel.
* Its value is an int from the \a grpc_stream_compression_level enum. */
#define GRPC_STREAM_COMPRESSION_CHANNEL_DEFAULT_LEVEL \
"grpc.default_stream_compression_level"
/** Compression algorithms supported by the channel.
* Its value is a bitset (an int). Bits correspond to algorithms in \a
* grpc_compression_algorithm. For example, its LSB corresponds to
@ -63,80 +50,49 @@ extern "C" {
* be ignored). */
#define GRPC_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET \
"grpc.compression_enabled_algorithms_bitset"
/** Stream compression algorithms supported by the channel.
* Its value is a bitset (an int). Bits correspond to algorithms in \a
* grpc_stream_compression_algorithm. For example, its LSB corresponds to
* GRPC_STREAM_COMPRESS_NONE, the next bit to GRPC_STREAM_COMPRESS_DEFLATE, etc.
* Unset bits disable support for the algorithm. By default all algorithms are
* supported. It's not possible to disable GRPC_STREAM_COMPRESS_NONE (the
* attempt will be ignored). */
#define GRPC_STREAM_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET \
"grpc.stream_compression_enabled_algorithms_bitset"
/** \} */
/** The various compression algorithms supported by gRPC */
typedef enum {
GRPC_COMPRESS_NONE = 0,
GRPC_COMPRESS_DEFLATE,
GRPC_COMPRESS_GZIP,
GRPC_COMPRESS_MESSAGE_DEFLATE,
GRPC_COMPRESS_MESSAGE_GZIP,
GRPC_COMPRESS_STREAM_GZIP,
/* TODO(ctiller): snappy */
GRPC_COMPRESS_ALGORITHMS_COUNT
} grpc_compression_algorithm;
/** Stream compresssion algorithms supported by gRPC */
typedef enum {
GRPC_STREAM_COMPRESS_NONE = 0,
GRPC_STREAM_COMPRESS_GZIP,
GRPC_STREAM_COMPRESS_ALGORITHMS_COUNT
} grpc_stream_compression_algorithm;
/** Compression levels allow a party with knowledge of its peer's accepted
* encodings to request compression in an abstract way. The level-algorithm
* mapping is performed internally and depends on the peer's supported
* compression algorithms. */
typedef enum {
GRPC_COMPRESS_LEVEL_NONE = 0,
GRPC_COMPRESS_LEVEL_LOW,
GRPC_COMPRESS_LEVEL_MED,
GRPC_COMPRESS_LEVEL_HIGH,
GRPC_COMPRESS_LEVEL_MESSAGE_LOW,
GRPC_COMPRESS_LEVEL_MESSAGE_MED,
GRPC_COMPRESS_LEVEL_MESSAGE_HIGH,
GRPC_COMPRESS_LEVEL_STREAM_LOW,
GRPC_COMPRESS_LEVEL_STREAM_MED,
GRPC_COMPRESS_LEVEL_STREAM_HIGH,
GRPC_COMPRESS_LEVEL_COUNT
} grpc_compression_level;
/** Compression levels for stream compression algorithms */
typedef enum {
GRPC_STREAM_COMPRESS_LEVEL_NONE = 0,
GRPC_STREAM_COMPRESS_LEVEL_LOW,
GRPC_STREAM_COMPRESS_LEVEL_MED,
GRPC_STREAM_COMPRESS_LEVEL_HIGH,
GRPC_STREAM_COMPRESS_LEVEL_COUNT
} grpc_stream_compression_level;
typedef struct grpc_compression_options {
/** All algs are enabled by default. This option corresponds to the channel
* argument key behind \a GRPC_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET
*/
uint32_t enabled_algorithms_bitset;
uint32_t enabled_stream_compression_algorithms_bitset;
/** The default message-wise compression level. It'll be used in the absence
* of * call specific settings. This option corresponds to the channel
/** The default compression level. It'll be used in the absence of call
* specific settings. This option corresponds to the channel
* argument key behind \a GRPC_COMPRESSION_CHANNEL_DEFAULT_LEVEL. If present,
* takes precedence over \a default_algorithm and \a
* default_stream_compression_algorithm.
* takes precedence over \a default_algorithm.
* TODO(dgq): currently only available for server channels. */
struct grpc_compression_options_default_level {
int is_set;
grpc_compression_level level;
} default_level;
/** The default stream compression level. It'll be used in the absence of call
* specefic settings. If present, takes precedence over \a default_level,
* \a default_algorithm and \a default_stream_compression_algorithm. */
struct grpc_stream_compression_options_default_level {
int is_set;
grpc_stream_compression_level level;
} default_stream_compression_level;
/** The default message compression algorithm. It'll be used in the absence of
* call specific settings. This option corresponds to the channel argument key
* behind \a GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM. */
@ -144,17 +100,6 @@ typedef struct grpc_compression_options {
int is_set;
grpc_compression_algorithm algorithm;
} default_algorithm;
/** The default stream compression algorithm. It'll be used in the absence of
* call specific settings. If present, takes precedence over \a
* default_algorithm. This option corresponds to the channel
* argument key behind \a GRPC_STREAM_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM.
*/
struct grpc_stream_compression_options_default_algorithm {
int is_set;
grpc_stream_compression_algorithm algorithm;
} default_stream_compression_algorithm;
} grpc_compression_options;
#ifdef __cplusplus

4
include/grpc/impl/codegen/grpc_types.h
Unescape View File

@ -508,10 +508,6 @@ typedef struct grpc_op {
uint8_t is_set;
grpc_compression_level level;
} maybe_compression_level;
struct grpc_op_send_initial_metadata_maybe_stream_compression_level {
uint8_t is_set;
grpc_stream_compression_level level;
} maybe_stream_compression_level;
} send_initial_metadata;
struct grpc_op_send_message {
/** This op takes ownership of the slices in send_message. After

129
src/core/ext/filters/http/message_compress/message_compress_filter.c
Unescape View File

@ -27,6 +27,7 @@
#include "src/core/ext/filters/http/message_compress/message_compress_filter.h"
#include "src/core/lib/channel/channel_args.h"
#include "src/core/lib/compression/algorithm_metadata.h"
#include "src/core/lib/compression/compression_internal.h"
#include "src/core/lib/compression/message_compress.h"
#include "src/core/lib/profiling/timers.h"
#include "src/core/lib/slice/slice_internal.h"
@ -52,7 +53,7 @@ typedef struct call_data {
grpc_linked_mdelem accept_stream_encoding_storage;
/** Compression algorithm we'll try to use. It may be given by incoming
* metadata, or by the channel's default compression settings. */
grpc_compression_algorithm compression_algorithm;
grpc_message_compression_algorithm message_compression_algorithm;
initial_metadata_state send_initial_metadata_state;
grpc_error *cancel_error;
grpc_closure start_send_message_batch_in_call_combiner;
@ -67,15 +68,10 @@ typedef struct call_data {
typedef struct channel_data {
/** The default, channel-level, compression algorithm */
grpc_compression_algorithm default_compression_algorithm;
/** Bitset of enabled algorithms */
/** Bitset of enabled compression algorithms */
uint32_t enabled_algorithms_bitset;
/** Supported compression algorithms */
uint32_t supported_compression_algorithms;
/** The default, channel-level, stream compression algorithm */
grpc_stream_compression_algorithm default_stream_compression_algorithm;
/** Bitset of enabled stream compression algorithms */
uint32_t enabled_stream_compression_algorithms_bitset;
uint32_t supported_message_compression_algorithms;
/** Supported stream compression algorithms */
uint32_t supported_stream_compression_algorithms;
} channel_data;
@ -89,7 +85,7 @@ static bool skip_compression(grpc_call_element *elem, uint32_t flags,
return true;
}
if (has_compression_algorithm) {
if (calld->compression_algorithm == GRPC_COMPRESS_NONE) {
if (calld->message_compression_algorithm == GRPC_MESSAGE_COMPRESS_NONE) {
return true;
}
return false; /* we have an actual call-specific algorithm */
@ -109,70 +105,53 @@ static grpc_error *process_send_initial_metadata(
call_data *calld = (call_data *)elem->call_data;
channel_data *channeld = (channel_data *)elem->channel_data;
*has_compression_algorithm = false;
grpc_compression_algorithm compression_algorithm;
grpc_stream_compression_algorithm stream_compression_algorithm =
GRPC_STREAM_COMPRESS_NONE;
if (initial_metadata->idx.named.grpc_internal_stream_encoding_request !=
NULL) {
if (initial_metadata->idx.named.grpc_internal_encoding_request != NULL) {
grpc_mdelem md =
initial_metadata->idx.named.grpc_internal_stream_encoding_request->md;
if (!grpc_stream_compression_algorithm_parse(
GRPC_MDVALUE(md), &stream_compression_algorithm)) {
initial_metadata->idx.named.grpc_internal_encoding_request->md;
if (!grpc_compression_algorithm_parse(GRPC_MDVALUE(md),
&compression_algorithm)) {
char *val = grpc_slice_to_c_string(GRPC_MDVALUE(md));
gpr_log(GPR_ERROR,
"Invalid stream compression algorithm: '%s' (unknown). Ignoring.",
val);
"Invalid compression algorithm: '%s' (unknown). Ignoring.", val);
gpr_free(val);
calld->message_compression_algorithm = GRPC_MESSAGE_COMPRESS_NONE;
stream_compression_algorithm = GRPC_STREAM_COMPRESS_NONE;
}
if (!GPR_BITGET(channeld->enabled_stream_compression_algorithms_bitset,
stream_compression_algorithm)) {
if (!GPR_BITGET(channeld->enabled_algorithms_bitset,
compression_algorithm)) {
char *val = grpc_slice_to_c_string(GRPC_MDVALUE(md));
gpr_log(
GPR_ERROR,
"Invalid stream compression algorithm: '%s' (previously disabled). "
gpr_log(GPR_ERROR,
"Invalid compression algorithm: '%s' (previously disabled). "
"Ignoring.",
val);
gpr_free(val);
calld->message_compression_algorithm = GRPC_MESSAGE_COMPRESS_NONE;
stream_compression_algorithm = GRPC_STREAM_COMPRESS_NONE;
}
*has_compression_algorithm = true;
grpc_metadata_batch_remove(
exec_ctx, initial_metadata,
initial_metadata->idx.named.grpc_internal_stream_encoding_request);
/* Disable message-wise compression */
calld->compression_algorithm = GRPC_COMPRESS_NONE;
if (initial_metadata->idx.named.grpc_internal_encoding_request != NULL) {
grpc_metadata_batch_remove(
exec_ctx, initial_metadata,
initial_metadata->idx.named.grpc_internal_encoding_request);
}
} else if (initial_metadata->idx.named.grpc_internal_encoding_request !=
NULL) {
grpc_mdelem md =
initial_metadata->idx.named.grpc_internal_encoding_request->md;
if (!grpc_compression_algorithm_parse(GRPC_MDVALUE(md),
&calld->compression_algorithm)) {
char *val = grpc_slice_to_c_string(GRPC_MDVALUE(md));
gpr_log(GPR_ERROR,
"Invalid compression algorithm: '%s' (unknown). Ignoring.", val);
gpr_free(val);
calld->compression_algorithm = GRPC_COMPRESS_NONE;
}
*has_compression_algorithm = true;
grpc_metadata_batch_remove(
exec_ctx, initial_metadata,
initial_metadata->idx.named.grpc_internal_encoding_request);
calld->message_compression_algorithm =
grpc_compression_algorithm_to_message_compression_algorithm(
compression_algorithm);
stream_compression_algorithm =
grpc_compression_algorithm_to_stream_compression_algorithm(
compression_algorithm);
} else {
/* If no algorithm was found in the metadata and we aren't
* exceptionally skipping compression, fall back to the channel
* default */
if (channeld->default_stream_compression_algorithm !=
GRPC_STREAM_COMPRESS_NONE) {
if (channeld->default_compression_algorithm != GRPC_COMPRESS_NONE) {
calld->message_compression_algorithm =
grpc_compression_algorithm_to_message_compression_algorithm(
channeld->default_compression_algorithm);
stream_compression_algorithm =
channeld->default_stream_compression_algorithm;
calld->compression_algorithm = GRPC_COMPRESS_NONE;
} else {
calld->compression_algorithm = channeld->default_compression_algorithm;
grpc_compression_algorithm_to_stream_compression_algorithm(
channeld->default_compression_algorithm);
}
*has_compression_algorithm = true;
}
@ -184,10 +163,11 @@ static grpc_error *process_send_initial_metadata(
exec_ctx, initial_metadata,
&calld->stream_compression_algorithm_storage,
grpc_stream_compression_encoding_mdelem(stream_compression_algorithm));
} else if (calld->compression_algorithm != GRPC_COMPRESS_NONE) {
} else if (calld->message_compression_algorithm !=
GRPC_MESSAGE_COMPRESS_NONE) {
error = grpc_metadata_batch_add_tail(
exec_ctx, initial_metadata, &calld->compression_algorithm_storage,
grpc_compression_encoding_mdelem(calld->compression_algorithm));
grpc_message_compression_encoding_mdelem(calld->message_compression_algorithm));
}
if (error != GRPC_ERROR_NONE) return error;
@ -196,11 +176,12 @@ static grpc_error *process_send_initial_metadata(
error = grpc_metadata_batch_add_tail(
exec_ctx, initial_metadata, &calld->accept_encoding_storage,
GRPC_MDELEM_ACCEPT_ENCODING_FOR_ALGORITHMS(
channeld->supported_compression_algorithms));
channeld->supported_message_compression_algorithms));
if (error != GRPC_ERROR_NONE) return error;
/* Do not overwrite accept-encoding header if it already presents. */
/* Do not overwrite accept-encoding header if it already presents (e.g. added
* by some proxy). */
if (!initial_metadata->idx.named.accept_encoding) {
error = grpc_metadata_batch_add_tail(
exec_ctx, initial_metadata, &calld->accept_stream_encoding_storage,
@ -240,16 +221,16 @@ static void finish_send_message(grpc_exec_ctx *exec_ctx,
grpc_slice_buffer_init(&tmp);
uint32_t send_flags =
calld->send_message_batch->payload->send_message.send_message->flags;
bool did_compress = grpc_msg_compress(exec_ctx, calld->compression_algorithm,
&calld->slices, &tmp);
bool did_compress = grpc_msg_compress(
exec_ctx, calld->message_compression_algorithm, &calld->slices, &tmp);
if (did_compress) {
if (GRPC_TRACER_ON(grpc_compression_trace)) {
char *algo_name;
const size_t before_size = calld->slices.length;
const size_t after_size = tmp.length;
const float savings_ratio = 1.0f - (float)after_size / (float)before_size;
GPR_ASSERT(grpc_compression_algorithm_name(calld->compression_algorithm,
&algo_name));
GPR_ASSERT(grpc_message_compression_algorithm_name(
calld->message_compression_algorithm, &algo_name));
gpr_log(GPR_DEBUG, "Compressed[%s] %" PRIuPTR " bytes vs. %" PRIuPTR
" bytes (%.2f%% savings)",
algo_name, before_size, after_size, 100 * savings_ratio);
@ -259,8 +240,8 @@ static void finish_send_message(grpc_exec_ctx *exec_ctx,
} else {
if (GRPC_TRACER_ON(grpc_compression_trace)) {
char *algo_name;
GPR_ASSERT(grpc_compression_algorithm_name(calld->compression_algorithm,
&algo_name));
GPR_ASSERT(grpc_message_compression_algorithm_name(
calld->message_compression_algorithm, &algo_name));
gpr_log(GPR_DEBUG,
"Algorithm '%s' enabled but decided not to compress. Input size: "
"%" PRIuPTR,
@ -484,12 +465,11 @@ static grpc_error *init_channel_elem(grpc_exec_ctx *exec_ctx,
grpc_channel_element_args *args) {
channel_data *channeld = (channel_data *)elem->channel_data;
/* Configuration for message compression */
channeld->enabled_algorithms_bitset =
grpc_channel_args_compression_algorithm_get_states(args->channel_args);
channeld->default_compression_algorithm =
grpc_channel_args_get_compression_algorithm(args->channel_args);
/* Make sure the default isn't disabled. */
if (!GPR_BITGET(channeld->enabled_algorithms_bitset,
channeld->default_compression_algorithm)) {
@ -499,31 +479,18 @@ static grpc_error *init_channel_elem(grpc_exec_ctx *exec_ctx,
channeld->default_compression_algorithm = GRPC_COMPRESS_NONE;
}
channeld->supported_compression_algorithms =
uint32_t supported_compression_algorithms =
(((1u << GRPC_COMPRESS_ALGORITHMS_COUNT) - 1) &
channeld->enabled_algorithms_bitset) |
1u;
/* Configuration for stream compression */
channeld->enabled_stream_compression_algorithms_bitset =
grpc_channel_args_stream_compression_algorithm_get_states(
args->channel_args);
channeld->default_stream_compression_algorithm =
grpc_channel_args_get_stream_compression_algorithm(args->channel_args);
if (!GPR_BITGET(channeld->enabled_stream_compression_algorithms_bitset,
channeld->default_stream_compression_algorithm)) {
gpr_log(GPR_DEBUG,
"stream compression algorithm %d not enabled: switching to none",
channeld->default_stream_compression_algorithm);
channeld->default_stream_compression_algorithm = GRPC_STREAM_COMPRESS_NONE;
}
channeld->supported_message_compression_algorithms =
grpc_compression_bitset_to_message_bitset(
supported_compression_algorithms);
channeld->supported_stream_compression_algorithms =
(((1u << GRPC_STREAM_COMPRESS_ALGORITHMS_COUNT) - 1) &
channeld->enabled_stream_compression_algorithms_bitset) |
1u;
grpc_compression_bitset_to_stream_bitset(
supported_compression_algorithms);
GPR_ASSERT(!args->is_last);
return GRPC_ERROR_NONE;

98
src/core/lib/channel/channel_args.c
Unescape View File

@ -223,21 +223,6 @@ grpc_compression_algorithm grpc_channel_args_get_compression_algorithm(
return GRPC_COMPRESS_NONE;
}
grpc_stream_compression_algorithm
grpc_channel_args_get_stream_compression_algorithm(const grpc_channel_args *a) {
size_t i;
if (a == NULL) return 0;
for (i = 0; i < a->num_args; ++i) {
if (a->args[i].type == GRPC_ARG_INTEGER &&
!strcmp(GRPC_STREAM_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM,
a->args[i].key)) {
return (grpc_stream_compression_algorithm)a->args[i].value.integer;
break;
}
}
return GRPC_STREAM_COMPRESS_NONE;
}
grpc_channel_args *grpc_channel_args_set_compression_algorithm(
grpc_channel_args *a, grpc_compression_algorithm algorithm) {
GPR_ASSERT(algorithm < GRPC_COMPRESS_ALGORITHMS_COUNT);
@ -248,16 +233,6 @@ grpc_channel_args *grpc_channel_args_set_compression_algorithm(
return grpc_channel_args_copy_and_add(a, &tmp, 1);
}
grpc_channel_args *grpc_channel_args_set_stream_compression_algorithm(
grpc_channel_args *a, grpc_stream_compression_algorithm algorithm) {
GPR_ASSERT(algorithm < GRPC_STREAM_COMPRESS_ALGORITHMS_COUNT);
grpc_arg tmp;
tmp.type = GRPC_ARG_INTEGER;
tmp.key = GRPC_STREAM_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. */
@ -278,26 +253,6 @@ static int find_compression_algorithm_states_bitset(const grpc_channel_args *a,
return 0; /* GPR_FALSE */
}
/** 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_stream_compression_algorithm_states_bitset(
const grpc_channel_args *a, int **states_arg) {
if (a != NULL) {
size_t i;
for (i = 0; i < a->num_args; ++i) {
if (a->args[i].type == GRPC_ARG_INTEGER &&
!strcmp(GRPC_STREAM_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET,
a->args[i].key)) {
*states_arg = &a->args[i].value.integer;
**states_arg |= 0x1; /* forcefully enable support for no compression */
return 1;
}
}
}
return 0; /* GPR_FALSE */
}
grpc_channel_args *grpc_channel_args_compression_algorithm_set_state(
grpc_exec_ctx *exec_ctx, grpc_channel_args **a,
grpc_compression_algorithm algorithm, int state) {
@ -339,48 +294,6 @@ grpc_channel_args *grpc_channel_args_compression_algorithm_set_state(
return result;
}
grpc_channel_args *grpc_channel_args_stream_compression_algorithm_set_state(
grpc_exec_ctx *exec_ctx, grpc_channel_args **a,
grpc_stream_compression_algorithm algorithm, int state) {
int *states_arg = NULL;
grpc_channel_args *result = *a;
const int states_arg_found =
find_stream_compression_algorithm_states_bitset(*a, &states_arg);
if (grpc_channel_args_get_stream_compression_algorithm(*a) == algorithm &&
state == 0) {
char *algo_name = NULL;
GPR_ASSERT(grpc_stream_compression_algorithm_name(algorithm, &algo_name) !=
0);
gpr_log(GPR_ERROR,
"Tried to disable default stream compression algorithm '%s'. The "
"operation has been ignored.",
algo_name);
} else if (states_arg_found) {
if (state != 0) {
GPR_BITSET((unsigned *)states_arg, algorithm);
} else if (algorithm != GRPC_STREAM_COMPRESS_NONE) {
GPR_BITCLEAR((unsigned *)states_arg, algorithm);
}
} else {
/* create a new arg */
grpc_arg tmp;
tmp.type = GRPC_ARG_INTEGER;
tmp.key = GRPC_STREAM_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET;
/* all enabled by default */
tmp.value.integer = (1u << GRPC_STREAM_COMPRESS_ALGORITHMS_COUNT) - 1;
if (state != 0) {
GPR_BITSET((unsigned *)&tmp.value.integer, algorithm);
} else if (algorithm != GRPC_STREAM_COMPRESS_NONE) {
GPR_BITCLEAR((unsigned *)&tmp.value.integer, algorithm);
}
result = grpc_channel_args_copy_and_add(*a, &tmp, 1);
grpc_channel_args_destroy(exec_ctx, *a);
*a = result;
}
return result;
}
uint32_t grpc_channel_args_compression_algorithm_get_states(
const grpc_channel_args *a) {
int *states_arg;
@ -391,17 +304,6 @@ uint32_t grpc_channel_args_compression_algorithm_get_states(
}
}
uint32_t grpc_channel_args_stream_compression_algorithm_get_states(
const grpc_channel_args *a) {
int *states_arg;
if (find_stream_compression_algorithm_states_bitset(a, &states_arg)) {
return (uint32_t)*states_arg;
} else {
return (1u << GRPC_STREAM_COMPRESS_ALGORITHMS_COUNT) -
1; /* All algs. enabled */
}
}
grpc_channel_args *grpc_channel_args_set_socket_mutator(
grpc_channel_args *a, grpc_socket_mutator *mutator) {
grpc_arg tmp = grpc_socket_mutator_to_arg(mutator);

31
src/core/lib/channel/channel_args.h
Unescape View File

@ -59,24 +59,12 @@ void grpc_channel_args_destroy(grpc_exec_ctx *exec_ctx, grpc_channel_args *a);
grpc_compression_algorithm grpc_channel_args_get_compression_algorithm(
const grpc_channel_args *a);
/** Returns the stream compression algorithm set in \a a. */
grpc_stream_compression_algorithm
grpc_channel_args_get_stream_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. */
grpc_channel_args *grpc_channel_args_set_compression_algorithm(
grpc_channel_args *a, grpc_compression_algorithm algorithm);
/** Returns a channel arg instance with stream compression enabled. If \a a is
* non-NULL, its args are copied. N.B. GRPC_STREAM_COMPRESS_NONE disables
* stream compression for the channel. If a value other than
* GRPC_STREAM_COMPRESS_NONE is set, it takes precedence over message-wise
* compression algorithms. */
grpc_channel_args *grpc_channel_args_set_stream_compression_algorithm(
grpc_channel_args *a, grpc_stream_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.
@ -88,17 +76,6 @@ grpc_channel_args *grpc_channel_args_compression_algorithm_set_state(
grpc_exec_ctx *exec_ctx, grpc_channel_args **a,
grpc_compression_algorithm algorithm, int enabled);
/** Sets the support for the given stream compression algorithm. By default, all
* stream compression algorithms are enabled. It's an error to disable an
* algorithm set by grpc_channel_args_set_stream_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). */
grpc_channel_args *grpc_channel_args_stream_compression_algorithm_set_state(
grpc_exec_ctx *exec_ctx, grpc_channel_args **a,
grpc_stream_compression_algorithm algorithm, int enabled);
/** Returns the bitset representing the support state (true for enabled, false
* for disabled) for compression algorithms.
*
@ -107,14 +84,6 @@ grpc_channel_args *grpc_channel_args_stream_compression_algorithm_set_state(
uint32_t grpc_channel_args_compression_algorithm_get_states(
const grpc_channel_args *a);
/** Returns the bitset representing the support state (true for enabled, false
* for disabled) for stream compression algorithms.
*
* The i-th bit of the returned bitset corresponds to the i-th entry in the
* grpc_stream_compression_algorithm enum. */
uint32_t grpc_channel_args_stream_compression_algorithm_get_states(
const grpc_channel_args *a);
int grpc_channel_args_compare(const grpc_channel_args *a,
const grpc_channel_args *b);

18
src/core/lib/compression/algorithm_metadata.h
Unescape View File

@ -20,20 +20,26 @@
#define GRPC_CORE_LIB_COMPRESSION_ALGORITHM_METADATA_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);
/** Return stream compression algorithm based metadata value */
grpc_slice grpc_stream_compression_algorithm_slice(
grpc_stream_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(
grpc_slice str);
/** Return compression algorithm based metadata element (grpc-encoding: xxx) */
/** 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(
@ -41,8 +47,8 @@ grpc_mdelem grpc_stream_compression_encoding_mdelem(
/** Find compression algorithm based on passed in mdstr - returns
* GRPC_COMPRESS_ALGORITHM_COUNT on failure */
grpc_compression_algorithm grpc_compression_algorithm_from_slice(
grpc_slice str);
grpc_message_compression_algorithm
grpc_message_compression_algorithm_from_slice(grpc_slice str);
/** Find stream compression algorithm based on passed in mdstr - returns
* GRPC_STREAM_COMPRESS_ALGORITHM_COUNT on failure */

281
src/core/lib/compression/compression.c
Unescape View File

@ -23,40 +23,39 @@
#include <grpc/support/useful.h>
#include "src/core/lib/compression/algorithm_metadata.h"
#include "src/core/lib/compression/compression_internal.h"
#include "src/core/lib/surface/api_trace.h"
#include "src/core/lib/transport/static_metadata.h"
int grpc_compression_algorithm_is_message(
grpc_compression_algorithm algorithm) {
return (algorithm >= GRPC_COMPRESS_MESSAGE_DEFLATE &&
algorithm <= GRPC_COMPRESS_MESSAGE_GZIP) ? 1 : 0;
}
int grpc_compression_algorithm_is_stream(
grpc_compression_algorithm algorithm) {
return (algorithm == GRPC_COMPRESS_STREAM_GZIP) ? 1 : 0;
}
int grpc_compression_algorithm_parse(grpc_slice name,
grpc_compression_algorithm *algorithm) {
/* we use strncmp not only because it's safer (even though in this case it
* doesn't matter, given that we are comparing against string literals, but
* because this way we needn't have "name" nil-terminated (useful for slice
* data, for example) */
if (grpc_slice_eq(name, GRPC_MDSTR_IDENTITY)) {
*algorithm = GRPC_COMPRESS_NONE;
return 1;
} else if (grpc_slice_eq(name, GRPC_MDSTR_GZIP)) {
*algorithm = GRPC_COMPRESS_GZIP;
} else if (grpc_slice_eq(name, GRPC_MDSTR_MESSAGE_SLASH_DEFLATE)) {
*algorithm = GRPC_COMPRESS_MESSAGE_DEFLATE;
return 1;
} else if (grpc_slice_eq(name, GRPC_MDSTR_DEFLATE)) {
*algorithm = GRPC_COMPRESS_DEFLATE;
} else if (grpc_slice_eq(name, GRPC_MDSTR_MESSAGE_SLASH_GZIP)) {
*algorithm = GRPC_COMPRESS_MESSAGE_GZIP;
return 1;
} else {
return 0;
}
}
int grpc_stream_compression_algorithm_parse(
grpc_slice name, grpc_stream_compression_algorithm *algorithm) {
if (grpc_slice_eq(name, GRPC_MDSTR_IDENTITY)) {
*algorithm = GRPC_STREAM_COMPRESS_NONE;
return 1;
} else if (grpc_slice_eq(name, GRPC_MDSTR_GZIP)) {
*algorithm = GRPC_STREAM_COMPRESS_GZIP;
} else if (grpc_slice_eq(name, GRPC_MDSTR_STREAM_SLASH_GZIP)) {
*algorithm = GRPC_COMPRESS_STREAM_GZIP;
return 1;
} else {
return 0;
}
return 0;
}
int grpc_compression_algorithm_name(grpc_compression_algorithm algorithm,
@ -67,11 +66,14 @@ int grpc_compression_algorithm_name(grpc_compression_algorithm algorithm,
case GRPC_COMPRESS_NONE:
*name = "identity";
return 1;
case GRPC_COMPRESS_DEFLATE:
*name = "deflate";
case GRPC_COMPRESS_MESSAGE_DEFLATE:
*name = "message/deflate";
return 1;
case GRPC_COMPRESS_MESSAGE_GZIP:
*name = "message/gzip";
return 1;
case GRPC_COMPRESS_GZIP:
*name = "gzip";
case GRPC_COMPRESS_STREAM_GZIP:
*name = "stream/gzip";
return 1;
case GRPC_COMPRESS_ALGORITHMS_COUNT:
return 0;
@ -79,37 +81,56 @@ int grpc_compression_algorithm_name(grpc_compression_algorithm algorithm,
return 0;
}
int grpc_stream_compression_algorithm_name(
grpc_stream_compression_algorithm algorithm, char **name) {
GRPC_API_TRACE(
"grpc_stream_compression_algorithm_parse(algorithm=%d, name=%p)", 2,
((int)algorithm, name));
switch (algorithm) {
case GRPC_STREAM_COMPRESS_NONE:
*name = "identity";
return 1;
case GRPC_STREAM_COMPRESS_GZIP:
*name = "gzip";
return 1;
case GRPC_STREAM_COMPRESS_ALGORITHMS_COUNT:
return 0;
grpc_compression_algorithm grpc_compression_algorithm_for_level(
grpc_compression_level level, uint32_t accepted_encodings) {
grpc_compression_algorithm algo;
if (level == GRPC_COMPRESS_LEVEL_NONE) {
return GRPC_COMPRESS_NONE;
} else if (level <= GRPC_COMPRESS_LEVEL_MESSAGE_HIGH) {
GPR_ASSERT(
grpc_compression_algorithm_from_message_stream_compression_algorithm(
&algo,
grpc_message_compression_algorithm_for_level(
grpc_compression_level_to_message_compression_level(level),
grpc_compression_bitset_to_message_bitset(
accepted_encodings)),
0));
return algo;
} else if (level <= GRPC_COMPRESS_LEVEL_STREAM_HIGH) {
GPR_ASSERT(
grpc_compression_algorithm_from_message_stream_compression_algorithm(
&algo, 0,
grpc_stream_compression_algorithm_for_level(
grpc_compression_level_to_stream_compression_level(level),
grpc_compression_bitset_to_stream_bitset(
accepted_encodings))));
return algo;
} else {
gpr_log(GPR_ERROR, "Unknown compression level: %d", level);
return GRPC_COMPRESS_NONE;
}
return 0;
}
grpc_compression_algorithm grpc_compression_algorithm_from_slice(
grpc_slice str) {
if (grpc_slice_eq(str, GRPC_MDSTR_IDENTITY)) return GRPC_COMPRESS_NONE;
if (grpc_slice_eq(str, GRPC_MDSTR_DEFLATE)) return GRPC_COMPRESS_DEFLATE;
if (grpc_slice_eq(str, GRPC_MDSTR_GZIP)) return GRPC_COMPRESS_GZIP;
return GRPC_COMPRESS_ALGORITHMS_COUNT;
void grpc_compression_options_init(grpc_compression_options *opts) {
memset(opts, 0, sizeof(*opts));
/* all enabled by default */
opts->enabled_algorithms_bitset = (1u << GRPC_COMPRESS_ALGORITHMS_COUNT) - 1;
}
grpc_stream_compression_algorithm grpc_stream_compression_algorithm_from_slice(
grpc_slice str) {
if (grpc_slice_eq(str, GRPC_MDSTR_IDENTITY)) return GRPC_STREAM_COMPRESS_NONE;
if (grpc_slice_eq(str, GRPC_MDSTR_GZIP)) return GRPC_STREAM_COMPRESS_GZIP;
return GRPC_STREAM_COMPRESS_ALGORITHMS_COUNT;
void grpc_compression_options_enable_algorithm(
grpc_compression_options *opts, grpc_compression_algorithm algorithm) {
GPR_BITSET(&opts->enabled_algorithms_bitset, algorithm);
}
void grpc_compression_options_disable_algorithm(
grpc_compression_options *opts, grpc_compression_algorithm algorithm) {
GPR_BITCLEAR(&opts->enabled_algorithms_bitset, algorithm);
}
int grpc_compression_options_is_algorithm_enabled(
const grpc_compression_options *opts,
grpc_compression_algorithm algorithm) {
return GPR_BITGET(opts->enabled_algorithms_bitset, algorithm);
}
grpc_slice grpc_compression_algorithm_slice(
@ -117,27 +138,25 @@ grpc_slice grpc_compression_algorithm_slice(
switch (algorithm) {
case GRPC_COMPRESS_NONE:
return GRPC_MDSTR_IDENTITY;
case GRPC_COMPRESS_DEFLATE:
return GRPC_MDSTR_DEFLATE;
case GRPC_COMPRESS_GZIP:
return GRPC_MDSTR_GZIP;
case GRPC_COMPRESS_MESSAGE_DEFLATE:
return GRPC_MDSTR_MESSAGE_SLASH_DEFLATE;
case GRPC_COMPRESS_MESSAGE_GZIP:
return GRPC_MDSTR_MESSAGE_SLASH_GZIP;
case GRPC_COMPRESS_STREAM_GZIP:
return GRPC_MDSTR_STREAM_SLASH_GZIP;
case GRPC_COMPRESS_ALGORITHMS_COUNT:
return grpc_empty_slice();
}
return grpc_empty_slice();
}
grpc_slice grpc_stream_compression_algorithm_slice(
grpc_stream_compression_algorithm algorithm) {
switch (algorithm) {
case GRPC_STREAM_COMPRESS_NONE:
return GRPC_MDSTR_IDENTITY;
case GRPC_STREAM_COMPRESS_GZIP:
return GRPC_MDSTR_GZIP;
case GRPC_STREAM_COMPRESS_ALGORITHMS_COUNT:
return grpc_empty_slice();
}
return grpc_empty_slice();
grpc_compression_algorithm grpc_compression_algorithm_from_slice(
grpc_slice str) {
if (grpc_slice_eq(str, GRPC_MDSTR_IDENTITY)) return GRPC_COMPRESS_NONE;
if (grpc_slice_eq(str, GRPC_MDSTR_MESSAGE_SLASH_DEFLATE)) return GRPC_COMPRESS_MESSAGE_DEFLATE;
if (grpc_slice_eq(str, GRPC_MDSTR_MESSAGE_SLASH_GZIP)) return GRPC_COMPRESS_MESSAGE_GZIP;
if (grpc_slice_eq(str, GRPC_MDSTR_STREAM_SLASH_GZIP)) return GRPC_COMPRESS_STREAM_GZIP;
return GRPC_COMPRESS_ALGORITHMS_COUNT;
}
grpc_mdelem grpc_compression_encoding_mdelem(
@ -145,9 +164,11 @@ grpc_mdelem grpc_compression_encoding_mdelem(
switch (algorithm) {
case GRPC_COMPRESS_NONE:
return GRPC_MDELEM_GRPC_ENCODING_IDENTITY;
case GRPC_COMPRESS_DEFLATE:
case GRPC_COMPRESS_MESSAGE_DEFLATE:
return GRPC_MDELEM_GRPC_ENCODING_DEFLATE;
case GRPC_COMPRESS_GZIP:
case GRPC_COMPRESS_MESSAGE_GZIP:
return GRPC_MDELEM_GRPC_ENCODING_GZIP;
case GRPC_COMPRESS_STREAM_GZIP:
return GRPC_MDELEM_GRPC_ENCODING_GZIP;
default:
break;
@ -155,129 +176,3 @@ grpc_mdelem grpc_compression_encoding_mdelem(
return GRPC_MDNULL;
}
grpc_mdelem grpc_stream_compression_encoding_mdelem(
grpc_stream_compression_algorithm algorithm) {
switch (algorithm) {
case GRPC_STREAM_COMPRESS_NONE:
return GRPC_MDELEM_CONTENT_ENCODING_IDENTITY;
case GRPC_STREAM_COMPRESS_GZIP:
return GRPC_MDELEM_CONTENT_ENCODING_GZIP;
default:
break;
}
return GRPC_MDNULL;
}
void grpc_compression_options_init(grpc_compression_options *opts) {
memset(opts, 0, sizeof(*opts));
/* all enabled by default */
opts->enabled_algorithms_bitset = (1u << GRPC_COMPRESS_ALGORITHMS_COUNT) - 1;
opts->enabled_stream_compression_algorithms_bitset =
(1u << GRPC_STREAM_COMPRESS_ALGORITHMS_COUNT) - 1;
}
void grpc_compression_options_enable_algorithm(
grpc_compression_options *opts, grpc_compression_algorithm algorithm) {
GPR_BITSET(&opts->enabled_algorithms_bitset, algorithm);
}
void grpc_compression_options_disable_algorithm(
grpc_compression_options *opts, grpc_compression_algorithm algorithm) {
GPR_BITCLEAR(&opts->enabled_algorithms_bitset, algorithm);
}
int grpc_compression_options_is_algorithm_enabled(
const grpc_compression_options *opts,
grpc_compression_algorithm algorithm) {
return GPR_BITGET(opts->enabled_algorithms_bitset, algorithm);
}
int grpc_compression_options_is_stream_compression_algorithm_enabled(
const grpc_compression_options *opts,
grpc_stream_compression_algorithm algorithm) {
return GPR_BITGET(opts->enabled_stream_compression_algorithms_bitset,
algorithm);
}
/* TODO(dgq): Add the ability to specify parameters to the individual
* compression algorithms */
grpc_compression_algorithm grpc_compression_algorithm_for_level(
grpc_compression_level level, uint32_t accepted_encodings) {
GRPC_API_TRACE("grpc_compression_algorithm_for_level(level=%d)", 1,
((int)level));
if (level > GRPC_COMPRESS_LEVEL_HIGH) {
gpr_log(GPR_ERROR, "Unknown compression level %d.", (int)level);
abort();
}
const size_t num_supported =
GPR_BITCOUNT(accepted_encodings) - 1; /* discard NONE */
if (level == GRPC_COMPRESS_LEVEL_NONE || num_supported == 0) {
return GRPC_COMPRESS_NONE;
}
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). */
const grpc_compression_algorithm algos_ranking[] = {GRPC_COMPRESS_GZIP,
GRPC_COMPRESS_DEFLATE};
/* intersect algos_ranking with the supported ones keeping the ranked order */
grpc_compression_algorithm
sorted_supported_algos[GRPC_COMPRESS_ALGORITHMS_COUNT];
size_t algos_supported_idx = 0;
for (size_t i = 0; i < GPR_ARRAY_SIZE(algos_ranking); i++) {
const grpc_compression_algorithm alg = algos_ranking[i];
for (size_t j = 0; j < num_supported; j++) {
if (GPR_BITGET(accepted_encodings, alg) == 1) {
/* if \a alg in supported */
sorted_supported_algos[algos_supported_idx++] = alg;
break;
}
}
if (algos_supported_idx == num_supported) break;
}
switch (level) {
case GRPC_COMPRESS_LEVEL_NONE:
abort(); /* should have been handled already */
case GRPC_COMPRESS_LEVEL_LOW:
return sorted_supported_algos[0];
case GRPC_COMPRESS_LEVEL_MED:
return sorted_supported_algos[num_supported / 2];
case GRPC_COMPRESS_LEVEL_HIGH:
return sorted_supported_algos[num_supported - 1];
default:
abort();
};
}
GRPCAPI grpc_stream_compression_algorithm
grpc_stream_compression_algorithm_for_level(
grpc_stream_compression_level level, uint32_t accepted_stream_encodings) {
GRPC_API_TRACE("grpc_stream_compression_algorithm_for_level(level=%d)", 1,
((int)level));
if (level > GRPC_STREAM_COMPRESS_LEVEL_HIGH) {
gpr_log(GPR_ERROR, "Unknown compression level %d.", (int)level);
abort();
}
switch (level) {
case GRPC_STREAM_COMPRESS_LEVEL_NONE:
return GRPC_STREAM_COMPRESS_NONE;
case GRPC_STREAM_COMPRESS_LEVEL_LOW:
case GRPC_STREAM_COMPRESS_LEVEL_MED:
case GRPC_STREAM_COMPRESS_LEVEL_HIGH:
if (GPR_BITGET(accepted_stream_encodings, GRPC_STREAM_COMPRESS_GZIP) ==
1) {
return GRPC_STREAM_COMPRESS_GZIP;
} else {
return GRPC_STREAM_COMPRESS_NONE;
}
default:
abort();
}
}

310
src/core/lib/compression/compression_internal.c
Unescape View File

@ -0,0 +1,310 @@
/*
*
* 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 <stdlib.h>
#include <string.h>
#include <grpc/compression.h>
#include <grpc/support/useful.h>
#include "src/core/lib/compression/algorithm_metadata.h"
#include "src/core/lib/compression/compression_internal.h"
#include "src/core/lib/surface/api_trace.h"
#include "src/core/lib/transport/static_metadata.h"
/* Interfaces related to MD */
grpc_message_compression_algorithm
grpc_message_compression_algorithm_from_slice(grpc_slice str) {
if (grpc_slice_eq(str, GRPC_MDSTR_IDENTITY))
return GRPC_MESSAGE_COMPRESS_NONE;
if (grpc_slice_eq(str, GRPC_MDSTR_DEFLATE))
return GRPC_MESSAGE_COMPRESS_DEFLATE;
if (grpc_slice_eq(str, GRPC_MDSTR_GZIP)) return GRPC_MESSAGE_COMPRESS_GZIP;
return GRPC_MESSAGE_COMPRESS_ALGORITHMS_COUNT;
}
grpc_stream_compression_algorithm grpc_stream_compression_algorithm_from_slice(
grpc_slice str) {
if (grpc_slice_eq(str, GRPC_MDSTR_IDENTITY)) return GRPC_STREAM_COMPRESS_NONE;
if (grpc_slice_eq(str, GRPC_MDSTR_GZIP)) return GRPC_STREAM_COMPRESS_GZIP;
return GRPC_STREAM_COMPRESS_ALGORITHMS_COUNT;
}
grpc_mdelem grpc_message_compression_encoding_mdelem(
grpc_message_compression_algorithm algorithm) {
switch (algorithm) {
case GRPC_MESSAGE_COMPRESS_NONE:
return GRPC_MDELEM_GRPC_ENCODING_IDENTITY;
case GRPC_MESSAGE_COMPRESS_DEFLATE:
return GRPC_MDELEM_GRPC_ENCODING_DEFLATE;
case GRPC_MESSAGE_COMPRESS_GZIP:
return GRPC_MDELEM_GRPC_ENCODING_GZIP;
default:
break;
}
return GRPC_MDNULL;
}
grpc_mdelem grpc_stream_compression_encoding_mdelem(
grpc_stream_compression_algorithm algorithm) {
switch (algorithm) {
case GRPC_STREAM_COMPRESS_NONE:
return GRPC_MDELEM_CONTENT_ENCODING_IDENTITY;
case GRPC_STREAM_COMPRESS_GZIP:
return GRPC_MDELEM_CONTENT_ENCODING_GZIP;
default:
break;
}
return GRPC_MDNULL;
}
/* Interfaces performing transformation between compression algorithms and
* levels. */
grpc_message_compression_level
grpc_compression_level_to_message_compression_level(
grpc_compression_level level) {
if (level >= GRPC_COMPRESS_LEVEL_COUNT) {
return GRPC_MESSAGE_COMPRESS_LEVEL_NONE;
}
return (grpc_message_compression_level)(
(uint32_t)(level - GRPC_COMPRESS_LEVEL_NONE) +
(uint32_t)GRPC_MESSAGE_COMPRESS_LEVEL_NONE);
}
grpc_stream_compression_level
grpc_compression_level_to_stream_compression_level(
grpc_compression_level level) {
if (level >= GRPC_COMPRESS_LEVEL_COUNT) {
return GRPC_STREAM_COMPRESS_LEVEL_NONE;
}
return (grpc_stream_compression_level)(
(uint32_t)(level - (GRPC_MESSAGE_COMPRESS_LEVEL_COUNT - 1) - GRPC_COMPRESS_LEVEL_NONE) +
(uint32_t)GRPC_STREAM_COMPRESS_LEVEL_NONE);
}
grpc_message_compression_algorithm
grpc_compression_algorithm_to_message_compression_algorithm(
grpc_compression_algorithm algo) {
switch (algo) {
case GRPC_COMPRESS_MESSAGE_DEFLATE:
return GRPC_MESSAGE_COMPRESS_DEFLATE;
case GRPC_COMPRESS_MESSAGE_GZIP:
return GRPC_MESSAGE_COMPRESS_GZIP;
default:
return GRPC_MESSAGE_COMPRESS_NONE;
}
}
grpc_stream_compression_algorithm
grpc_compression_algorithm_to_stream_compression_algorithm(
grpc_compression_algorithm algo) {
switch (algo) {
case GRPC_COMPRESS_STREAM_GZIP:
return GRPC_STREAM_COMPRESS_GZIP;
default:
return GRPC_STREAM_COMPRESS_NONE;
}
}
uint32_t grpc_compression_bitset_to_message_bitset(uint32_t bitset) {
return bitset & ((1u << GRPC_MESSAGE_COMPRESS_ALGORITHMS_COUNT) - 1);
}
uint32_t grpc_compression_bitset_to_stream_bitset(uint32_t bitset) {
uint32_t identity = (bitset & 1u);
uint32_t other_bits =
(bitset >> (GRPC_MESSAGE_COMPRESS_ALGORITHMS_COUNT - 1)) &
((1u << GRPC_STREAM_COMPRESS_ALGORITHMS_COUNT) - 2);
return identity | other_bits;
}
uint32_t grpc_compression_bitset_from_message_stream_compression_bitset(
uint32_t message_bitset, uint32_t stream_bitset) {
uint32_t offset_stream_bitset = (stream_bitset & 1u) | ((stream_bitset & (~1u)) << (GRPC_MESSAGE_COMPRESS_ALGORITHMS_COUNT - 1));
return message_bitset | offset_stream_bitset;
}
int grpc_compression_algorithm_from_message_stream_compression_algorithm(
grpc_compression_algorithm *algorithm,
grpc_message_compression_algorithm message_algorithm,
grpc_stream_compression_algorithm stream_algorithm) {
if (message_algorithm != GRPC_MESSAGE_COMPRESS_NONE &&
stream_algorithm != GRPC_STREAM_COMPRESS_NONE) {
*algorithm = GRPC_COMPRESS_NONE;
return 0;
}
if (message_algorithm == GRPC_MESSAGE_COMPRESS_NONE) {
switch (stream_algorithm) {
case GRPC_STREAM_COMPRESS_NONE:
*algorithm = GRPC_COMPRESS_NONE;
return 1;
case GRPC_STREAM_COMPRESS_GZIP:
*algorithm = GRPC_COMPRESS_STREAM_GZIP;
return 1;
default:
*algorithm = GRPC_COMPRESS_NONE;
return 0;
}
} else {
switch (message_algorithm) {
case GRPC_MESSAGE_COMPRESS_NONE:
*algorithm = GRPC_COMPRESS_NONE;
return 1;
case GRPC_MESSAGE_COMPRESS_DEFLATE:
*algorithm = GRPC_COMPRESS_MESSAGE_DEFLATE;
return 1;
case GRPC_MESSAGE_COMPRESS_GZIP:
*algorithm = GRPC_COMPRESS_MESSAGE_GZIP;
return 1;
default:
*algorithm = GRPC_COMPRESS_NONE;
return 0;
}
}
return 0;
}
/* Interfaces for message compression. */
int grpc_message_compression_algorithm_name(
grpc_message_compression_algorithm algorithm, char **name) {
GRPC_API_TRACE("grpc_message_compression_algorithm_parse(algorithm=%d, name=%p)", 2,
((int)algorithm, name));
switch (algorithm) {
case GRPC_MESSAGE_COMPRESS_NONE:
*name = "identity";
return 1;
case GRPC_MESSAGE_COMPRESS_DEFLATE:
*name = "deflate";
return 1;
case GRPC_MESSAGE_COMPRESS_GZIP:
*name = "gzip";
return 1;
case GRPC_MESSAGE_COMPRESS_ALGORITHMS_COUNT:
return 0;
}
return 0;
}
/* TODO(dgq): Add the ability to specify parameters to the individual
* compression algorithms */
grpc_message_compression_algorithm grpc_message_compression_algorithm_for_level(
grpc_message_compression_level level, uint32_t accepted_encodings) {
GRPC_API_TRACE("grpc_message_compression_algorithm_for_level(level=%d)", 1,
((int)level));
if (level > GRPC_MESSAGE_COMPRESS_LEVEL_HIGH) {
gpr_log(GPR_ERROR, "Unknown message compression level %d.", (int)level);
abort();
}
const size_t num_supported =
GPR_BITCOUNT(accepted_encodings) - 1; /* discard NONE */
if (level == GRPC_MESSAGE_COMPRESS_LEVEL_NONE || num_supported == 0) {
return GRPC_MESSAGE_COMPRESS_NONE;
}
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). */
const grpc_message_compression_algorithm algos_ranking[] = {
GRPC_MESSAGE_COMPRESS_GZIP, GRPC_MESSAGE_COMPRESS_DEFLATE};
/* intersect algos_ranking with the supported ones keeping the ranked order */
grpc_message_compression_algorithm
sorted_supported_algos[GRPC_MESSAGE_COMPRESS_ALGORITHMS_COUNT];
size_t algos_supported_idx = 0;
for (size_t i = 0; i < GPR_ARRAY_SIZE(algos_ranking); i++) {
const grpc_message_compression_algorithm alg = algos_ranking[i];
for (size_t j = 0; j < num_supported; j++) {
if (GPR_BITGET(accepted_encodings, alg) == 1) {
/* if \a alg in supported */
sorted_supported_algos[algos_supported_idx++] = alg;
break;
}
}
if (algos_supported_idx == num_supported) break;
}
switch (level) {
case GRPC_MESSAGE_COMPRESS_LEVEL_NONE:
abort(); /* should have been handled already */
case GRPC_MESSAGE_COMPRESS_LEVEL_LOW:
return sorted_supported_algos[0];
case GRPC_MESSAGE_COMPRESS_LEVEL_MED:
return sorted_supported_algos[num_supported / 2];
case GRPC_MESSAGE_COMPRESS_LEVEL_HIGH:
return sorted_supported_algos[num_supported - 1];
default:
abort();
};
}
int grpc_message_compression_algorithm_parse(
grpc_slice value, grpc_message_compression_algorithm *algorithm) {
if (grpc_slice_eq(value, GRPC_MDSTR_IDENTITY)) {
*algorithm = GRPC_MESSAGE_COMPRESS_NONE;
return 1;
} else if (grpc_slice_eq(value, GRPC_MDSTR_DEFLATE)) {
*algorithm = GRPC_MESSAGE_COMPRESS_DEFLATE;
return 1;
} else if (grpc_slice_eq(value, GRPC_MDSTR_GZIP)) {
*algorithm = GRPC_MESSAGE_COMPRESS_GZIP;
return 1;
} else {
return 0;
}
return 0;
}
/* Interfaces for stream compression. */
grpc_stream_compression_algorithm grpc_stream_compression_algorithm_for_level(
grpc_stream_compression_level level, uint32_t accepted_encodings) {
GRPC_API_TRACE("grpc_stream_compression_algorithm_for_level(level=%d)", 1,
((int)level));
if (level > GRPC_STREAM_COMPRESS_LEVEL_HIGH) {
gpr_log(GPR_ERROR, "Unknown stream compression level %d.", (int)level);
abort();
}
/* TODO(mxyan): Use more sophisticated scheme when more algorithms added. */
if (level != GRPC_STREAM_COMPRESS_LEVEL_NONE &&
GPR_BITGET(accepted_encodings, GRPC_STREAM_COMPRESS_GZIP)) {
return GRPC_STREAM_COMPRESS_GZIP;
}
return GRPC_STREAM_COMPRESS_NONE;
}
int grpc_stream_compression_algorithm_parse(
grpc_slice value, grpc_stream_compression_algorithm *algorithm) {
if (grpc_slice_eq(value, GRPC_MDSTR_IDENTITY)) {
*algorithm = GRPC_STREAM_COMPRESS_NONE;
return 1;
} else if (grpc_slice_eq(value, GRPC_MDSTR_GZIP)) {
*algorithm = GRPC_STREAM_COMPRESS_GZIP;
return 1;
} else {
return 0;
}
return 0;
}

110
src/core/lib/compression/compression_internal.h
Unescape View File

@ -0,0 +1,110 @@
/*
*
* 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
#include <grpc/impl/codegen/compression_types.h>
typedef enum {
GRPC_MESSAGE_COMPRESS_NONE = 0,
GRPC_MESSAGE_COMPRESS_DEFLATE,
GRPC_MESSAGE_COMPRESS_GZIP,
/* TODO(ctiller): snappy */
GRPC_MESSAGE_COMPRESS_ALGORITHMS_COUNT
} grpc_message_compression_algorithm;
/** Stream compresssion algorithms supported by gRPC */
typedef enum {
GRPC_STREAM_COMPRESS_NONE = 0,
GRPC_STREAM_COMPRESS_GZIP,
GRPC_STREAM_COMPRESS_ALGORITHMS_COUNT
} grpc_stream_compression_algorithm;
/** Compression levels allow a party with knowledge of its peer's accepted
* encodings to request compression in an abstract way. The level-algorithm
* mapping is performed internally and depends on the peer's supported
* compression algorithms. */
typedef enum {
GRPC_MESSAGE_COMPRESS_LEVEL_NONE = 0,
GRPC_MESSAGE_COMPRESS_LEVEL_LOW,
GRPC_MESSAGE_COMPRESS_LEVEL_MED,
GRPC_MESSAGE_COMPRESS_LEVEL_HIGH,
GRPC_MESSAGE_COMPRESS_LEVEL_COUNT
} grpc_message_compression_level;
/** Compression levels for stream compression algorithms */
typedef enum {
GRPC_STREAM_COMPRESS_LEVEL_NONE = 0,
GRPC_STREAM_COMPRESS_LEVEL_LOW,
GRPC_STREAM_COMPRESS_LEVEL_MED,
GRPC_STREAM_COMPRESS_LEVEL_HIGH,
GRPC_STREAM_COMPRESS_LEVEL_COUNT
} grpc_stream_compression_level;
/* Interfaces performing transformation between compression algorithms and
* levels. */
grpc_message_compression_level
grpc_compression_level_to_message_compression_level(
grpc_compression_level level);
grpc_stream_compression_level
grpc_compression_level_to_stream_compression_level(
grpc_compression_level level);
grpc_message_compression_algorithm
grpc_compression_algorithm_to_message_compression_algorithm(
grpc_compression_algorithm algo);
grpc_stream_compression_algorithm
grpc_compression_algorithm_to_stream_compression_algorithm(
grpc_compression_algorithm algo);
uint32_t grpc_compression_bitset_to_message_bitset(uint32_t bitset);
uint32_t grpc_compression_bitset_to_stream_bitset(uint32_t bitset);
uint32_t grpc_compression_bitset_from_message_stream_compression_bitset(
uint32_t message_bitset, uint32_t stream_bitset);
int grpc_compression_algorithm_from_message_stream_compression_algorithm(
grpc_compression_algorithm *algorithm,
grpc_message_compression_algorithm message_algorithm,
grpc_stream_compression_algorithm stream_algorithm);
/* Interfaces for message compression. */
int grpc_message_compression_algorithm_name(
grpc_message_compression_algorithm algorithm, char **name);
grpc_message_compression_algorithm grpc_message_compression_algorithm_for_level(
grpc_message_compression_level level, uint32_t accepted_encodings);
int grpc_message_compression_algorithm_parse(
grpc_slice value, grpc_message_compression_algorithm *algorithm);
/* Interfaces for stream compression. */
grpc_stream_compression_algorithm grpc_stream_compression_algorithm_for_level(
grpc_stream_compression_level level, uint32_t accepted_encodings);
int grpc_stream_compression_algorithm_parse(
grpc_slice value, grpc_stream_compression_algorithm *algorithm);
#endif /* GRPC_CORE_LIB_COMPRESSION_COMPRESSION_INTERNAL_H */

22
src/core/lib/compression/message_compress.c
Unescape View File

@ -143,18 +143,18 @@ static int copy(grpc_slice_buffer* input, grpc_slice_buffer* output) {
}
static int compress_inner(grpc_exec_ctx* exec_ctx,
grpc_compression_algorithm algorithm,
grpc_message_compression_algorithm algorithm,
grpc_slice_buffer* input, grpc_slice_buffer* output) {
switch (algorithm) {
case GRPC_COMPRESS_NONE:
case GRPC_MESSAGE_COMPRESS_NONE:
/* the fallback path always needs to be send uncompressed: we simply
rely on that here */
return 0;
case GRPC_COMPRESS_DEFLATE:
case GRPC_MESSAGE_COMPRESS_DEFLATE:
return zlib_compress(exec_ctx, input, output, 0);
case GRPC_COMPRESS_GZIP:
case GRPC_MESSAGE_COMPRESS_GZIP:
return zlib_compress(exec_ctx, input, output, 1);
case GRPC_COMPRESS_ALGORITHMS_COUNT:
case GRPC_MESSAGE_COMPRESS_ALGORITHMS_COUNT:
break;
}
gpr_log(GPR_ERROR, "invalid compression algorithm %d", algorithm);
@ -162,7 +162,7 @@ static int compress_inner(grpc_exec_ctx* exec_ctx,
}
int grpc_msg_compress(grpc_exec_ctx* exec_ctx,
grpc_compression_algorithm algorithm,
grpc_message_compression_algorithm algorithm,
grpc_slice_buffer* input, grpc_slice_buffer* output) {
if (!compress_inner(exec_ctx, algorithm, input, output)) {
copy(input, output);
@ -172,16 +172,16 @@ int grpc_msg_compress(grpc_exec_ctx* exec_ctx,
}
int grpc_msg_decompress(grpc_exec_ctx* exec_ctx,
grpc_compression_algorithm algorithm,
grpc_message_compression_algorithm algorithm,
grpc_slice_buffer* input, grpc_slice_buffer* output) {
switch (algorithm) {
case GRPC_COMPRESS_NONE:
case GRPC_MESSAGE_COMPRESS_NONE:
return copy(input, output);
case GRPC_COMPRESS_DEFLATE:
case GRPC_MESSAGE_COMPRESS_DEFLATE:
return zlib_decompress(exec_ctx, input, output, 0);
case GRPC_COMPRESS_GZIP:
case GRPC_MESSAGE_COMPRESS_GZIP:
return zlib_decompress(exec_ctx, input, output, 1);
case GRPC_COMPRESS_ALGORITHMS_COUNT:
case GRPC_MESSAGE_COMPRESS_ALGORITHMS_COUNT:
break;
}
gpr_log(GPR_ERROR, "invalid compression algorithm %d", algorithm);

7
src/core/lib/compression/message_compress.h
Unescape View File

@ -19,21 +19,22 @@
#ifndef GRPC_CORE_LIB_COMPRESSION_MESSAGE_COMPRESS_H
#define GRPC_CORE_LIB_COMPRESSION_MESSAGE_COMPRESS_H
#include <grpc/compression.h>
#include <grpc/slice_buffer.h>
#include "src/core/lib/compression/compression_internal.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. */
int grpc_msg_compress(grpc_exec_ctx* exec_ctx,
grpc_compression_algorithm algorithm,
grpc_message_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. */
int grpc_msg_decompress(grpc_exec_ctx* exec_ctx,
grpc_compression_algorithm algorithm,
grpc_message_compression_algorithm algorithm,
grpc_slice_buffer* input, grpc_slice_buffer* output);
#endif /* GRPC_CORE_LIB_COMPRESSION_MESSAGE_COMPRESS_H */

2
src/core/lib/surface/byte_buffer_reader.c
Unescape View File

@ -50,7 +50,7 @@ int grpc_byte_buffer_reader_init(grpc_byte_buffer_reader *reader,
grpc_slice_buffer_init(&decompressed_slices_buffer);
if (is_compressed(reader->buffer_in)) {
if (grpc_msg_decompress(&exec_ctx,
reader->buffer_in->data.raw.compression,
grpc_compression_algorithm_to_message_compression_algorithm(reader->buffer_in->data.raw.compression),
&reader->buffer_in->data.raw.slice_buffer,
&decompressed_slices_buffer) == 0) {
gpr_log(GPR_ERROR,

279
src/core/lib/surface/call.c
Unescape View File

@ -199,7 +199,7 @@ struct grpc_call {
grpc_call_final_info final_info;
/* Compression algorithm for *incoming* data */
grpc_compression_algorithm incoming_compression_algorithm;
grpc_message_compression_algorithm incoming_message_compression_algorithm;
/* Stream compression algorithm for *incoming* data */
grpc_stream_compression_algorithm incoming_stream_compression_algorithm;
/* Supported encodings (compression algorithms), a bitset */
@ -342,7 +342,7 @@ grpc_error *grpc_call_create(grpc_exec_ctx *exec_ctx,
call->cq = args->cq;
call->start_time = gpr_now(GPR_CLOCK_MONOTONIC);
/* Always support no compression */
GPR_BITSET(&call->encodings_accepted_by_peer, GRPC_COMPRESS_NONE);
GPR_BITSET(&call->encodings_accepted_by_peer, GRPC_MESSAGE_COMPRESS_NONE);
call->is_client = args->server_transport_data == NULL;
if (call->is_client) {
GRPC_STATS_INC_CLIENT_CALLS_CREATED(exec_ctx);
@ -818,10 +818,10 @@ static void set_status_from_error(grpc_exec_ctx *exec_ctx, grpc_call *call,
* COMPRESSION
*/
static void set_incoming_compression_algorithm(
grpc_call *call, grpc_compression_algorithm algo) {
GPR_ASSERT(algo < GRPC_COMPRESS_ALGORITHMS_COUNT);
call->incoming_compression_algorithm = algo;
static void set_incoming_message_compression_algorithm(
grpc_call *call, grpc_message_compression_algorithm algo) {
GPR_ASSERT(algo < GRPC_MESSAGE_COMPRESS_ALGORITHMS_COUNT);
call->incoming_message_compression_algorithm = algo;
}
static void set_incoming_stream_compression_algorithm(
@ -830,10 +830,12 @@ static void set_incoming_stream_compression_algorithm(
call->incoming_stream_compression_algorithm = algo;
}
grpc_compression_algorithm grpc_call_test_only_get_compression_algorithm(
grpc_call *call) {
grpc_compression_algorithm algorithm;
algorithm = call->incoming_compression_algorithm;
grpc_compression_algorithm
grpc_call_test_only_get_compression_algorithm(grpc_call *call) {
grpc_compression_algorithm algorithm = GRPC_COMPRESS_NONE;
grpc_compression_algorithm_from_message_stream_compression_algorithm(
&algorithm, call->incoming_message_compression_algorithm,
call->incoming_stream_compression_algorithm);
return algorithm;
}
@ -843,13 +845,6 @@ static grpc_compression_algorithm compression_algorithm_for_level_locked(
call->encodings_accepted_by_peer);
}
static grpc_stream_compression_algorithm
stream_compression_algorithm_for_level_locked(
grpc_call *call, grpc_stream_compression_level level) {
return grpc_stream_compression_algorithm_for_level(
level, call->stream_encodings_accepted_by_peer);
}
uint32_t grpc_call_test_only_get_message_flags(grpc_call *call) {
uint32_t flags;
flags = call->test_only_last_message_flags;
@ -859,9 +854,11 @@ uint32_t grpc_call_test_only_get_message_flags(grpc_call *call) {
static void destroy_encodings_accepted_by_peer(void *p) { return; }
static void set_encodings_accepted_by_peer(grpc_exec_ctx *exec_ctx,
grpc_call *call, grpc_mdelem mdel) {
grpc_call *call, grpc_mdelem mdel,
uint32_t *encodings_accepted_by_peer,
bool stream_encoding) {
size_t i;
grpc_compression_algorithm algorithm;
uint32_t algorithm;
grpc_slice_buffer accept_encoding_parts;
grpc_slice accept_encoding_slice;
void *accepted_user_data;
@ -869,70 +866,32 @@ static void set_encodings_accepted_by_peer(grpc_exec_ctx *exec_ctx,
accepted_user_data =
grpc_mdelem_get_user_data(mdel, destroy_encodings_accepted_by_peer);
if (accepted_user_data != NULL) {
call->encodings_accepted_by_peer =
*encodings_accepted_by_peer =
(uint32_t)(((uintptr_t)accepted_user_data) - 1);
return;
}
*encodings_accepted_by_peer = 0;
accept_encoding_slice = GRPC_MDVALUE(mdel);
grpc_slice_buffer_init(&accept_encoding_parts);
grpc_slice_split(accept_encoding_slice, ",", &accept_encoding_parts);
/* No need to zero call->encodings_accepted_by_peer: grpc_call_create already
* zeroes the whole grpc_call */
/* Always support no compression */
GPR_BITSET(&call->encodings_accepted_by_peer, GRPC_COMPRESS_NONE);
GPR_BITSET(encodings_accepted_by_peer, GRPC_COMPRESS_NONE);
for (i = 0; i < accept_encoding_parts.count; i++) {
int r;
grpc_slice accept_encoding_entry_slice = accept_encoding_parts.slices[i];
if (grpc_compression_algorithm_parse(accept_encoding_entry_slice,
&algorithm)) {
GPR_BITSET(&call->encodings_accepted_by_peer, algorithm);
if (!stream_encoding) {
r = grpc_message_compression_algorithm_parse(
accept_encoding_entry_slice,
(grpc_message_compression_algorithm *)&algorithm);
} else {
char *accept_encoding_entry_str =
grpc_slice_to_c_string(accept_encoding_entry_slice);
gpr_log(GPR_ERROR,
"Invalid entry in accept encoding metadata: '%s'. Ignoring.",
accept_encoding_entry_str);
gpr_free(accept_encoding_entry_str);
}
}
grpc_slice_buffer_destroy_internal(exec_ctx, &accept_encoding_parts);
grpc_mdelem_set_user_data(
mdel, destroy_encodings_accepted_by_peer,
(void *)(((uintptr_t)call->encodings_accepted_by_peer) + 1));
}
static void set_stream_encodings_accepted_by_peer(grpc_exec_ctx *exec_ctx,
grpc_call *call,
grpc_mdelem mdel) {
size_t i;
grpc_stream_compression_algorithm algorithm;
grpc_slice_buffer accept_encoding_parts;
grpc_slice accept_encoding_slice;
void *accepted_user_data;
accepted_user_data =
grpc_mdelem_get_user_data(mdel, destroy_encodings_accepted_by_peer);
if (accepted_user_data != NULL) {
call->stream_encodings_accepted_by_peer =
(uint32_t)(((uintptr_t)accepted_user_data) - 1);
return;
r = grpc_stream_compression_algorithm_parse(
accept_encoding_entry_slice,
(grpc_stream_compression_algorithm *)&algorithm);
}
accept_encoding_slice = GRPC_MDVALUE(mdel);
grpc_slice_buffer_init(&accept_encoding_parts);
grpc_slice_split(accept_encoding_slice, ",", &accept_encoding_parts);
/* Always support no compression */
GPR_BITSET(&call->stream_encodings_accepted_by_peer,
GRPC_STREAM_COMPRESS_NONE);
for (i = 0; i < accept_encoding_parts.count; i++) {
grpc_slice accept_encoding_entry_slice = accept_encoding_parts.slices[i];
if (grpc_stream_compression_algorithm_parse(accept_encoding_entry_slice,
&algorithm)) {
GPR_BITSET(&call->stream_encodings_accepted_by_peer, algorithm);
if (r) {
GPR_BITSET(encodings_accepted_by_peer, algorithm);
} else {
char *accept_encoding_entry_str =
grpc_slice_to_c_string(accept_encoding_entry_slice);
@ -947,7 +906,7 @@ static void set_stream_encodings_accepted_by_peer(grpc_exec_ctx *exec_ctx,
grpc_mdelem_set_user_data(
mdel, destroy_encodings_accepted_by_peer,
(void *)(((uintptr_t)call->stream_encodings_accepted_by_peer) + 1));
(void *)(((uintptr_t)(*encodings_accepted_by_peer)) + 1));
}
uint32_t grpc_call_test_only_get_encodings_accepted_by_peer(grpc_call *call) {
@ -956,13 +915,6 @@ uint32_t grpc_call_test_only_get_encodings_accepted_by_peer(grpc_call *call) {
return encodings_accepted_by_peer;
}
uint32_t grpc_call_test_only_get_stream_encodings_accepted_by_peer(
grpc_call *call) {
uint32_t stream_encodings_accepted_by_peer;
stream_encodings_accepted_by_peer = call->stream_encodings_accepted_by_peer;
return stream_encodings_accepted_by_peer;
}
grpc_stream_compression_algorithm
grpc_call_test_only_get_incoming_stream_encodings(grpc_call *call) {
return call->incoming_stream_compression_algorithm;
@ -1064,17 +1016,17 @@ static uint32_t decode_status(grpc_mdelem md) {
return status;
}
static grpc_compression_algorithm decode_compression(grpc_mdelem md) {
grpc_compression_algorithm algorithm =
grpc_compression_algorithm_from_slice(GRPC_MDVALUE(md));
if (algorithm == GRPC_COMPRESS_ALGORITHMS_COUNT) {
static grpc_message_compression_algorithm decode_message_compression(grpc_mdelem md) {
grpc_message_compression_algorithm algorithm =
grpc_message_compression_algorithm_from_slice(GRPC_MDVALUE(md));
if (algorithm == GRPC_MESSAGE_COMPRESS_ALGORITHMS_COUNT) {
char *md_c_str = grpc_slice_to_c_string(GRPC_MDVALUE(md));
gpr_log(GPR_ERROR,
"Invalid incoming compression algorithm: '%s'. Interpreting "
"incoming data as uncompressed.",
"Invalid incoming message compression algorithm: '%s'. "
"Interpreting incoming data as uncompressed.",
md_c_str);
gpr_free(md_c_str);
return GRPC_COMPRESS_NONE;
return GRPC_MESSAGE_COMPRESS_NONE;
}
return algorithm;
}
@ -1120,38 +1072,41 @@ static void publish_app_metadata(grpc_call *call, grpc_metadata_batch *b,
static void recv_initial_filter(grpc_exec_ctx *exec_ctx, grpc_call *call,
grpc_metadata_batch *b) {
if (b->idx.named.content_encoding != NULL) {
if (b->idx.named.grpc_encoding != NULL) {
gpr_log(GPR_ERROR,
"Received both content-encoding and grpc-encoding header. "
"Ignoring grpc-encoding.");
grpc_metadata_batch_remove(exec_ctx, b, b->idx.named.grpc_encoding);
}
GPR_TIMER_BEGIN("incoming_stream_compression_algorithm", 0);
set_incoming_stream_compression_algorithm(
call, decode_stream_compression(b->idx.named.content_encoding->md));
GPR_TIMER_END("incoming_stream_compression_algorithm", 0);
grpc_metadata_batch_remove(exec_ctx, b, b->idx.named.content_encoding);
} else if (b->idx.named.grpc_encoding != NULL) {
GPR_TIMER_BEGIN("incoming_compression_algorithm", 0);
set_incoming_compression_algorithm(
call, decode_compression(b->idx.named.grpc_encoding->md));
GPR_TIMER_END("incoming_compression_algorithm", 0);
}
if (b->idx.named.grpc_encoding != NULL) {
GPR_TIMER_BEGIN("incoming_message_compression_algorithm", 0);
set_incoming_message_compression_algorithm(
call, decode_message_compression(b->idx.named.grpc_encoding->md));
GPR_TIMER_END("incoming_message_compression_algorithm", 0);
grpc_metadata_batch_remove(exec_ctx, b, b->idx.named.grpc_encoding);
}
uint32_t message_encodings_accepted_by_peer = 1u;
uint32_t stream_encodings_accepted_by_peer = 1u;
if (b->idx.named.grpc_accept_encoding != NULL) {
GPR_TIMER_BEGIN("encodings_accepted_by_peer", 0);
set_encodings_accepted_by_peer(exec_ctx, call,
b->idx.named.grpc_accept_encoding->md);
b->idx.named.grpc_accept_encoding->md,
&message_encodings_accepted_by_peer, false);
grpc_metadata_batch_remove(exec_ctx, b, b->idx.named.grpc_accept_encoding);
GPR_TIMER_END("encodings_accepted_by_peer", 0);
}
if (b->idx.named.accept_encoding != NULL) {
GPR_TIMER_BEGIN("stream_encodings_accepted_by_peer", 0);
set_stream_encodings_accepted_by_peer(exec_ctx, call,
b->idx.named.accept_encoding->md);
set_encodings_accepted_by_peer(exec_ctx, call,
b->idx.named.accept_encoding->md,
&stream_encodings_accepted_by_peer, true);
grpc_metadata_batch_remove(exec_ctx, b, b->idx.named.accept_encoding);
GPR_TIMER_END("stream_encodings_accepted_by_peer", 0);
}
call->encodings_accepted_by_peer =
grpc_compression_bitset_from_message_stream_compression_bitset(
message_encodings_accepted_by_peer,
stream_encodings_accepted_by_peer);
publish_app_metadata(call, b, false);
}
@ -1444,9 +1399,12 @@ static void process_data_after_md(grpc_exec_ctx *exec_ctx,
} else {
call->test_only_last_message_flags = call->receiving_stream->flags;
if ((call->receiving_stream->flags & GRPC_WRITE_INTERNAL_COMPRESS) &&
(call->incoming_compression_algorithm > GRPC_COMPRESS_NONE)) {
(call->incoming_message_compression_algorithm > GRPC_MESSAGE_COMPRESS_NONE)) {
grpc_compression_algorithm algo;
GPR_ASSERT(grpc_compression_algorithm_from_message_stream_compression_algorithm(
&algo, call->incoming_message_compression_algorithm, 0));
*call->receiving_buffer = grpc_raw_compressed_byte_buffer_create(
NULL, 0, call->incoming_compression_algorithm);
NULL, 0, algo);
} else {
*call->receiving_buffer = grpc_raw_byte_buffer_create(NULL, 0);
}
@ -1492,88 +1450,65 @@ static void receiving_stream_ready_in_call_combiner(grpc_exec_ctx *exec_ctx,
static void validate_filtered_metadata(grpc_exec_ctx *exec_ctx,
batch_control *bctl) {
grpc_compression_algorithm compression_algorithm;
grpc_call *call = bctl->call;
/* validate compression algorithms */
if (call->incoming_stream_compression_algorithm !=
GRPC_STREAM_COMPRESS_NONE) {
const grpc_stream_compression_algorithm algo =
call->incoming_stream_compression_algorithm;
GRPC_STREAM_COMPRESS_NONE &&
call->incoming_message_compression_algorithm != GRPC_MESSAGE_COMPRESS_NONE) {
char *error_msg = NULL;
const grpc_compression_options compression_options =
grpc_channel_compression_options(call->channel);
if (algo >= GRPC_STREAM_COMPRESS_ALGORITHMS_COUNT) {
gpr_asprintf(&error_msg,
"Invalid stream compression algorithm value '%d'.", algo);
"Incoming stream has both stream compression (%d) and message "
"compression (%d).",
call->incoming_stream_compression_algorithm,
call->incoming_message_compression_algorithm);
gpr_log(GPR_ERROR, "%s", error_msg);
cancel_with_status(exec_ctx, call, STATUS_FROM_SURFACE,
GRPC_STATUS_UNIMPLEMENTED, error_msg);
} else if (grpc_compression_options_is_stream_compression_algorithm_enabled(
&compression_options, algo) == 0) {
/* check if algorithm is supported by current channel config */
char *algo_name = NULL;
grpc_stream_compression_algorithm_name(algo, &algo_name);
gpr_asprintf(&error_msg, "Stream compression algorithm '%s' is disabled.",
algo_name);
gpr_log(GPR_ERROR, "%s", error_msg);
GRPC_STATUS_INTERNAL, error_msg);
gpr_free(error_msg);
} else if (
grpc_compression_algorithm_from_message_stream_compression_algorithm(
&compression_algorithm, call->incoming_message_compression_algorithm,
call->incoming_stream_compression_algorithm) == 0) {
char *error_msg = NULL;
gpr_asprintf(&error_msg,
"Error in incoming message compression (%d) or stream "
"compression (%d).",
call->incoming_stream_compression_algorithm,
call->incoming_message_compression_algorithm);
cancel_with_status(exec_ctx, call, STATUS_FROM_SURFACE,
GRPC_STATUS_UNIMPLEMENTED, error_msg);
}
GRPC_STATUS_INTERNAL, error_msg);
gpr_free(error_msg);
GPR_ASSERT(call->stream_encodings_accepted_by_peer != 0);
if (!GPR_BITGET(call->stream_encodings_accepted_by_peer,
call->incoming_stream_compression_algorithm)) {
if (GRPC_TRACER_ON(grpc_compression_trace)) {
char *algo_name = NULL;
grpc_stream_compression_algorithm_name(
call->incoming_stream_compression_algorithm, &algo_name);
gpr_log(
GPR_ERROR,
"Stream compression algorithm (content-encoding = '%s') not "
"present in the bitset of accepted encodings (accept-encodings: "
"'0x%x')",
algo_name, call->stream_encodings_accepted_by_peer);
}
}
} else if (call->incoming_compression_algorithm != GRPC_COMPRESS_NONE) {
const grpc_compression_algorithm algo =
call->incoming_compression_algorithm;
} else {
char *error_msg = NULL;
const grpc_compression_options compression_options =
grpc_channel_compression_options(call->channel);
/* check if algorithm is known */
if (algo >= GRPC_COMPRESS_ALGORITHMS_COUNT) {
if (compression_algorithm >= GRPC_COMPRESS_ALGORITHMS_COUNT) {
gpr_asprintf(&error_msg, "Invalid compression algorithm value '%d'.",
algo);
compression_algorithm);
gpr_log(GPR_ERROR, "%s", error_msg);
cancel_with_status(exec_ctx, call, STATUS_FROM_SURFACE,
GRPC_STATUS_UNIMPLEMENTED, error_msg);
} else if (grpc_compression_options_is_algorithm_enabled(
&compression_options, algo) == 0) {
&compression_options, compression_algorithm) == 0) {
/* check if algorithm is supported by current channel config */
char *algo_name = NULL;
grpc_compression_algorithm_name(algo, &algo_name);
grpc_compression_algorithm_name(compression_algorithm, &algo_name);
gpr_asprintf(&error_msg, "Compression algorithm '%s' is disabled.",
algo_name);
gpr_log(GPR_ERROR, "%s", error_msg);
cancel_with_status(exec_ctx, call, STATUS_FROM_SURFACE,
GRPC_STATUS_UNIMPLEMENTED, error_msg);
} else {
call->incoming_compression_algorithm = algo;
}
gpr_free(error_msg);
GPR_ASSERT(call->encodings_accepted_by_peer != 0);
if (!GPR_BITGET(call->encodings_accepted_by_peer,
call->incoming_compression_algorithm)) {
if (!GPR_BITGET(call->encodings_accepted_by_peer, compression_algorithm)) {
if (GRPC_TRACER_ON(grpc_compression_trace)) {
char *algo_name = NULL;
grpc_compression_algorithm_name(call->incoming_compression_algorithm,
&algo_name);
grpc_compression_algorithm_name(compression_algorithm, &algo_name);
gpr_log(GPR_ERROR,
"Compression algorithm (grpc-encoding = '%s') not present in "
"the bitset of accepted encodings (grpc-accept-encodings: "
"'0x%x')",
"Compression algorithm ('%s') not present in the bitset of "
"accepted encodings ('0x%x')",
algo_name, call->encodings_accepted_by_peer);
}
}
@ -1724,57 +1659,29 @@ static grpc_call_error call_start_batch(grpc_exec_ctx *exec_ctx,
size_t additional_metadata_count = 0;
grpc_compression_level effective_compression_level =
GRPC_COMPRESS_LEVEL_NONE;
grpc_stream_compression_level effective_stream_compression_level =
GRPC_STREAM_COMPRESS_LEVEL_NONE;
bool level_set = false;
bool stream_compression = false;
if (op->data.send_initial_metadata.maybe_stream_compression_level
.is_set) {
effective_stream_compression_level =
op->data.send_initial_metadata.maybe_stream_compression_level
.level;
level_set = true;
stream_compression = true;
} else if (op->data.send_initial_metadata.maybe_compression_level
.is_set) {
if (op->data.send_initial_metadata.maybe_compression_level.is_set) {
effective_compression_level =
op->data.send_initial_metadata.maybe_compression_level.level;
level_set = true;
} else {
const grpc_compression_options copts =
grpc_channel_compression_options(call->channel);
if (copts.default_stream_compression_level.is_set) {
level_set = true;
effective_stream_compression_level =
copts.default_stream_compression_level.level;
stream_compression = true;
} else if (copts.default_level.is_set) {
if (copts.default_level.is_set) {
level_set = true;
effective_compression_level = copts.default_level.level;
}
}
if (level_set && !call->is_client) {
if (stream_compression) {
const grpc_stream_compression_algorithm calgo =
stream_compression_algorithm_for_level_locked(
call, effective_stream_compression_level);
call->compression_md.key =
GRPC_MDSTR_GRPC_INTERNAL_STREAM_ENCODING_REQUEST;
call->compression_md.value =
grpc_stream_compression_algorithm_slice(calgo);
} else {
const grpc_compression_algorithm calgo =
compression_algorithm_for_level_locked(
call, effective_compression_level);
/* the following will be picked up by the compress filter and used
* as the call's compression algorithm. */
call->compression_md.key =
GRPC_MDSTR_GRPC_INTERNAL_ENCODING_REQUEST;
call->compression_md.value =
grpc_compression_algorithm_slice(calgo);
call->compression_md.key = GRPC_MDSTR_GRPC_INTERNAL_ENCODING_REQUEST;
call->compression_md.value = grpc_compression_algorithm_slice(calgo);
additional_metadata_count++;
}
}
if (op->data.send_initial_metadata.count + additional_metadata_count >
INT_MAX) {

14
src/core/lib/surface/call_test_only.h
Unescape View File

@ -25,7 +25,7 @@
extern "C" {
#endif
/** Return the compression algorithm from \a call.
/** Return the message compression algorithm from \a call.
*
* \warning This function should \b only be used in test code. */
grpc_compression_algorithm grpc_call_test_only_get_compression_algorithm(
@ -42,18 +42,6 @@ uint32_t grpc_call_test_only_get_message_flags(grpc_call *call);
* To be indexed by grpc_compression_algorithm enum values. */
uint32_t grpc_call_test_only_get_encodings_accepted_by_peer(grpc_call *call);
/** Returns a bitset for the stream encodings (stream compression algorithms)
* supported by \a call's peer.
*
* To be indexed by grpc_stream_compression_algorithm enum values. */
uint32_t grpc_call_test_only_get_stream_encodings_accepted_by_peer(
grpc_call *call);
/** Returns the incoming stream compression algorithm (content-encoding header)
* received by a call. */
grpc_stream_compression_algorithm
grpc_call_test_only_get_incoming_stream_encodings(grpc_call *call);
#ifdef __cplusplus
}
#endif

29
src/core/lib/surface/channel.c
Unescape View File

@ -141,16 +141,6 @@ grpc_channel *grpc_channel_create_with_builder(
(grpc_integer_options){GRPC_COMPRESS_LEVEL_NONE,
GRPC_COMPRESS_LEVEL_NONE,
GRPC_COMPRESS_LEVEL_COUNT - 1});
} else if (0 == strcmp(args->args[i].key,
GRPC_STREAM_COMPRESSION_CHANNEL_DEFAULT_LEVEL)) {
channel->compression_options.default_stream_compression_level.is_set =
true;
channel->compression_options.default_stream_compression_level.level =
(grpc_stream_compression_level)grpc_channel_arg_get_integer(
&args->args[i],
(grpc_integer_options){GRPC_STREAM_COMPRESS_LEVEL_NONE,
GRPC_STREAM_COMPRESS_LEVEL_NONE,
GRPC_STREAM_COMPRESS_LEVEL_COUNT - 1});
} else if (0 == strcmp(args->args[i].key,
GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM)) {
channel->compression_options.default_algorithm.is_set = true;
@ -159,31 +149,12 @@ grpc_channel *grpc_channel_create_with_builder(
&args->args[i],
(grpc_integer_options){GRPC_COMPRESS_NONE, GRPC_COMPRESS_NONE,
GRPC_COMPRESS_ALGORITHMS_COUNT - 1});
} else if (0 == strcmp(args->args[i].key,
GRPC_STREAM_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM)) {
channel->compression_options.default_stream_compression_algorithm.is_set =
true;
channel->compression_options.default_stream_compression_algorithm
.algorithm =
(grpc_stream_compression_algorithm)grpc_channel_arg_get_integer(
&args->args[i],
(grpc_integer_options){
GRPC_STREAM_COMPRESS_NONE, GRPC_STREAM_COMPRESS_NONE,
GRPC_STREAM_COMPRESS_ALGORITHMS_COUNT - 1});
} else if (0 ==
strcmp(args->args[i].key,
GRPC_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET)) {
channel->compression_options.enabled_algorithms_bitset =
(uint32_t)args->args[i].value.integer |
0x1; /* always support no compression */
} else if (0 ==
strcmp(
args->args[i].key,
GRPC_STREAM_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET)) {
channel->compression_options
.enabled_stream_compression_algorithms_bitset =
(uint32_t)args->args[i].value.integer |
0x1; /* always support no compression */
}
}

587
src/core/lib/transport/static_metadata.c
Unescape View File

@ -57,51 +57,53 @@ static uint8_t g_bytes[] = {
112, 111, 110, 115, 101, 95, 109, 101, 115, 115, 97, 103, 101, 95, 98,
121, 116, 101, 115, 47, 103, 114, 112, 99, 46, 108, 98, 46, 118, 49,
46, 76, 111, 97, 100, 66, 97, 108, 97, 110, 99, 101, 114, 47, 66,
97, 108, 97, 110, 99, 101, 76, 111, 97, 100, 48, 49, 50, 105, 100,
101, 110, 116, 105, 116, 121, 103, 122, 105, 112, 100, 101, 102, 108, 97,
116, 101, 116, 114, 97, 105, 108, 101, 114, 115, 97, 112, 112, 108, 105,
99, 97, 116, 105, 111, 110, 47, 103, 114, 112, 99, 80, 79, 83, 84,
50, 48, 48, 52, 48, 52, 104, 116, 116, 112, 104, 116, 116, 112, 115,
103, 114, 112, 99, 71, 69, 84, 80, 85, 84, 47, 47, 105, 110, 100,
101, 120, 46, 104, 116, 109, 108, 50, 48, 52, 50, 48, 54, 51, 48,
52, 52, 48, 48, 53, 48, 48, 97, 99, 99, 101, 112, 116, 45, 99,
104, 97, 114, 115, 101, 116, 103, 122, 105, 112, 44, 32, 100, 101, 102,
108, 97, 116, 101, 97, 99, 99, 101, 112, 116, 45, 108, 97, 110, 103,
117, 97, 103, 101, 97, 99, 99, 101, 112, 116, 45, 114, 97, 110, 103,
101, 115, 97, 99, 99, 101, 112, 116, 97, 99, 99, 101, 115, 115, 45,
99, 111, 110, 116, 114, 111, 108, 45, 97, 108, 108, 111, 119, 45, 111,
114, 105, 103, 105, 110, 97, 103, 101, 97, 108, 108, 111, 119, 97, 117,
116, 104, 111, 114, 105, 122, 97, 116, 105, 111, 110, 99, 97, 99, 104,
101, 45, 99, 111, 110, 116, 114, 111, 108, 99, 111, 110, 116, 101, 110,
116, 45, 100, 105, 115, 112, 111, 115, 105, 116, 105, 111, 110, 99, 111,
110, 116, 101, 110, 116, 45, 108, 97, 110, 103, 117, 97, 103, 101, 99,
111, 110, 116, 101, 110, 116, 45, 108, 101, 110, 103, 116, 104, 99, 111,
110, 116, 101, 110, 116, 45, 108, 111, 99, 97, 116, 105, 111, 110, 99,
111, 110, 116, 101, 110, 116, 45, 114, 97, 110, 103, 101, 99, 111, 111,
107, 105, 101, 100, 97, 116, 101, 101, 116, 97, 103, 101, 120, 112, 101,
99, 116, 101, 120, 112, 105, 114, 101, 115, 102, 114, 111, 109, 105, 102,
45, 109, 97, 116, 99, 104, 105, 102, 45, 109, 111, 100, 105, 102, 105,
101, 100, 45, 115, 105, 110, 99, 101, 105, 102, 45, 110, 111, 110, 101,
45, 109, 97, 116, 99, 104, 105, 102, 45, 114, 97, 110, 103, 101, 105,
102, 45, 117, 110, 109, 111, 100, 105, 102, 105, 101, 100, 45, 115, 105,
110, 99, 101, 108, 97, 115, 116, 45, 109, 111, 100, 105, 102, 105, 101,
100, 108, 98, 45, 99, 111, 115, 116, 45, 98, 105, 110, 108, 105, 110,
107, 108, 111, 99, 97, 116, 105, 111, 110, 109, 97, 120, 45, 102, 111,
114, 119, 97, 114, 100, 115, 112, 114, 111, 120, 121, 45, 97, 117, 116,
104, 101, 110, 116, 105, 99, 97, 116, 101, 112, 114, 111, 120, 121, 45,
97, 117, 116, 104, 111, 114, 105, 122, 97, 116, 105, 111, 110, 114, 97,
110, 103, 101, 114, 101, 102, 101, 114, 101, 114, 114, 101, 102, 114, 101,
115, 104, 114, 101, 116, 114, 121, 45, 97, 102, 116, 101, 114, 115, 101,
114, 118, 101, 114, 115, 101, 116, 45, 99, 111, 111, 107, 105, 101, 115,
116, 114, 105, 99, 116, 45, 116, 114, 97, 110, 115, 112, 111, 114, 116,
45, 115, 101, 99, 117, 114, 105, 116, 121, 116, 114, 97, 110, 115, 102,
101, 114, 45, 101, 110, 99, 111, 100, 105, 110, 103, 118, 97, 114, 121,
118, 105, 97, 119, 119, 119, 45, 97, 117, 116, 104, 101, 110, 116, 105,
99, 97, 116, 101, 105, 100, 101, 110, 116, 105, 116, 121, 44, 100, 101,
102, 108, 97, 116, 101, 105, 100, 101, 110, 116, 105, 116, 121, 44, 103,
122, 105, 112, 100, 101, 102, 108, 97, 116, 101, 44, 103, 122, 105, 112,
105, 100, 101, 110, 116, 105, 116, 121, 44, 100, 101, 102, 108, 97, 116,
101, 44, 103, 122, 105, 112};
97, 108, 97, 110, 99, 101, 76, 111, 97, 100, 109, 101, 115, 115, 97,
103, 101, 47, 100, 101, 102, 108, 97, 116, 101, 109, 101, 115, 115, 97,
103, 101, 47, 103, 122, 105, 112, 115, 116, 114, 101, 97, 109, 47, 103,
122, 105, 112, 48, 49, 50, 105, 100, 101, 110, 116, 105, 116, 121, 103,
122, 105, 112, 100, 101, 102, 108, 97, 116, 101, 116, 114, 97, 105, 108,
101, 114, 115, 97, 112, 112, 108, 105, 99, 97, 116, 105, 111, 110, 47,
103, 114, 112, 99, 80, 79, 83, 84, 50, 48, 48, 52, 48, 52, 104,
116, 116, 112, 104, 116, 116, 112, 115, 103, 114, 112, 99, 71, 69, 84,
80, 85, 84, 47, 47, 105, 110, 100, 101, 120, 46, 104, 116, 109, 108,
50, 48, 52, 50, 48, 54, 51, 48, 52, 52, 48, 48, 53, 48, 48,
97, 99, 99, 101, 112, 116, 45, 99, 104, 97, 114, 115, 101, 116, 103,
122, 105, 112, 44, 32, 100, 101, 102, 108, 97, 116, 101, 97, 99, 99,
101, 112, 116, 45, 108, 97, 110, 103, 117, 97, 103, 101, 97, 99, 99,
101, 112, 116, 45, 114, 97, 110, 103, 101, 115, 97, 99, 99, 101, 112,
116, 97, 99, 99, 101, 115, 115, 45, 99, 111, 110, 116, 114, 111, 108,
45, 97, 108, 108, 111, 119, 45, 111, 114, 105, 103, 105, 110, 97, 103,
101, 97, 108, 108, 111, 119, 97, 117, 116, 104, 111, 114, 105, 122, 97,
116, 105, 111, 110, 99, 97, 99, 104, 101, 45, 99, 111, 110, 116, 114,
111, 108, 99, 111, 110, 116, 101, 110, 116, 45, 100, 105, 115, 112, 111,
115, 105, 116, 105, 111, 110, 99, 111, 110, 116, 101, 110, 116, 45, 108,
97, 110, 103, 117, 97, 103, 101, 99, 111, 110, 116, 101, 110, 116, 45,
108, 101, 110, 103, 116, 104, 99, 111, 110, 116, 101, 110, 116, 45, 108,
111, 99, 97, 116, 105, 111, 110, 99, 111, 110, 116, 101, 110, 116, 45,
114, 97, 110, 103, 101, 99, 111, 111, 107, 105, 101, 100, 97, 116, 101,
101, 116, 97, 103, 101, 120, 112, 101, 99, 116, 101, 120, 112, 105, 114,
101, 115, 102, 114, 111, 109, 105, 102, 45, 109, 97, 116, 99, 104, 105,
102, 45, 109, 111, 100, 105, 102, 105, 101, 100, 45, 115, 105, 110, 99,
101, 105, 102, 45, 110, 111, 110, 101, 45, 109, 97, 116, 99, 104, 105,
102, 45, 114, 97, 110, 103, 101, 105, 102, 45, 117, 110, 109, 111, 100,
105, 102, 105, 101, 100, 45, 115, 105, 110, 99, 101, 108, 97, 115, 116,
45, 109, 111, 100, 105, 102, 105, 101, 100, 108, 98, 45, 99, 111, 115,
116, 45, 98, 105, 110, 108, 105, 110, 107, 108, 111, 99, 97, 116, 105,
111, 110, 109, 97, 120, 45, 102, 111, 114, 119, 97, 114, 100, 115, 112,
114, 111, 120, 121, 45, 97, 117, 116, 104, 101, 110, 116, 105, 99, 97,
116, 101, 112, 114, 111, 120, 121, 45, 97, 117, 116, 104, 111, 114, 105,
122, 97, 116, 105, 111, 110, 114, 97, 110, 103, 101, 114, 101, 102, 101,
114, 101, 114, 114, 101, 102, 114, 101, 115, 104, 114, 101, 116, 114, 121,
45, 97, 102, 116, 101, 114, 115, 101, 114, 118, 101, 114, 115, 101, 116,
45, 99, 111, 111, 107, 105, 101, 115, 116, 114, 105, 99, 116, 45, 116,
114, 97, 110, 115, 112, 111, 114, 116, 45, 115, 101, 99, 117, 114, 105,
116, 121, 116, 114, 97, 110, 115, 102, 101, 114, 45, 101, 110, 99, 111,
100, 105, 110, 103, 118, 97, 114, 121, 118, 105, 97, 119, 119, 119, 45,
97, 117, 116, 104, 101, 110, 116, 105, 99, 97, 116, 101, 105, 100, 101,
110, 116, 105, 116, 121, 44, 100, 101, 102, 108, 97, 116, 101, 105, 100,
101, 110, 116, 105, 116, 121, 44, 103, 122, 105, 112, 100, 101, 102, 108,
97, 116, 101, 44, 103, 122, 105, 112, 105, 100, 101, 110, 116, 105, 116,
121, 44, 100, 101, 102, 108, 97, 116, 101, 44, 103, 122, 105, 112};
static void static_ref(void *unused) {}
static void static_unref(grpc_exec_ctx *exec_ctx, void *unused) {}
@ -213,6 +215,9 @@ grpc_slice_refcount grpc_static_metadata_refcounts[GRPC_STATIC_MDSTR_COUNT] = {
{&grpc_static_metadata_vtable, &static_sub_refcnt},
{&grpc_static_metadata_vtable, &static_sub_refcnt},
{&grpc_static_metadata_vtable, &static_sub_refcnt},
{&grpc_static_metadata_vtable, &static_sub_refcnt},
{&grpc_static_metadata_vtable, &static_sub_refcnt},
{&grpc_static_metadata_vtable, &static_sub_refcnt},
};
const grpc_slice grpc_static_slice_table[GRPC_STATIC_MDSTR_COUNT] = {
@ -275,147 +280,153 @@ const grpc_slice grpc_static_slice_table[GRPC_STATIC_MDSTR_COUNT] = {
{.refcount = &grpc_static_metadata_refcounts[28],
.data.refcounted = {g_bytes + 394, 36}},
{.refcount = &grpc_static_metadata_refcounts[29],
.data.refcounted = {g_bytes + 430, 1}},
.data.refcounted = {g_bytes + 430, 15}},
{.refcount = &grpc_static_metadata_refcounts[30],
.data.refcounted = {g_bytes + 431, 1}},
.data.refcounted = {g_bytes + 445, 12}},
{.refcount = &grpc_static_metadata_refcounts[31],
.data.refcounted = {g_bytes + 432, 1}},
.data.refcounted = {g_bytes + 457, 11}},
{.refcount = &grpc_static_metadata_refcounts[32],
.data.refcounted = {g_bytes + 433, 8}},
.data.refcounted = {g_bytes + 468, 1}},
{.refcount = &grpc_static_metadata_refcounts[33],
.data.refcounted = {g_bytes + 441, 4}},
.data.refcounted = {g_bytes + 469, 1}},
{.refcount = &grpc_static_metadata_refcounts[34],
.data.refcounted = {g_bytes + 445, 7}},
.data.refcounted = {g_bytes + 470, 1}},
{.refcount = &grpc_static_metadata_refcounts[35],
.data.refcounted = {g_bytes + 452, 8}},
.data.refcounted = {g_bytes + 471, 8}},
{.refcount = &grpc_static_metadata_refcounts[36],
.data.refcounted = {g_bytes + 460, 16}},
.data.refcounted = {g_bytes + 479, 4}},
{.refcount = &grpc_static_metadata_refcounts[37],
.data.refcounted = {g_bytes + 476, 4}},
.data.refcounted = {g_bytes + 483, 7}},
{.refcount = &grpc_static_metadata_refcounts[38],
.data.refcounted = {g_bytes + 480, 3}},
.data.refcounted = {g_bytes + 490, 8}},
{.refcount = &grpc_static_metadata_refcounts[39],
.data.refcounted = {g_bytes + 483, 3}},
.data.refcounted = {g_bytes + 498, 16}},
{.refcount = &grpc_static_metadata_refcounts[40],
.data.refcounted = {g_bytes + 486, 4}},
.data.refcounted = {g_bytes + 514, 4}},
{.refcount = &grpc_static_metadata_refcounts[41],
.data.refcounted = {g_bytes + 490, 5}},
.data.refcounted = {g_bytes + 518, 3}},
{.refcount = &grpc_static_metadata_refcounts[42],
.data.refcounted = {g_bytes + 495, 4}},
.data.refcounted = {g_bytes + 521, 3}},
{.refcount = &grpc_static_metadata_refcounts[43],
.data.refcounted = {g_bytes + 499, 3}},
.data.refcounted = {g_bytes + 524, 4}},
{.refcount = &grpc_static_metadata_refcounts[44],
.data.refcounted = {g_bytes + 502, 3}},
.data.refcounted = {g_bytes + 528, 5}},
{.refcount = &grpc_static_metadata_refcounts[45],
.data.refcounted = {g_bytes + 505, 1}},
.data.refcounted = {g_bytes + 533, 4}},
{.refcount = &grpc_static_metadata_refcounts[46],
.data.refcounted = {g_bytes + 506, 11}},
.data.refcounted = {g_bytes + 537, 3}},
{.refcount = &grpc_static_metadata_refcounts[47],
.data.refcounted = {g_bytes + 517, 3}},
.data.refcounted = {g_bytes + 540, 3}},
{.refcount = &grpc_static_metadata_refcounts[48],
.data.refcounted = {g_bytes + 520, 3}},
.data.refcounted = {g_bytes + 543, 1}},
{.refcount = &grpc_static_metadata_refcounts[49],
.data.refcounted = {g_bytes + 523, 3}},
.data.refcounted = {g_bytes + 544, 11}},
{.refcount = &grpc_static_metadata_refcounts[50],
.data.refcounted = {g_bytes + 526, 3}},
.data.refcounted = {g_bytes + 555, 3}},
{.refcount = &grpc_static_metadata_refcounts[51],
.data.refcounted = {g_bytes + 529, 3}},
.data.refcounted = {g_bytes + 558, 3}},
{.refcount = &grpc_static_metadata_refcounts[52],
.data.refcounted = {g_bytes + 532, 14}},
.data.refcounted = {g_bytes + 561, 3}},
{.refcount = &grpc_static_metadata_refcounts[53],
.data.refcounted = {g_bytes + 546, 13}},
.data.refcounted = {g_bytes + 564, 3}},
{.refcount = &grpc_static_metadata_refcounts[54],
.data.refcounted = {g_bytes + 559, 15}},
.data.refcounted = {g_bytes + 567, 3}},
{.refcount = &grpc_static_metadata_refcounts[55],
.data.refcounted = {g_bytes + 574, 13}},
.data.refcounted = {g_bytes + 570, 14}},
{.refcount = &grpc_static_metadata_refcounts[56],
.data.refcounted = {g_bytes + 587, 6}},
.data.refcounted = {g_bytes + 584, 13}},
{.refcount = &grpc_static_metadata_refcounts[57],
.data.refcounted = {g_bytes + 593, 27}},
.data.refcounted = {g_bytes + 597, 15}},
{.refcount = &grpc_static_metadata_refcounts[58],
.data.refcounted = {g_bytes + 620, 3}},
.data.refcounted = {g_bytes + 612, 13}},
{.refcount = &grpc_static_metadata_refcounts[59],
.data.refcounted = {g_bytes + 623, 5}},
.data.refcounted = {g_bytes + 625, 6}},
{.refcount = &grpc_static_metadata_refcounts[60],
.data.refcounted = {g_bytes + 628, 13}},
.data.refcounted = {g_bytes + 631, 27}},
{.refcount = &grpc_static_metadata_refcounts[61],
.data.refcounted = {g_bytes + 641, 13}},
.data.refcounted = {g_bytes + 658, 3}},
{.refcount = &grpc_static_metadata_refcounts[62],
.data.refcounted = {g_bytes + 654, 19}},
.data.refcounted = {g_bytes + 661, 5}},
{.refcount = &grpc_static_metadata_refcounts[63],
.data.refcounted = {g_bytes + 673, 16}},
.data.refcounted = {g_bytes + 666, 13}},
{.refcount = &grpc_static_metadata_refcounts[64],
.data.refcounted = {g_bytes + 689, 14}},
.data.refcounted = {g_bytes + 679, 13}},
{.refcount = &grpc_static_metadata_refcounts[65],
.data.refcounted = {g_bytes + 703, 16}},
.data.refcounted = {g_bytes + 692, 19}},
{.refcount = &grpc_static_metadata_refcounts[66],
.data.refcounted = {g_bytes + 719, 13}},
.data.refcounted = {g_bytes + 711, 16}},
{.refcount = &grpc_static_metadata_refcounts[67],
.data.refcounted = {g_bytes + 732, 6}},
.data.refcounted = {g_bytes + 727, 14}},
{.refcount = &grpc_static_metadata_refcounts[68],
.data.refcounted = {g_bytes + 738, 4}},
.data.refcounted = {g_bytes + 741, 16}},
{.refcount = &grpc_static_metadata_refcounts[69],
.data.refcounted = {g_bytes + 742, 4}},
.data.refcounted = {g_bytes + 757, 13}},
{.refcount = &grpc_static_metadata_refcounts[70],
.data.refcounted = {g_bytes + 746, 6}},
.data.refcounted = {g_bytes + 770, 6}},
{.refcount = &grpc_static_metadata_refcounts[71],
.data.refcounted = {g_bytes + 752, 7}},
.data.refcounted = {g_bytes + 776, 4}},
{.refcount = &grpc_static_metadata_refcounts[72],
.data.refcounted = {g_bytes + 759, 4}},
.data.refcounted = {g_bytes + 780, 4}},
{.refcount = &grpc_static_metadata_refcounts[73],
.data.refcounted = {g_bytes + 763, 8}},
.data.refcounted = {g_bytes + 784, 6}},
{.refcount = &grpc_static_metadata_refcounts[74],
.data.refcounted = {g_bytes + 771, 17}},
.data.refcounted = {g_bytes + 790, 7}},
{.refcount = &grpc_static_metadata_refcounts[75],
.data.refcounted = {g_bytes + 788, 13}},
.data.refcounted = {g_bytes + 797, 4}},
{.refcount = &grpc_static_metadata_refcounts[76],
.data.refcounted = {g_bytes + 801, 8}},
{.refcount = &grpc_static_metadata_refcounts[77],
.data.refcounted = {g_bytes + 809, 19}},
.data.refcounted = {g_bytes + 809, 17}},
{.refcount = &grpc_static_metadata_refcounts[78],
.data.refcounted = {g_bytes + 828, 13}},
.data.refcounted = {g_bytes + 826, 13}},
{.refcount = &grpc_static_metadata_refcounts[79],
.data.refcounted = {g_bytes + 841, 11}},
.data.refcounted = {g_bytes + 839, 8}},
{.refcount = &grpc_static_metadata_refcounts[80],
.data.refcounted = {g_bytes + 852, 4}},
.data.refcounted = {g_bytes + 847, 19}},
{.refcount = &grpc_static_metadata_refcounts[81],
.data.refcounted = {g_bytes + 856, 8}},
.data.refcounted = {g_bytes + 866, 13}},
{.refcount = &grpc_static_metadata_refcounts[82],
.data.refcounted = {g_bytes + 864, 12}},
.data.refcounted = {g_bytes + 879, 11}},
{.refcount = &grpc_static_metadata_refcounts[83],
.data.refcounted = {g_bytes + 876, 18}},
.data.refcounted = {g_bytes + 890, 4}},
{.refcount = &grpc_static_metadata_refcounts[84],
.data.refcounted = {g_bytes + 894, 19}},
.data.refcounted = {g_bytes + 894, 8}},
{.refcount = &grpc_static_metadata_refcounts[85],
.data.refcounted = {g_bytes + 913, 5}},
.data.refcounted = {g_bytes + 902, 12}},
{.refcount = &grpc_static_metadata_refcounts[86],
.data.refcounted = {g_bytes + 918, 7}},
.data.refcounted = {g_bytes + 914, 18}},
{.refcount = &grpc_static_metadata_refcounts[87],
.data.refcounted = {g_bytes + 925, 7}},
.data.refcounted = {g_bytes + 932, 19}},
{.refcount = &grpc_static_metadata_refcounts[88],
.data.refcounted = {g_bytes + 932, 11}},
.data.refcounted = {g_bytes + 951, 5}},
{.refcount = &grpc_static_metadata_refcounts[89],
.data.refcounted = {g_bytes + 943, 6}},
.data.refcounted = {g_bytes + 956, 7}},
{.refcount = &grpc_static_metadata_refcounts[90],
.data.refcounted = {g_bytes + 949, 10}},
.data.refcounted = {g_bytes + 963, 7}},
{.refcount = &grpc_static_metadata_refcounts[91],
.data.refcounted = {g_bytes + 959, 25}},
.data.refcounted = {g_bytes + 970, 11}},
{.refcount = &grpc_static_metadata_refcounts[92],
.data.refcounted = {g_bytes + 984, 17}},
.data.refcounted = {g_bytes + 981, 6}},
{.refcount = &grpc_static_metadata_refcounts[93],
.data.refcounted = {g_bytes + 1001, 4}},
.data.refcounted = {g_bytes + 987, 10}},
{.refcount = &grpc_static_metadata_refcounts[94],
.data.refcounted = {g_bytes + 1005, 3}},
.data.refcounted = {g_bytes + 997, 25}},
{.refcount = &grpc_static_metadata_refcounts[95],
.data.refcounted = {g_bytes + 1008, 16}},
.data.refcounted = {g_bytes + 1022, 17}},
{.refcount = &grpc_static_metadata_refcounts[96],
.data.refcounted = {g_bytes + 1024, 16}},
.data.refcounted = {g_bytes + 1039, 4}},
{.refcount = &grpc_static_metadata_refcounts[97],
.data.refcounted = {g_bytes + 1040, 13}},
.data.refcounted = {g_bytes + 1043, 3}},
{.refcount = &grpc_static_metadata_refcounts[98],
.data.refcounted = {g_bytes + 1053, 12}},
.data.refcounted = {g_bytes + 1046, 16}},
{.refcount = &grpc_static_metadata_refcounts[99],
.data.refcounted = {g_bytes + 1065, 21}},
.data.refcounted = {g_bytes + 1062, 16}},
{.refcount = &grpc_static_metadata_refcounts[100],
.data.refcounted = {g_bytes + 1078, 13}},
{.refcount = &grpc_static_metadata_refcounts[101],
.data.refcounted = {g_bytes + 1091, 12}},
{.refcount = &grpc_static_metadata_refcounts[102],
.data.refcounted = {g_bytes + 1103, 21}},
};
uintptr_t grpc_static_mdelem_user_data[GRPC_STATIC_MDELEM_COUNT] = {
@ -425,16 +436,16 @@ uintptr_t grpc_static_mdelem_user_data[GRPC_STATIC_MDELEM_COUNT] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 4, 4, 6, 6, 8, 8, 2, 4, 4};
static const int8_t elems_r[] = {
11, 9, -3, 0, 10, 27, -74, 28, 0, 14, -7, 0, 0, 0, 18, 8, -2,
0, 0, 13, 12, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
11, 9, -3, 0, 10, 25, -77, 26, 0, 11, -7, 0, 0, 0, 21, 14, 1,
0, 0, 33, 12, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, -50, 0, -33, -55, -56, -57, -58, -57, 0, 40, 39, 38, 37, 36, 35, 34,
33, 32, 31, 30, 29, 28, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 22,
21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 12, 11, 0};
0, 0, 0, 0, -56, 0, -36, -61, -60, -39, -63, -64, 0, 36, 35, 34, 33,
34, 33, 32, 31, 31, 30, 29, 28, 27, 26, 26, 25, 25, 24, 23, 22, 21,
20, 19, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 12, 11, 0};
static uint32_t elems_phash(uint32_t i) {
i -= 45;
uint32_t x = i % 98;
uint32_t y = i / 98;
i -= 48;
uint32_t x = i % 101;
uint32_t y = i / 101;
uint32_t h = x;
if (y < GPR_ARRAY_SIZE(elems_r)) {
uint32_t delta = (uint32_t)elems_r[y];
@ -444,31 +455,31 @@ static uint32_t elems_phash(uint32_t i) {
}
static const uint16_t elem_keys[] = {
1032, 1033, 1034, 247, 248, 249, 250, 251, 1623, 143, 144, 45,
46, 440, 441, 442, 1523, 1632, 1633, 932, 933, 934, 729, 730,
1423, 1532, 1533, 535, 731, 1923, 2023, 2123, 5223, 5523, 5623, 5723,
5823, 1436, 1653, 5923, 6023, 6123, 6223, 6323, 6423, 6523, 6623, 6723,
6823, 6923, 7023, 7123, 7223, 5423, 7323, 7423, 7523, 7623, 7723, 7823,
7923, 8023, 8123, 8223, 1096, 1097, 1098, 1099, 8323, 8423, 8523, 8623,
8723, 8823, 8923, 9023, 9123, 9223, 9323, 323, 9423, 9523, 1697, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 137, 238, 239, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1065, 1066, 1067, 256, 257, 258, 259, 260, 1671, 149, 150, 48,
49, 455, 456, 457, 962, 963, 964, 1568, 1683, 1684, 753, 754,
1465, 553, 755, 2083, 2186, 5688, 5997, 1580, 1581, 6100, 6306, 6409,
6512, 6615, 6718, 6821, 1481, 1704, 6924, 7027, 7130, 7233, 1980, 7336,
7439, 7542, 7645, 7748, 7851, 5894, 7954, 8057, 6203, 8160, 8263, 8366,
8469, 8572, 8675, 8778, 1129, 1130, 1131, 1132, 8881, 8984, 9087, 9190,
9293, 9396, 9499, 9602, 9705, 9808, 9911, 332, 10014, 10117, 0, 0,
0, 1748, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 143, 247,
248, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0};
0, 0, 0, 0};
static const uint8_t elem_idxs[] = {
76, 79, 77, 19, 20, 21, 22, 23, 25, 15, 16, 17, 18, 11,
12, 13, 38, 83, 84, 3, 4, 5, 0, 1, 43, 36, 37, 6,
2, 72, 50, 57, 24, 28, 29, 30, 31, 7, 26, 32, 33, 34,
35, 39, 40, 41, 42, 44, 45, 46, 47, 48, 49, 27, 51, 52,
53, 54, 55, 56, 58, 59, 60, 61, 78, 80, 81, 82, 62, 63,
64, 65, 66, 67, 68, 69, 70, 71, 73, 14, 74, 75, 85, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 8, 9, 10};
12, 13, 3, 4, 5, 38, 83, 84, 0, 1, 43, 6, 2, 50,
57, 24, 28, 36, 37, 29, 31, 32, 33, 34, 35, 39, 7, 26,
40, 41, 42, 44, 72, 45, 46, 47, 48, 49, 51, 27, 52, 53,
30, 54, 55, 56, 58, 59, 60, 61, 78, 80, 81, 82, 62, 63,
64, 65, 66, 67, 68, 69, 70, 71, 73, 14, 74, 75, 255, 255,
255, 85, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 8, 9, 10};
grpc_mdelem grpc_static_mdelem_for_static_strings(int a, int b) {
if (a == -1 || b == -1) return GRPC_MDNULL;
uint32_t k = (uint32_t)(a * 100 + b);
uint32_t k = (uint32_t)(a * 103 + b);
uint32_t h = elems_phash(k);
return h < GPR_ARRAY_SIZE(elem_keys) && elem_keys[h] == k &&
elem_idxs[h] != 255
@ -480,102 +491,102 @@ grpc_mdelem grpc_static_mdelem_for_static_strings(int a, int b) {
grpc_mdelem_data grpc_static_mdelem_table[GRPC_STATIC_MDELEM_COUNT] = {
{{.refcount = &grpc_static_metadata_refcounts[7],
.data.refcounted = {g_bytes + 50, 11}},
{.refcount = &grpc_static_metadata_refcounts[29],
.data.refcounted = {g_bytes + 430, 1}}},
{.refcount = &grpc_static_metadata_refcounts[32],
.data.refcounted = {g_bytes + 468, 1}}},
{{.refcount = &grpc_static_metadata_refcounts[7],
.data.refcounted = {g_bytes + 50, 11}},
{.refcount = &grpc_static_metadata_refcounts[30],
.data.refcounted = {g_bytes + 431, 1}}},
{.refcount = &grpc_static_metadata_refcounts[33],
.data.refcounted = {g_bytes + 469, 1}}},
{{.refcount = &grpc_static_metadata_refcounts[7],
.data.refcounted = {g_bytes + 50, 11}},
{.refcount = &grpc_static_metadata_refcounts[31],
.data.refcounted = {g_bytes + 432, 1}}},
{.refcount = &grpc_static_metadata_refcounts[34],
.data.refcounted = {g_bytes + 470, 1}}},
{{.refcount = &grpc_static_metadata_refcounts[9],
.data.refcounted = {g_bytes + 77, 13}},
{.refcount = &grpc_static_metadata_refcounts[32],
.data.refcounted = {g_bytes + 433, 8}}},
{.refcount = &grpc_static_metadata_refcounts[35],
.data.refcounted = {g_bytes + 471, 8}}},
{{.refcount = &grpc_static_metadata_refcounts[9],
.data.refcounted = {g_bytes + 77, 13}},
{.refcount = &grpc_static_metadata_refcounts[33],
.data.refcounted = {g_bytes + 441, 4}}},
{.refcount = &grpc_static_metadata_refcounts[36],
.data.refcounted = {g_bytes + 479, 4}}},
{{.refcount = &grpc_static_metadata_refcounts[9],
.data.refcounted = {g_bytes + 77, 13}},
{.refcount = &grpc_static_metadata_refcounts[34],
.data.refcounted = {g_bytes + 445, 7}}},
{.refcount = &grpc_static_metadata_refcounts[37],
.data.refcounted = {g_bytes + 483, 7}}},
{{.refcount = &grpc_static_metadata_refcounts[5],
.data.refcounted = {g_bytes + 36, 2}},
{.refcount = &grpc_static_metadata_refcounts[35],
.data.refcounted = {g_bytes + 452, 8}}},
{.refcount = &grpc_static_metadata_refcounts[38],
.data.refcounted = {g_bytes + 490, 8}}},
{{.refcount = &grpc_static_metadata_refcounts[14],
.data.refcounted = {g_bytes + 158, 12}},
{.refcount = &grpc_static_metadata_refcounts[36],
.data.refcounted = {g_bytes + 460, 16}}},
{.refcount = &grpc_static_metadata_refcounts[39],
.data.refcounted = {g_bytes + 498, 16}}},
{{.refcount = &grpc_static_metadata_refcounts[1],
.data.refcounted = {g_bytes + 5, 7}},
{.refcount = &grpc_static_metadata_refcounts[37],
.data.refcounted = {g_bytes + 476, 4}}},
{.refcount = &grpc_static_metadata_refcounts[40],
.data.refcounted = {g_bytes + 514, 4}}},
{{.refcount = &grpc_static_metadata_refcounts[2],
.data.refcounted = {g_bytes + 12, 7}},
{.refcount = &grpc_static_metadata_refcounts[38],
.data.refcounted = {g_bytes + 480, 3}}},
{.refcount = &grpc_static_metadata_refcounts[41],
.data.refcounted = {g_bytes + 518, 3}}},
{{.refcount = &grpc_static_metadata_refcounts[2],
.data.refcounted = {g_bytes + 12, 7}},
{.refcount = &grpc_static_metadata_refcounts[39],
.data.refcounted = {g_bytes + 483, 3}}},
{.refcount = &grpc_static_metadata_refcounts[42],
.data.refcounted = {g_bytes + 521, 3}}},
{{.refcount = &grpc_static_metadata_refcounts[4],
.data.refcounted = {g_bytes + 29, 7}},
{.refcount = &grpc_static_metadata_refcounts[40],
.data.refcounted = {g_bytes + 486, 4}}},
{.refcount = &grpc_static_metadata_refcounts[43],
.data.refcounted = {g_bytes + 524, 4}}},
{{.refcount = &grpc_static_metadata_refcounts[4],
.data.refcounted = {g_bytes + 29, 7}},
{.refcount = &grpc_static_metadata_refcounts[41],
.data.refcounted = {g_bytes + 490, 5}}},
{.refcount = &grpc_static_metadata_refcounts[44],
.data.refcounted = {g_bytes + 528, 5}}},
{{.refcount = &grpc_static_metadata_refcounts[4],
.data.refcounted = {g_bytes + 29, 7}},
{.refcount = &grpc_static_metadata_refcounts[42],
.data.refcounted = {g_bytes + 495, 4}}},
{.refcount = &grpc_static_metadata_refcounts[45],
.data.refcounted = {g_bytes + 533, 4}}},
{{.refcount = &grpc_static_metadata_refcounts[3],
.data.refcounted = {g_bytes + 19, 10}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[1],
.data.refcounted = {g_bytes + 5, 7}},
{.refcount = &grpc_static_metadata_refcounts[43],
.data.refcounted = {g_bytes + 499, 3}}},
{.refcount = &grpc_static_metadata_refcounts[46],
.data.refcounted = {g_bytes + 537, 3}}},
{{.refcount = &grpc_static_metadata_refcounts[1],
.data.refcounted = {g_bytes + 5, 7}},
{.refcount = &grpc_static_metadata_refcounts[44],
.data.refcounted = {g_bytes + 502, 3}}},
{.refcount = &grpc_static_metadata_refcounts[47],
.data.refcounted = {g_bytes + 540, 3}}},
{{.refcount = &grpc_static_metadata_refcounts[0],
.data.refcounted = {g_bytes + 0, 5}},
{.refcount = &grpc_static_metadata_refcounts[45],
.data.refcounted = {g_bytes + 505, 1}}},
{.refcount = &grpc_static_metadata_refcounts[48],
.data.refcounted = {g_bytes + 543, 1}}},
{{.refcount = &grpc_static_metadata_refcounts[0],
.data.refcounted = {g_bytes + 0, 5}},
{.refcount = &grpc_static_metadata_refcounts[46],
.data.refcounted = {g_bytes + 506, 11}}},
{.refcount = &grpc_static_metadata_refcounts[49],
.data.refcounted = {g_bytes + 544, 11}}},
{{.refcount = &grpc_static_metadata_refcounts[2],
.data.refcounted = {g_bytes + 12, 7}},
{.refcount = &grpc_static_metadata_refcounts[47],
.data.refcounted = {g_bytes + 517, 3}}},
{.refcount = &grpc_static_metadata_refcounts[50],
.data.refcounted = {g_bytes + 555, 3}}},
{{.refcount = &grpc_static_metadata_refcounts[2],
.data.refcounted = {g_bytes + 12, 7}},
{.refcount = &grpc_static_metadata_refcounts[48],
.data.refcounted = {g_bytes + 520, 3}}},
{.refcount = &grpc_static_metadata_refcounts[51],
.data.refcounted = {g_bytes + 558, 3}}},
{{.refcount = &grpc_static_metadata_refcounts[2],
.data.refcounted = {g_bytes + 12, 7}},
{.refcount = &grpc_static_metadata_refcounts[49],
.data.refcounted = {g_bytes + 523, 3}}},
{.refcount = &grpc_static_metadata_refcounts[52],
.data.refcounted = {g_bytes + 561, 3}}},
{{.refcount = &grpc_static_metadata_refcounts[2],
.data.refcounted = {g_bytes + 12, 7}},
{.refcount = &grpc_static_metadata_refcounts[50],
.data.refcounted = {g_bytes + 526, 3}}},
{.refcount = &grpc_static_metadata_refcounts[53],
.data.refcounted = {g_bytes + 564, 3}}},
{{.refcount = &grpc_static_metadata_refcounts[2],
.data.refcounted = {g_bytes + 12, 7}},
{.refcount = &grpc_static_metadata_refcounts[51],
.data.refcounted = {g_bytes + 529, 3}}},
{{.refcount = &grpc_static_metadata_refcounts[52],
.data.refcounted = {g_bytes + 532, 14}},
{.refcount = &grpc_static_metadata_refcounts[54],
.data.refcounted = {g_bytes + 567, 3}}},
{{.refcount = &grpc_static_metadata_refcounts[55],
.data.refcounted = {g_bytes + 570, 14}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[16],
@ -584,114 +595,102 @@ grpc_mdelem_data grpc_static_mdelem_table[GRPC_STATIC_MDELEM_COUNT] = {
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[16],
.data.refcounted = {g_bytes + 186, 15}},
{.refcount = &grpc_static_metadata_refcounts[53],
.data.refcounted = {g_bytes + 546, 13}}},
{{.refcount = &grpc_static_metadata_refcounts[54],
.data.refcounted = {g_bytes + 559, 15}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[55],
.data.refcounted = {g_bytes + 574, 13}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[56],
.data.refcounted = {g_bytes + 587, 6}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{.refcount = &grpc_static_metadata_refcounts[56],
.data.refcounted = {g_bytes + 584, 13}}},
{{.refcount = &grpc_static_metadata_refcounts[57],
.data.refcounted = {g_bytes + 593, 27}},
.data.refcounted = {g_bytes + 597, 15}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[58],
.data.refcounted = {g_bytes + 620, 3}},
.data.refcounted = {g_bytes + 612, 13}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[59],
.data.refcounted = {g_bytes + 623, 5}},
.data.refcounted = {g_bytes + 625, 6}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[60],
.data.refcounted = {g_bytes + 628, 13}},
.data.refcounted = {g_bytes + 631, 27}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[61],
.data.refcounted = {g_bytes + 641, 13}},
.data.refcounted = {g_bytes + 658, 3}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[62],
.data.refcounted = {g_bytes + 654, 19}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[15],
.data.refcounted = {g_bytes + 170, 16}},
{.refcount = &grpc_static_metadata_refcounts[32],
.data.refcounted = {g_bytes + 433, 8}}},
{{.refcount = &grpc_static_metadata_refcounts[15],
.data.refcounted = {g_bytes + 170, 16}},
{.refcount = &grpc_static_metadata_refcounts[33],
.data.refcounted = {g_bytes + 441, 4}}},
{{.refcount = &grpc_static_metadata_refcounts[15],
.data.refcounted = {g_bytes + 170, 16}},
.data.refcounted = {g_bytes + 661, 5}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[63],
.data.refcounted = {g_bytes + 673, 16}},
.data.refcounted = {g_bytes + 666, 13}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[64],
.data.refcounted = {g_bytes + 689, 14}},
.data.refcounted = {g_bytes + 679, 13}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[65],
.data.refcounted = {g_bytes + 703, 16}},
.data.refcounted = {g_bytes + 692, 19}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[66],
.data.refcounted = {g_bytes + 719, 13}},
{{.refcount = &grpc_static_metadata_refcounts[15],
.data.refcounted = {g_bytes + 170, 16}},
{.refcount = &grpc_static_metadata_refcounts[35],
.data.refcounted = {g_bytes + 471, 8}}},
{{.refcount = &grpc_static_metadata_refcounts[15],
.data.refcounted = {g_bytes + 170, 16}},
{.refcount = &grpc_static_metadata_refcounts[36],
.data.refcounted = {g_bytes + 479, 4}}},
{{.refcount = &grpc_static_metadata_refcounts[15],
.data.refcounted = {g_bytes + 170, 16}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[14],
.data.refcounted = {g_bytes + 158, 12}},
{{.refcount = &grpc_static_metadata_refcounts[66],
.data.refcounted = {g_bytes + 711, 16}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[67],
.data.refcounted = {g_bytes + 732, 6}},
.data.refcounted = {g_bytes + 727, 14}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[68],
.data.refcounted = {g_bytes + 738, 4}},
.data.refcounted = {g_bytes + 741, 16}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[69],
.data.refcounted = {g_bytes + 742, 4}},
.data.refcounted = {g_bytes + 757, 13}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[14],
.data.refcounted = {g_bytes + 158, 12}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[70],
.data.refcounted = {g_bytes + 746, 6}},
.data.refcounted = {g_bytes + 770, 6}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[71],
.data.refcounted = {g_bytes + 752, 7}},
.data.refcounted = {g_bytes + 776, 4}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[72],
.data.refcounted = {g_bytes + 759, 4}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[20],
.data.refcounted = {g_bytes + 278, 4}},
.data.refcounted = {g_bytes + 780, 4}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[73],
.data.refcounted = {g_bytes + 763, 8}},
.data.refcounted = {g_bytes + 784, 6}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[74],
.data.refcounted = {g_bytes + 771, 17}},
.data.refcounted = {g_bytes + 790, 7}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[75],
.data.refcounted = {g_bytes + 788, 13}},
.data.refcounted = {g_bytes + 797, 4}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[20],
.data.refcounted = {g_bytes + 278, 4}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[76],
@ -699,129 +698,141 @@ grpc_mdelem_data grpc_static_mdelem_table[GRPC_STATIC_MDELEM_COUNT] = {
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[77],
.data.refcounted = {g_bytes + 809, 19}},
.data.refcounted = {g_bytes + 809, 17}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[78],
.data.refcounted = {g_bytes + 828, 13}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[21],
.data.refcounted = {g_bytes + 282, 8}},
.data.refcounted = {g_bytes + 826, 13}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[79],
.data.refcounted = {g_bytes + 841, 11}},
.data.refcounted = {g_bytes + 839, 8}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[80],
.data.refcounted = {g_bytes + 852, 4}},
.data.refcounted = {g_bytes + 847, 19}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[81],
.data.refcounted = {g_bytes + 856, 8}},
.data.refcounted = {g_bytes + 866, 13}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[21],
.data.refcounted = {g_bytes + 282, 8}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[82],
.data.refcounted = {g_bytes + 864, 12}},
.data.refcounted = {g_bytes + 879, 11}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[83],
.data.refcounted = {g_bytes + 876, 18}},
.data.refcounted = {g_bytes + 890, 4}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[84],
.data.refcounted = {g_bytes + 894, 19}},
.data.refcounted = {g_bytes + 894, 8}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[85],
.data.refcounted = {g_bytes + 913, 5}},
.data.refcounted = {g_bytes + 902, 12}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[86],
.data.refcounted = {g_bytes + 918, 7}},
.data.refcounted = {g_bytes + 914, 18}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[87],
.data.refcounted = {g_bytes + 925, 7}},
.data.refcounted = {g_bytes + 932, 19}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[88],
.data.refcounted = {g_bytes + 932, 11}},
.data.refcounted = {g_bytes + 951, 5}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[89],
.data.refcounted = {g_bytes + 943, 6}},
.data.refcounted = {g_bytes + 956, 7}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[90],
.data.refcounted = {g_bytes + 949, 10}},
.data.refcounted = {g_bytes + 963, 7}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[91],
.data.refcounted = {g_bytes + 959, 25}},
.data.refcounted = {g_bytes + 970, 11}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[92],
.data.refcounted = {g_bytes + 984, 17}},
.data.refcounted = {g_bytes + 981, 6}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[93],
.data.refcounted = {g_bytes + 987, 10}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[94],
.data.refcounted = {g_bytes + 997, 25}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[95],
.data.refcounted = {g_bytes + 1022, 17}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[19],
.data.refcounted = {g_bytes + 268, 10}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[93],
.data.refcounted = {g_bytes + 1001, 4}},
{{.refcount = &grpc_static_metadata_refcounts[96],
.data.refcounted = {g_bytes + 1039, 4}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[94],
.data.refcounted = {g_bytes + 1005, 3}},
{{.refcount = &grpc_static_metadata_refcounts[97],
.data.refcounted = {g_bytes + 1043, 3}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[95],
.data.refcounted = {g_bytes + 1008, 16}},
{{.refcount = &grpc_static_metadata_refcounts[98],
.data.refcounted = {g_bytes + 1046, 16}},
{.refcount = &grpc_static_metadata_refcounts[23],
.data.refcounted = {g_bytes + 302, 0}}},
{{.refcount = &grpc_static_metadata_refcounts[10],
.data.refcounted = {g_bytes + 90, 20}},
{.refcount = &grpc_static_metadata_refcounts[32],
.data.refcounted = {g_bytes + 433, 8}}},
{.refcount = &grpc_static_metadata_refcounts[35],
.data.refcounted = {g_bytes + 471, 8}}},
{{.refcount = &grpc_static_metadata_refcounts[10],
.data.refcounted = {g_bytes + 90, 20}},
{.refcount = &grpc_static_metadata_refcounts[34],
.data.refcounted = {g_bytes + 445, 7}}},
{.refcount = &grpc_static_metadata_refcounts[37],
.data.refcounted = {g_bytes + 483, 7}}},
{{.refcount = &grpc_static_metadata_refcounts[10],
.data.refcounted = {g_bytes + 90, 20}},
{.refcount = &grpc_static_metadata_refcounts[96],
.data.refcounted = {g_bytes + 1024, 16}}},
{.refcount = &grpc_static_metadata_refcounts[99],
.data.refcounted = {g_bytes + 1062, 16}}},
{{.refcount = &grpc_static_metadata_refcounts[10],
.data.refcounted = {g_bytes + 90, 20}},
{.refcount = &grpc_static_metadata_refcounts[33],
.data.refcounted = {g_bytes + 441, 4}}},
{.refcount = &grpc_static_metadata_refcounts[36],
.data.refcounted = {g_bytes + 479, 4}}},
{{.refcount = &grpc_static_metadata_refcounts[10],
.data.refcounted = {g_bytes + 90, 20}},
{.refcount = &grpc_static_metadata_refcounts[97],
.data.refcounted = {g_bytes + 1040, 13}}},
{.refcount = &grpc_static_metadata_refcounts[100],
.data.refcounted = {g_bytes + 1078, 13}}},
{{.refcount = &grpc_static_metadata_refcounts[10],
.data.refcounted = {g_bytes + 90, 20}},
{.refcount = &grpc_static_metadata_refcounts[98],
.data.refcounted = {g_bytes + 1053, 12}}},
{.refcount = &grpc_static_metadata_refcounts[101],
.data.refcounted = {g_bytes + 1091, 12}}},
{{.refcount = &grpc_static_metadata_refcounts[10],
.data.refcounted = {g_bytes + 90, 20}},
{.refcount = &grpc_static_metadata_refcounts[99],
.data.refcounted = {g_bytes + 1065, 21}}},
{.refcount = &grpc_static_metadata_refcounts[102],
.data.refcounted = {g_bytes + 1103, 21}}},
{{.refcount = &grpc_static_metadata_refcounts[16],
.data.refcounted = {g_bytes + 186, 15}},
{.refcount = &grpc_static_metadata_refcounts[32],
.data.refcounted = {g_bytes + 433, 8}}},
{.refcount = &grpc_static_metadata_refcounts[35],
.data.refcounted = {g_bytes + 471, 8}}},
{{.refcount = &grpc_static_metadata_refcounts[16],
.data.refcounted = {g_bytes + 186, 15}},
{.refcount = &grpc_static_metadata_refcounts[33],
.data.refcounted = {g_bytes + 441, 4}}},
{.refcount = &grpc_static_metadata_refcounts[36],
.data.refcounted = {g_bytes + 479, 4}}},
{{.refcount = &grpc_static_metadata_refcounts[16],
.data.refcounted = {g_bytes + 186, 15}},
{.refcount = &grpc_static_metadata_refcounts[97],
.data.refcounted = {g_bytes + 1040, 13}}},
{.refcount = &grpc_static_metadata_refcounts[100],
.data.refcounted = {g_bytes + 1078, 13}}},
};
bool grpc_static_callout_is_default[GRPC_BATCH_CALLOUTS_COUNT] = {
true, // :path

150
src/core/lib/transport/static_metadata.h
Unescape View File

@ -29,7 +29,7 @@
#include "src/core/lib/transport/metadata.h"
#define GRPC_STATIC_MDSTR_COUNT 100
#define GRPC_STATIC_MDSTR_COUNT 103
extern const grpc_slice grpc_static_slice_table[GRPC_STATIC_MDSTR_COUNT];
/* ":path" */
#define GRPC_MDSTR_PATH (grpc_static_slice_table[0])
@ -93,149 +93,155 @@ extern const grpc_slice grpc_static_slice_table[GRPC_STATIC_MDSTR_COUNT];
/* "/grpc.lb.v1.LoadBalancer/BalanceLoad" */
#define GRPC_MDSTR_SLASH_GRPC_DOT_LB_DOT_V1_DOT_LOADBALANCER_SLASH_BALANCELOAD \
(grpc_static_slice_table[28])
/* "message/deflate" */
#define GRPC_MDSTR_MESSAGE_SLASH_DEFLATE (grpc_static_slice_table[29])
/* "message/gzip" */
#define GRPC_MDSTR_MESSAGE_SLASH_GZIP (grpc_static_slice_table[30])
/* "stream/gzip" */
#define GRPC_MDSTR_STREAM_SLASH_GZIP (grpc_static_slice_table[31])
/* "0" */
#define GRPC_MDSTR_0 (grpc_static_slice_table[29])
#define GRPC_MDSTR_0 (grpc_static_slice_table[32])
/* "1" */
#define GRPC_MDSTR_1 (grpc_static_slice_table[30])
#define GRPC_MDSTR_1 (grpc_static_slice_table[33])
/* "2" */
#define GRPC_MDSTR_2 (grpc_static_slice_table[31])
#define GRPC_MDSTR_2 (grpc_static_slice_table[34])
/* "identity" */
#define GRPC_MDSTR_IDENTITY (grpc_static_slice_table[32])
#define GRPC_MDSTR_IDENTITY (grpc_static_slice_table[35])
/* "gzip" */
#define GRPC_MDSTR_GZIP (grpc_static_slice_table[33])
#define GRPC_MDSTR_GZIP (grpc_static_slice_table[36])
/* "deflate" */
#define GRPC_MDSTR_DEFLATE (grpc_static_slice_table[34])
#define GRPC_MDSTR_DEFLATE (grpc_static_slice_table[37])
/* "trailers" */
#define GRPC_MDSTR_TRAILERS (grpc_static_slice_table[35])
#define GRPC_MDSTR_TRAILERS (grpc_static_slice_table[38])
/* "application/grpc" */
#define GRPC_MDSTR_APPLICATION_SLASH_GRPC (grpc_static_slice_table[36])
#define GRPC_MDSTR_APPLICATION_SLASH_GRPC (grpc_static_slice_table[39])
/* "POST" */
#define GRPC_MDSTR_POST (grpc_static_slice_table[37])
#define GRPC_MDSTR_POST (grpc_static_slice_table[40])
/* "200" */
#define GRPC_MDSTR_200 (grpc_static_slice_table[38])
#define GRPC_MDSTR_200 (grpc_static_slice_table[41])
/* "404" */
#define GRPC_MDSTR_404 (grpc_static_slice_table[39])
#define GRPC_MDSTR_404 (grpc_static_slice_table[42])
/* "http" */
#define GRPC_MDSTR_HTTP (grpc_static_slice_table[40])
#define GRPC_MDSTR_HTTP (grpc_static_slice_table[43])
/* "https" */
#define GRPC_MDSTR_HTTPS (grpc_static_slice_table[41])
#define GRPC_MDSTR_HTTPS (grpc_static_slice_table[44])
/* "grpc" */
#define GRPC_MDSTR_GRPC (grpc_static_slice_table[42])
#define GRPC_MDSTR_GRPC (grpc_static_slice_table[45])
/* "GET" */
#define GRPC_MDSTR_GET (grpc_static_slice_table[43])
#define GRPC_MDSTR_GET (grpc_static_slice_table[46])
/* "PUT" */
#define GRPC_MDSTR_PUT (grpc_static_slice_table[44])
#define GRPC_MDSTR_PUT (grpc_static_slice_table[47])
/* "/" */
#define GRPC_MDSTR_SLASH (grpc_static_slice_table[45])
#define GRPC_MDSTR_SLASH (grpc_static_slice_table[48])
/* "/index.html" */
#define GRPC_MDSTR_SLASH_INDEX_DOT_HTML (grpc_static_slice_table[46])
#define GRPC_MDSTR_SLASH_INDEX_DOT_HTML (grpc_static_slice_table[49])
/* "204" */
#define GRPC_MDSTR_204 (grpc_static_slice_table[47])
#define GRPC_MDSTR_204 (grpc_static_slice_table[50])
/* "206" */
#define GRPC_MDSTR_206 (grpc_static_slice_table[48])
#define GRPC_MDSTR_206 (grpc_static_slice_table[51])
/* "304" */
#define GRPC_MDSTR_304 (grpc_static_slice_table[49])
#define GRPC_MDSTR_304 (grpc_static_slice_table[52])
/* "400" */
#define GRPC_MDSTR_400 (grpc_static_slice_table[50])
#define GRPC_MDSTR_400 (grpc_static_slice_table[53])
/* "500" */
#define GRPC_MDSTR_500 (grpc_static_slice_table[51])
#define GRPC_MDSTR_500 (grpc_static_slice_table[54])
/* "accept-charset" */
#define GRPC_MDSTR_ACCEPT_CHARSET (grpc_static_slice_table[52])
#define GRPC_MDSTR_ACCEPT_CHARSET (grpc_static_slice_table[55])
/* "gzip, deflate" */
#define GRPC_MDSTR_GZIP_COMMA_DEFLATE (grpc_static_slice_table[53])
#define GRPC_MDSTR_GZIP_COMMA_DEFLATE (grpc_static_slice_table[56])
/* "accept-language" */
#define GRPC_MDSTR_ACCEPT_LANGUAGE (grpc_static_slice_table[54])
#define GRPC_MDSTR_ACCEPT_LANGUAGE (grpc_static_slice_table[57])
/* "accept-ranges" */
#define GRPC_MDSTR_ACCEPT_RANGES (grpc_static_slice_table[55])
#define GRPC_MDSTR_ACCEPT_RANGES (grpc_static_slice_table[58])
/* "accept" */
#define GRPC_MDSTR_ACCEPT (grpc_static_slice_table[56])
#define GRPC_MDSTR_ACCEPT (grpc_static_slice_table[59])
/* "access-control-allow-origin" */
#define GRPC_MDSTR_ACCESS_CONTROL_ALLOW_ORIGIN (grpc_static_slice_table[57])
#define GRPC_MDSTR_ACCESS_CONTROL_ALLOW_ORIGIN (grpc_static_slice_table[60])
/* "age" */
#define GRPC_MDSTR_AGE (grpc_static_slice_table[58])
#define GRPC_MDSTR_AGE (grpc_static_slice_table[61])
/* "allow" */
#define GRPC_MDSTR_ALLOW (grpc_static_slice_table[59])
#define GRPC_MDSTR_ALLOW (grpc_static_slice_table[62])
/* "authorization" */
#define GRPC_MDSTR_AUTHORIZATION (grpc_static_slice_table[60])
#define GRPC_MDSTR_AUTHORIZATION (grpc_static_slice_table[63])
/* "cache-control" */
#define GRPC_MDSTR_CACHE_CONTROL (grpc_static_slice_table[61])
#define GRPC_MDSTR_CACHE_CONTROL (grpc_static_slice_table[64])
/* "content-disposition" */
#define GRPC_MDSTR_CONTENT_DISPOSITION (grpc_static_slice_table[62])
#define GRPC_MDSTR_CONTENT_DISPOSITION (grpc_static_slice_table[65])
/* "content-language" */
#define GRPC_MDSTR_CONTENT_LANGUAGE (grpc_static_slice_table[63])
#define GRPC_MDSTR_CONTENT_LANGUAGE (grpc_static_slice_table[66])
/* "content-length" */
#define GRPC_MDSTR_CONTENT_LENGTH (grpc_static_slice_table[64])
#define GRPC_MDSTR_CONTENT_LENGTH (grpc_static_slice_table[67])
/* "content-location" */
#define GRPC_MDSTR_CONTENT_LOCATION (grpc_static_slice_table[65])
#define GRPC_MDSTR_CONTENT_LOCATION (grpc_static_slice_table[68])
/* "content-range" */
#define GRPC_MDSTR_CONTENT_RANGE (grpc_static_slice_table[66])
#define GRPC_MDSTR_CONTENT_RANGE (grpc_static_slice_table[69])
/* "cookie" */
#define GRPC_MDSTR_COOKIE (grpc_static_slice_table[67])
#define GRPC_MDSTR_COOKIE (grpc_static_slice_table[70])
/* "date" */
#define GRPC_MDSTR_DATE (grpc_static_slice_table[68])
#define GRPC_MDSTR_DATE (grpc_static_slice_table[71])
/* "etag" */
#define GRPC_MDSTR_ETAG (grpc_static_slice_table[69])
#define GRPC_MDSTR_ETAG (grpc_static_slice_table[72])
/* "expect" */
#define GRPC_MDSTR_EXPECT (grpc_static_slice_table[70])
#define GRPC_MDSTR_EXPECT (grpc_static_slice_table[73])
/* "expires" */
#define GRPC_MDSTR_EXPIRES (grpc_static_slice_table[71])
#define GRPC_MDSTR_EXPIRES (grpc_static_slice_table[74])
/* "from" */
#define GRPC_MDSTR_FROM (grpc_static_slice_table[72])
#define GRPC_MDSTR_FROM (grpc_static_slice_table[75])
/* "if-match" */
#define GRPC_MDSTR_IF_MATCH (grpc_static_slice_table[73])
#define GRPC_MDSTR_IF_MATCH (grpc_static_slice_table[76])
/* "if-modified-since" */
#define GRPC_MDSTR_IF_MODIFIED_SINCE (grpc_static_slice_table[74])
#define GRPC_MDSTR_IF_MODIFIED_SINCE (grpc_static_slice_table[77])
/* "if-none-match" */
#define GRPC_MDSTR_IF_NONE_MATCH (grpc_static_slice_table[75])
#define GRPC_MDSTR_IF_NONE_MATCH (grpc_static_slice_table[78])
/* "if-range" */
#define GRPC_MDSTR_IF_RANGE (grpc_static_slice_table[76])
#define GRPC_MDSTR_IF_RANGE (grpc_static_slice_table[79])
/* "if-unmodified-since" */
#define GRPC_MDSTR_IF_UNMODIFIED_SINCE (grpc_static_slice_table[77])
#define GRPC_MDSTR_IF_UNMODIFIED_SINCE (grpc_static_slice_table[80])
/* "last-modified" */
#define GRPC_MDSTR_LAST_MODIFIED (grpc_static_slice_table[78])
#define GRPC_MDSTR_LAST_MODIFIED (grpc_static_slice_table[81])
/* "lb-cost-bin" */
#define GRPC_MDSTR_LB_COST_BIN (grpc_static_slice_table[79])
#define GRPC_MDSTR_LB_COST_BIN (grpc_static_slice_table[82])
/* "link" */
#define GRPC_MDSTR_LINK (grpc_static_slice_table[80])
#define GRPC_MDSTR_LINK (grpc_static_slice_table[83])
/* "location" */
#define GRPC_MDSTR_LOCATION (grpc_static_slice_table[81])
#define GRPC_MDSTR_LOCATION (grpc_static_slice_table[84])
/* "max-forwards" */
#define GRPC_MDSTR_MAX_FORWARDS (grpc_static_slice_table[82])
#define GRPC_MDSTR_MAX_FORWARDS (grpc_static_slice_table[85])
/* "proxy-authenticate" */
#define GRPC_MDSTR_PROXY_AUTHENTICATE (grpc_static_slice_table[83])
#define GRPC_MDSTR_PROXY_AUTHENTICATE (grpc_static_slice_table[86])
/* "proxy-authorization" */
#define GRPC_MDSTR_PROXY_AUTHORIZATION (grpc_static_slice_table[84])
#define GRPC_MDSTR_PROXY_AUTHORIZATION (grpc_static_slice_table[87])
/* "range" */
#define GRPC_MDSTR_RANGE (grpc_static_slice_table[85])
#define GRPC_MDSTR_RANGE (grpc_static_slice_table[88])
/* "referer" */
#define GRPC_MDSTR_REFERER (grpc_static_slice_table[86])
#define GRPC_MDSTR_REFERER (grpc_static_slice_table[89])
/* "refresh" */
#define GRPC_MDSTR_REFRESH (grpc_static_slice_table[87])
#define GRPC_MDSTR_REFRESH (grpc_static_slice_table[90])
/* "retry-after" */
#define GRPC_MDSTR_RETRY_AFTER (grpc_static_slice_table[88])
#define GRPC_MDSTR_RETRY_AFTER (grpc_static_slice_table[91])
/* "server" */
#define GRPC_MDSTR_SERVER (grpc_static_slice_table[89])
#define GRPC_MDSTR_SERVER (grpc_static_slice_table[92])
/* "set-cookie" */
#define GRPC_MDSTR_SET_COOKIE (grpc_static_slice_table[90])
#define GRPC_MDSTR_SET_COOKIE (grpc_static_slice_table[93])
/* "strict-transport-security" */
#define GRPC_MDSTR_STRICT_TRANSPORT_SECURITY (grpc_static_slice_table[91])
#define GRPC_MDSTR_STRICT_TRANSPORT_SECURITY (grpc_static_slice_table[94])
/* "transfer-encoding" */
#define GRPC_MDSTR_TRANSFER_ENCODING (grpc_static_slice_table[92])
#define GRPC_MDSTR_TRANSFER_ENCODING (grpc_static_slice_table[95])
/* "vary" */
#define GRPC_MDSTR_VARY (grpc_static_slice_table[93])
#define GRPC_MDSTR_VARY (grpc_static_slice_table[96])
/* "via" */
#define GRPC_MDSTR_VIA (grpc_static_slice_table[94])
#define GRPC_MDSTR_VIA (grpc_static_slice_table[97])
/* "www-authenticate" */
#define GRPC_MDSTR_WWW_AUTHENTICATE (grpc_static_slice_table[95])
#define GRPC_MDSTR_WWW_AUTHENTICATE (grpc_static_slice_table[98])
/* "identity,deflate" */
#define GRPC_MDSTR_IDENTITY_COMMA_DEFLATE (grpc_static_slice_table[96])
#define GRPC_MDSTR_IDENTITY_COMMA_DEFLATE (grpc_static_slice_table[99])
/* "identity,gzip" */
#define GRPC_MDSTR_IDENTITY_COMMA_GZIP (grpc_static_slice_table[97])
#define GRPC_MDSTR_IDENTITY_COMMA_GZIP (grpc_static_slice_table[100])
/* "deflate,gzip" */
#define GRPC_MDSTR_DEFLATE_COMMA_GZIP (grpc_static_slice_table[98])
#define GRPC_MDSTR_DEFLATE_COMMA_GZIP (grpc_static_slice_table[101])
/* "identity,deflate,gzip" */
#define GRPC_MDSTR_IDENTITY_COMMA_DEFLATE_COMMA_GZIP \
(grpc_static_slice_table[99])
(grpc_static_slice_table[102])
extern const grpc_slice_refcount_vtable grpc_static_metadata_vtable;
extern grpc_slice_refcount

25
test/core/channel/channel_args_test.c
Unescape View File

@ -64,7 +64,7 @@ static void test_set_compression_algorithm(void) {
grpc_channel_args *ch_args;
ch_args =
grpc_channel_args_set_compression_algorithm(NULL, GRPC_COMPRESS_GZIP);
grpc_channel_args_set_compression_algorithm(NULL, GRPC_COMPRESS_MESSAGE_GZIP);
GPR_ASSERT(ch_args->num_args == 1);
GPR_ASSERT(strcmp(ch_args->args[0].key,
GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM) == 0);
@ -76,7 +76,7 @@ static void test_set_compression_algorithm(void) {
static void test_compression_algorithm_states(void) {
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
grpc_channel_args *ch_args, *ch_args_wo_gzip, *ch_args_wo_gzip_deflate;
grpc_channel_args *ch_args, *ch_args_wo_gzip, *ch_args_wo_gzip_deflate, *ch_args_wo_gzip_deflate_gzip;
unsigned states_bitset;
size_t i;
@ -89,33 +89,38 @@ static void test_compression_algorithm_states(void) {
GPR_ASSERT(GPR_BITGET(states_bitset, i));
}
/* disable gzip and deflate */
/* disable message/gzip and message/deflate and stream/gzip */
ch_args_wo_gzip = grpc_channel_args_compression_algorithm_set_state(
&exec_ctx, &ch_args, GRPC_COMPRESS_GZIP, 0);
&exec_ctx, &ch_args, GRPC_COMPRESS_MESSAGE_GZIP, 0);
GPR_ASSERT(ch_args == ch_args_wo_gzip);
ch_args_wo_gzip_deflate = grpc_channel_args_compression_algorithm_set_state(
&exec_ctx, &ch_args_wo_gzip, GRPC_COMPRESS_DEFLATE, 0);
&exec_ctx, &ch_args_wo_gzip, GRPC_COMPRESS_MESSAGE_DEFLATE, 0);
GPR_ASSERT(ch_args_wo_gzip == ch_args_wo_gzip_deflate);
ch_args_wo_gzip_deflate_gzip = grpc_channel_args_compression_algorithm_set_state(
&exec_ctx, &ch_args_wo_gzip_deflate, GRPC_COMPRESS_STREAM_GZIP, 0);
GPR_ASSERT(ch_args_wo_gzip_deflate == ch_args_wo_gzip_deflate_gzip);
states_bitset = (unsigned)grpc_channel_args_compression_algorithm_get_states(
ch_args_wo_gzip_deflate);
for (i = 0; i < GRPC_COMPRESS_ALGORITHMS_COUNT; i++) {
if (i == GRPC_COMPRESS_GZIP || i == GRPC_COMPRESS_DEFLATE) {
if (i == GRPC_COMPRESS_MESSAGE_GZIP || i == GRPC_COMPRESS_MESSAGE_DEFLATE || i == GRPC_COMPRESS_STREAM_GZIP) {
GPR_ASSERT(GPR_BITGET(states_bitset, i) == 0);
} else {
GPR_ASSERT(GPR_BITGET(states_bitset, i) != 0);
}
}
/* re-enabled gzip only */
/* re-enabled message/gzip and stream/gzip only */
ch_args_wo_gzip = grpc_channel_args_compression_algorithm_set_state(
&exec_ctx, &ch_args_wo_gzip_deflate, GRPC_COMPRESS_GZIP, 1);
GPR_ASSERT(ch_args_wo_gzip == ch_args_wo_gzip_deflate);
&exec_ctx, &ch_args_wo_gzip_deflate_gzip, GRPC_COMPRESS_MESSAGE_GZIP, 1);
ch_args_wo_gzip = grpc_channel_args_compression_algorithm_set_state(
&exec_ctx, &ch_args_wo_gzip, GRPC_COMPRESS_STREAM_GZIP, 1);
GPR_ASSERT(ch_args_wo_gzip == ch_args_wo_gzip_deflate_gzip);
states_bitset = (unsigned)grpc_channel_args_compression_algorithm_get_states(
ch_args_wo_gzip);
for (i = 0; i < GRPC_COMPRESS_ALGORITHMS_COUNT; i++) {
if (i == GRPC_COMPRESS_DEFLATE) {
if (i == GRPC_COMPRESS_MESSAGE_DEFLATE) {
GPR_ASSERT(GPR_BITGET(states_bitset, i) == 0);
} else {
GPR_ASSERT(GPR_BITGET(states_bitset, i) != 0);

12
test/core/compression/BUILD
Unescape View File

@ -53,3 +53,15 @@ grpc_cc_test(
"//test/core/util:grpc_test_util",
],
)
grpc_cc_test(
name = "stream_compress_test",
srcs = ["stream_compress_test.c"],
language = "C",
deps = [
"//:gpr",
"//:grpc",
"//test/core/util:gpr_test_util",
"//test/core/util:grpc_test_util",
],
)

16
test/core/compression/algorithm_test.c
Unescape View File

@ -29,6 +29,8 @@
#include "src/core/lib/transport/static_metadata.h"
#include "test/core/util/test_config.h"
const uint32_t message_prefix_length = 8;
const uint32_t stream_prefix_length = 7;
static void test_algorithm_mesh(void) {
int i;
@ -48,9 +50,19 @@ static void test_algorithm_mesh(void) {
mdstr = grpc_slice_from_copied_string(name);
GPR_ASSERT(grpc_slice_eq(mdstr, grpc_compression_algorithm_slice(parsed)));
GPR_ASSERT(parsed == grpc_compression_algorithm_from_slice(mdstr));
mdelem = grpc_compression_encoding_mdelem(parsed);
GPR_ASSERT(grpc_slice_eq(GRPC_MDVALUE(mdelem), mdstr));
if (parsed == 0) {
continue;
} else if (grpc_compression_algorithm_is_message(parsed)) {
mdelem = grpc_message_compression_encoding_mdelem(grpc_compression_algorithm_to_message_compression_algorithm(parsed));
grpc_slice value = GRPC_MDVALUE(mdelem);
GPR_ASSERT(0 == memcmp(&name[message_prefix_length], GRPC_SLICE_START_PTR(value), GRPC_SLICE_LENGTH(value)));
GPR_ASSERT(grpc_slice_eq(GRPC_MDKEY(mdelem), GRPC_MDSTR_GRPC_ENCODING));
} else {
mdelem = grpc_stream_compression_encoding_mdelem(grpc_compression_algorithm_to_stream_compression_algorithm(parsed));
grpc_slice value = GRPC_MDVALUE(mdelem);
GPR_ASSERT(0 == memcmp(&name[stream_prefix_length], GRPC_SLICE_START_PTR(value), GRPC_SLICE_LENGTH(value)));
GPR_ASSERT(grpc_slice_eq(GRPC_MDKEY(mdelem), GRPC_MDSTR_CONTENT_ENCODING));
}
grpc_slice_unref_internal(&exec_ctx, mdstr);
GRPC_MDELEM_UNREF(&exec_ctx, mdelem);
grpc_exec_ctx_finish(&exec_ctx);

178
test/core/compression/compression_test.c
Unescape View File

@ -28,9 +28,9 @@
static void test_compression_algorithm_parse(void) {
size_t i;
const char *valid_names[] = {"identity", "gzip", "deflate"};
const char *valid_names[] = {"identity", "message/gzip", "message/deflate", "stream/gzip"};
const grpc_compression_algorithm valid_algorithms[] = {
GRPC_COMPRESS_NONE, GRPC_COMPRESS_GZIP, GRPC_COMPRESS_DEFLATE};
GRPC_COMPRESS_NONE, GRPC_COMPRESS_MESSAGE_GZIP, GRPC_COMPRESS_MESSAGE_DEFLATE, GRPC_COMPRESS_STREAM_GZIP};
const char *invalid_names[] = {"gzip2", "foo", "", "2gzip"};
gpr_log(GPR_DEBUG, "test_compression_algorithm_parse");
@ -59,9 +59,9 @@ static void test_compression_algorithm_name(void) {
int success;
char *name;
size_t i;
const char *valid_names[] = {"identity", "gzip", "deflate"};
const char *valid_names[] = {"identity", "message/gzip", "message/deflate", "stream/gzip"};
const grpc_compression_algorithm valid_algorithms[] = {
GRPC_COMPRESS_NONE, GRPC_COMPRESS_GZIP, GRPC_COMPRESS_DEFLATE};
GRPC_COMPRESS_NONE, GRPC_COMPRESS_MESSAGE_GZIP, GRPC_COMPRESS_MESSAGE_DEFLATE, GRPC_COMPRESS_STREAM_GZIP};
gpr_log(GPR_DEBUG, "test_compression_algorithm_name");
@ -90,15 +90,27 @@ static void test_compression_algorithm_for_level(void) {
accepted_encodings));
GPR_ASSERT(GRPC_COMPRESS_NONE ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_LOW,
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MESSAGE_LOW,
accepted_encodings));
GPR_ASSERT(GRPC_COMPRESS_NONE ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MED,
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MESSAGE_MED,
accepted_encodings));
GPR_ASSERT(GRPC_COMPRESS_NONE ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_HIGH,
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MESSAGE_HIGH,
accepted_encodings));
GPR_ASSERT(GRPC_COMPRESS_NONE ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_STREAM_LOW,
accepted_encodings));
GPR_ASSERT(GRPC_COMPRESS_NONE ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_STREAM_MED,
accepted_encodings));
GPR_ASSERT(GRPC_COMPRESS_NONE ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_STREAM_HIGH,
accepted_encodings));
}
@ -106,22 +118,34 @@ static void test_compression_algorithm_for_level(void) {
/* accept only gzip */
uint32_t accepted_encodings = 0;
GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_NONE); /* always */
GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_GZIP);
GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_MESSAGE_GZIP);
GPR_ASSERT(GRPC_COMPRESS_NONE ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_NONE,
accepted_encodings));
GPR_ASSERT(GRPC_COMPRESS_GZIP ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_LOW,
GPR_ASSERT(GRPC_COMPRESS_MESSAGE_GZIP ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MESSAGE_LOW,
accepted_encodings));
GPR_ASSERT(GRPC_COMPRESS_GZIP ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MED,
GPR_ASSERT(GRPC_COMPRESS_MESSAGE_GZIP ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MESSAGE_MED,
accepted_encodings));
GPR_ASSERT(GRPC_COMPRESS_GZIP ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_HIGH,
GPR_ASSERT(GRPC_COMPRESS_MESSAGE_GZIP ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MESSAGE_HIGH,
accepted_encodings));
GPR_ASSERT(GRPC_COMPRESS_NONE ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_STREAM_LOW,
accepted_encodings));
GPR_ASSERT(GRPC_COMPRESS_NONE ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_STREAM_MED,
accepted_encodings));
GPR_ASSERT(GRPC_COMPRESS_NONE ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_STREAM_HIGH,
accepted_encodings));
}
@ -129,22 +153,34 @@ static void test_compression_algorithm_for_level(void) {
/* accept only deflate */
uint32_t accepted_encodings = 0;
GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_NONE); /* always */
GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_DEFLATE);
GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_MESSAGE_DEFLATE);
GPR_ASSERT(GRPC_COMPRESS_NONE ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_NONE,
accepted_encodings));
GPR_ASSERT(GRPC_COMPRESS_DEFLATE ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_LOW,
GPR_ASSERT(GRPC_COMPRESS_MESSAGE_DEFLATE ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MESSAGE_LOW,
accepted_encodings));
GPR_ASSERT(GRPC_COMPRESS_DEFLATE ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MED,
GPR_ASSERT(GRPC_COMPRESS_MESSAGE_DEFLATE ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MESSAGE_MED,
accepted_encodings));
GPR_ASSERT(GRPC_COMPRESS_DEFLATE ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_HIGH,
GPR_ASSERT(GRPC_COMPRESS_MESSAGE_DEFLATE ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MESSAGE_HIGH,
accepted_encodings));
GPR_ASSERT(GRPC_COMPRESS_NONE ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_STREAM_LOW,
accepted_encodings));
GPR_ASSERT(GRPC_COMPRESS_NONE ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_STREAM_MED,
accepted_encodings));
GPR_ASSERT(GRPC_COMPRESS_NONE ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_STREAM_HIGH,
accepted_encodings));
}
@ -152,23 +188,107 @@ static void test_compression_algorithm_for_level(void) {
/* accept gzip and deflate */
uint32_t accepted_encodings = 0;
GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_NONE); /* always */
GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_GZIP);
GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_DEFLATE);
GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_MESSAGE_GZIP);
GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_MESSAGE_DEFLATE);
GPR_ASSERT(GRPC_COMPRESS_NONE ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_NONE,
accepted_encodings));
GPR_ASSERT(GRPC_COMPRESS_GZIP ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_LOW,
GPR_ASSERT(GRPC_COMPRESS_MESSAGE_GZIP ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MESSAGE_LOW,
accepted_encodings));
GPR_ASSERT(GRPC_COMPRESS_MESSAGE_DEFLATE ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MESSAGE_MED,
accepted_encodings));
GPR_ASSERT(GRPC_COMPRESS_MESSAGE_DEFLATE ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MESSAGE_HIGH,
accepted_encodings));
GPR_ASSERT(GRPC_COMPRESS_NONE ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_STREAM_LOW,
accepted_encodings));
GPR_ASSERT(GRPC_COMPRESS_NONE ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_STREAM_MED,
accepted_encodings));
GPR_ASSERT(GRPC_COMPRESS_NONE ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_STREAM_HIGH,
accepted_encodings));
}
{
/* accept stream gzip */
uint32_t accepted_encodings = 0;
GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_NONE); /* always */
GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_STREAM_GZIP);
GPR_ASSERT(GRPC_COMPRESS_NONE ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_NONE,
accepted_encodings));
GPR_ASSERT(GRPC_COMPRESS_NONE ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MESSAGE_LOW,
accepted_encodings));
GPR_ASSERT(GRPC_COMPRESS_NONE ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MESSAGE_MED,
accepted_encodings));
GPR_ASSERT(GRPC_COMPRESS_NONE ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MESSAGE_HIGH,
accepted_encodings));
GPR_ASSERT(GRPC_COMPRESS_STREAM_GZIP ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_STREAM_LOW,
accepted_encodings));
GPR_ASSERT(GRPC_COMPRESS_STREAM_GZIP ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_STREAM_MED,
accepted_encodings));
GPR_ASSERT(GRPC_COMPRESS_STREAM_GZIP ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_STREAM_HIGH,
accepted_encodings));
}
{
/* accept all algorithms */
uint32_t accepted_encodings = 0;
GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_NONE); /* always */
GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_MESSAGE_GZIP);
GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_MESSAGE_DEFLATE);
GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_STREAM_GZIP);
GPR_ASSERT(GRPC_COMPRESS_NONE ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_NONE,
accepted_encodings));
GPR_ASSERT(GRPC_COMPRESS_MESSAGE_GZIP ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MESSAGE_LOW,
accepted_encodings));
GPR_ASSERT(GRPC_COMPRESS_MESSAGE_DEFLATE ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MESSAGE_MED,
accepted_encodings));
GPR_ASSERT(GRPC_COMPRESS_MESSAGE_DEFLATE ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MESSAGE_HIGH,
accepted_encodings));
GPR_ASSERT(GRPC_COMPRESS_STREAM_GZIP ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_STREAM_LOW,
accepted_encodings));
GPR_ASSERT(GRPC_COMPRESS_DEFLATE ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MED,
GPR_ASSERT(GRPC_COMPRESS_STREAM_GZIP ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_STREAM_MED,
accepted_encodings));
GPR_ASSERT(GRPC_COMPRESS_DEFLATE ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_HIGH,
GPR_ASSERT(GRPC_COMPRESS_STREAM_GZIP ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_STREAM_HIGH,
accepted_encodings));
}
}

34
test/core/compression/message_compress_test.c
Unescape View File

@ -39,7 +39,7 @@ typedef enum {
} compressability;
static void assert_passthrough(grpc_slice value,
grpc_compression_algorithm algorithm,
grpc_message_compression_algorithm algorithm,
grpc_slice_split_mode uncompressed_split_mode,
grpc_slice_split_mode compressed_split_mode,
compressability compress_result_check) {
@ -51,7 +51,7 @@ static void assert_passthrough(grpc_slice value,
int was_compressed;
char *algorithm_name;
GPR_ASSERT(grpc_compression_algorithm_name(algorithm, &algorithm_name) != 0);
GPR_ASSERT(grpc_message_compression_algorithm_name(algorithm, &algorithm_name) != 0);
gpr_log(
GPR_INFO, "assert_passthrough: value_length=%" PRIuPTR
" value_hash=0x%08x "
@ -93,7 +93,7 @@ static void assert_passthrough(grpc_slice value,
{
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
GPR_ASSERT(grpc_msg_decompress(
&exec_ctx, was_compressed ? algorithm : GRPC_COMPRESS_NONE, &compressed,
&exec_ctx, was_compressed ? algorithm : GRPC_MESSAGE_COMPRESS_NONE, &compressed,
&output));
grpc_exec_ctx_finish(&exec_ctx);
}
@ -115,8 +115,8 @@ static grpc_slice repeated(char c, size_t length) {
}
static compressability get_compressability(
test_value id, grpc_compression_algorithm algorithm) {
if (algorithm == GRPC_COMPRESS_NONE) return SHOULD_NOT_COMPRESS;
test_value id, grpc_message_compression_algorithm algorithm) {
if (algorithm == GRPC_MESSAGE_COMPRESS_NONE) return SHOULD_NOT_COMPRESS;
switch (id) {
case ONE_A:
return SHOULD_NOT_COMPRESS;
@ -148,14 +148,14 @@ static grpc_slice create_test_value(test_value id) {
static void test_tiny_data_compress(void) {
grpc_slice_buffer input;
grpc_slice_buffer output;
grpc_compression_algorithm i;
grpc_message_compression_algorithm i;
grpc_slice_buffer_init(&input);
grpc_slice_buffer_init(&output);
grpc_slice_buffer_add(&input, create_test_value(ONE_A));
for (i = 0; i < GRPC_COMPRESS_ALGORITHMS_COUNT; i++) {
if (i == GRPC_COMPRESS_NONE) continue;
for (i = 0; i < GRPC_MESSAGE_COMPRESS_ALGORITHMS_COUNT; i++) {
if (i == GRPC_MESSAGE_COMPRESS_NONE) continue;
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
GPR_ASSERT(0 == grpc_msg_compress(&exec_ctx, i, &input, &output));
grpc_exec_ctx_finish(&exec_ctx);
@ -180,7 +180,7 @@ static void test_bad_decompression_data_crc(void) {
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
/* compress it */
grpc_msg_compress(&exec_ctx, GRPC_COMPRESS_GZIP, &input, &corrupted);
grpc_msg_compress(&exec_ctx, GRPC_MESSAGE_COMPRESS_GZIP, &input, &corrupted);
/* corrupt the output by smashing the CRC */
GPR_ASSERT(corrupted.count > 1);
GPR_ASSERT(GRPC_SLICE_LENGTH(corrupted.slices[1]) > 8);
@ -188,7 +188,7 @@ static void test_bad_decompression_data_crc(void) {
memcpy(GRPC_SLICE_START_PTR(corrupted.slices[1]) + idx, &bad, 4);
/* try (and fail) to decompress the corrupted compresed buffer */
GPR_ASSERT(0 == grpc_msg_decompress(&exec_ctx, GRPC_COMPRESS_GZIP, &corrupted,
GPR_ASSERT(0 == grpc_msg_decompress(&exec_ctx, GRPC_MESSAGE_COMPRESS_GZIP, &corrupted,
&output));
grpc_exec_ctx_finish(&exec_ctx);
@ -210,7 +210,7 @@ static void test_bad_decompression_data_trailing_garbage(void) {
/* try (and fail) to decompress the invalid compresed buffer */
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
GPR_ASSERT(0 == grpc_msg_decompress(&exec_ctx, GRPC_COMPRESS_DEFLATE, &input,
GPR_ASSERT(0 == grpc_msg_decompress(&exec_ctx, GRPC_MESSAGE_COMPRESS_DEFLATE, &input,
&output));
grpc_exec_ctx_finish(&exec_ctx);
@ -229,7 +229,7 @@ static void test_bad_decompression_data_stream(void) {
/* try (and fail) to decompress the invalid compresed buffer */
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
GPR_ASSERT(0 == grpc_msg_decompress(&exec_ctx, GRPC_COMPRESS_DEFLATE, &input,
GPR_ASSERT(0 == grpc_msg_decompress(&exec_ctx, GRPC_MESSAGE_COMPRESS_DEFLATE, &input,
&output));
grpc_exec_ctx_finish(&exec_ctx);
@ -248,12 +248,12 @@ static void test_bad_compression_algorithm(void) {
&input, grpc_slice_from_copied_string("Never gonna give you up"));
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
was_compressed = grpc_msg_compress(&exec_ctx, GRPC_COMPRESS_ALGORITHMS_COUNT,
was_compressed = grpc_msg_compress(&exec_ctx, GRPC_MESSAGE_COMPRESS_ALGORITHMS_COUNT,
&input, &output);
GPR_ASSERT(0 == was_compressed);
was_compressed = grpc_msg_compress(
&exec_ctx, GRPC_COMPRESS_ALGORITHMS_COUNT + 123, &input, &output);
&exec_ctx, GRPC_MESSAGE_COMPRESS_ALGORITHMS_COUNT + 123, &input, &output);
GPR_ASSERT(0 == was_compressed);
grpc_exec_ctx_finish(&exec_ctx);
@ -273,11 +273,11 @@ static void test_bad_decompression_algorithm(void) {
"I'm not really compressed but it doesn't matter"));
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
was_decompressed = grpc_msg_decompress(
&exec_ctx, GRPC_COMPRESS_ALGORITHMS_COUNT, &input, &output);
&exec_ctx, GRPC_MESSAGE_COMPRESS_ALGORITHMS_COUNT, &input, &output);
GPR_ASSERT(0 == was_decompressed);
was_decompressed = grpc_msg_decompress(
&exec_ctx, GRPC_COMPRESS_ALGORITHMS_COUNT + 123, &input, &output);
&exec_ctx, GRPC_MESSAGE_COMPRESS_ALGORITHMS_COUNT + 123, &input, &output);
GPR_ASSERT(0 == was_decompressed);
grpc_exec_ctx_finish(&exec_ctx);
@ -296,7 +296,7 @@ int main(int argc, char **argv) {
grpc_test_init(argc, argv);
grpc_init();
for (i = 0; i < GRPC_COMPRESS_ALGORITHMS_COUNT; i++) {
for (i = 0; i < GRPC_MESSAGE_COMPRESS_ALGORITHMS_COUNT; i++) {
for (j = 0; j < GPR_ARRAY_SIZE(uncompressed_split_modes); j++) {
for (k = 0; k < GPR_ARRAY_SIZE(compressed_split_modes); k++) {
for (m = 0; m < TEST_VALUE_COUNT; m++) {

4
test/core/end2end/fixtures/h2_compress.c
Unescape View File

@ -69,7 +69,7 @@ void chttp2_init_client_fullstack_compression(grpc_end2end_test_fixture *f,
grpc_exec_ctx_finish(&exec_ctx);
}
ffd->client_args_compression = grpc_channel_args_set_compression_algorithm(
client_args, GRPC_COMPRESS_GZIP);
client_args, GRPC_COMPRESS_MESSAGE_GZIP);
f->client = grpc_insecure_channel_create(ffd->localaddr,
ffd->client_args_compression, NULL);
}
@ -83,7 +83,7 @@ void chttp2_init_server_fullstack_compression(grpc_end2end_test_fixture *f,
grpc_exec_ctx_finish(&exec_ctx);
}
ffd->server_args_compression = grpc_channel_args_set_compression_algorithm(
server_args, GRPC_COMPRESS_GZIP);
server_args, GRPC_COMPRESS_MESSAGE_GZIP);
if (f->server) {
grpc_server_destroy(f->server);
}

3
test/core/end2end/fuzzers/hpack.dictionary
Unescape View File

@ -28,6 +28,9 @@
"\x1Egrpc.max_request_message_bytes"
"\x1Fgrpc.max_response_message_bytes"
"$/grpc.lb.v1.LoadBalancer/BalanceLoad"
"\x0Fmessage/deflate"
"\x0Cmessage/gzip"
"\x0Bstream/gzip"
"\x010"
"\x011"
"\x012"

37
test/core/end2end/tests/compressed_payload.c
Unescape View File

@ -384,9 +384,9 @@ static void request_with_payload_template(
GPR_ASSERT(GPR_BITGET(grpc_call_test_only_get_encodings_accepted_by_peer(s),
GRPC_COMPRESS_NONE) != 0);
GPR_ASSERT(GPR_BITGET(grpc_call_test_only_get_encodings_accepted_by_peer(s),
GRPC_COMPRESS_DEFLATE) != 0);
GRPC_COMPRESS_MESSAGE_DEFLATE) != 0);
GPR_ASSERT(GPR_BITGET(grpc_call_test_only_get_encodings_accepted_by_peer(s),
GRPC_COMPRESS_GZIP) != 0);
GRPC_COMPRESS_MESSAGE_GZIP) != 0);
memset(ops, 0, sizeof(ops));
op = ops;
@ -549,8 +549,9 @@ static void test_invoke_request_with_exceptionally_uncompressed_payload(
grpc_end2end_test_config config) {
request_with_payload_template(
config, "test_invoke_request_with_exceptionally_uncompressed_payload",
GRPC_WRITE_NO_COMPRESS, GRPC_COMPRESS_GZIP, GRPC_COMPRESS_GZIP,
GRPC_COMPRESS_NONE, GRPC_COMPRESS_GZIP, NULL, false,
GRPC_WRITE_NO_COMPRESS, GRPC_COMPRESS_MESSAGE_GZIP,
GRPC_COMPRESS_MESSAGE_GZIP, GRPC_COMPRESS_NONE,
GRPC_COMPRESS_MESSAGE_GZIP, NULL, false,
/* ignored */ GRPC_COMPRESS_LEVEL_NONE, false);
}
@ -567,18 +568,18 @@ static void test_invoke_request_with_compressed_payload(
grpc_end2end_test_config config) {
request_with_payload_template(
config, "test_invoke_request_with_compressed_payload", 0,
GRPC_COMPRESS_GZIP, GRPC_COMPRESS_GZIP, GRPC_COMPRESS_GZIP,
GRPC_COMPRESS_GZIP, NULL, false, /* ignored */ GRPC_COMPRESS_LEVEL_NONE,
false);
GRPC_COMPRESS_MESSAGE_GZIP, GRPC_COMPRESS_MESSAGE_GZIP,
GRPC_COMPRESS_MESSAGE_GZIP, GRPC_COMPRESS_MESSAGE_GZIP, NULL, false,
/* ignored */ GRPC_COMPRESS_LEVEL_NONE, false);
}
static void test_invoke_request_with_send_message_before_initial_metadata(
grpc_end2end_test_config config) {
request_with_payload_template(
config, "test_invoke_request_with_compressed_payload", 0,
GRPC_COMPRESS_GZIP, GRPC_COMPRESS_GZIP, GRPC_COMPRESS_GZIP,
GRPC_COMPRESS_GZIP, NULL, false, /* ignored */ GRPC_COMPRESS_LEVEL_NONE,
true);
GRPC_COMPRESS_MESSAGE_GZIP, GRPC_COMPRESS_MESSAGE_GZIP,
GRPC_COMPRESS_MESSAGE_GZIP, GRPC_COMPRESS_MESSAGE_GZIP, NULL, false,
/* ignored */ GRPC_COMPRESS_LEVEL_NONE, true);
}
static void test_invoke_request_with_server_level(
@ -586,7 +587,7 @@ static void test_invoke_request_with_server_level(
request_with_payload_template(
config, "test_invoke_request_with_server_level", 0, GRPC_COMPRESS_NONE,
GRPC_COMPRESS_NONE, GRPC_COMPRESS_NONE, GRPC_COMPRESS_NONE /* ignored */,
NULL, true, GRPC_COMPRESS_LEVEL_HIGH, false);
NULL, true, GRPC_COMPRESS_LEVEL_MESSAGE_HIGH, false);
}
static void test_invoke_request_with_compressed_payload_md_override(
@ -595,7 +596,7 @@ static void test_invoke_request_with_compressed_payload_md_override(
grpc_metadata identity_compression_override;
gzip_compression_override.key = GRPC_MDSTR_GRPC_INTERNAL_ENCODING_REQUEST;
gzip_compression_override.value = grpc_slice_from_static_string("gzip");
gzip_compression_override.value = grpc_slice_from_static_string("message/gzip");
memset(&gzip_compression_override.internal_data, 0,
sizeof(gzip_compression_override.internal_data));
@ -608,21 +609,22 @@ static void test_invoke_request_with_compressed_payload_md_override(
/* Channel default NONE (aka IDENTITY), call override to GZIP */
request_with_payload_template(
config, "test_invoke_request_with_compressed_payload_md_override_1", 0,
GRPC_COMPRESS_NONE, GRPC_COMPRESS_NONE, GRPC_COMPRESS_GZIP,
GRPC_COMPRESS_NONE, GRPC_COMPRESS_NONE, GRPC_COMPRESS_MESSAGE_GZIP,
GRPC_COMPRESS_NONE, &gzip_compression_override, false,
/*ignored*/ GRPC_COMPRESS_LEVEL_NONE, false);
/* Channel default DEFLATE, call override to GZIP */
request_with_payload_template(
config, "test_invoke_request_with_compressed_payload_md_override_2", 0,
GRPC_COMPRESS_DEFLATE, GRPC_COMPRESS_NONE, GRPC_COMPRESS_GZIP,
GRPC_COMPRESS_NONE, &gzip_compression_override, false,
GRPC_COMPRESS_MESSAGE_DEFLATE, GRPC_COMPRESS_NONE,
GRPC_COMPRESS_MESSAGE_GZIP, GRPC_COMPRESS_NONE,
&gzip_compression_override, false,
/*ignored*/ GRPC_COMPRESS_LEVEL_NONE, false);
/* Channel default DEFLATE, call override to NONE (aka IDENTITY) */
request_with_payload_template(
config, "test_invoke_request_with_compressed_payload_md_override_3", 0,
GRPC_COMPRESS_DEFLATE, GRPC_COMPRESS_NONE, GRPC_COMPRESS_NONE,
GRPC_COMPRESS_MESSAGE_DEFLATE, GRPC_COMPRESS_NONE, GRPC_COMPRESS_NONE,
GRPC_COMPRESS_NONE, &identity_compression_override, false,
/*ignored*/ GRPC_COMPRESS_LEVEL_NONE, false);
}
@ -631,7 +633,8 @@ static void test_invoke_request_with_disabled_algorithm(
grpc_end2end_test_config config) {
request_for_disabled_algorithm(
config, "test_invoke_request_with_disabled_algorithm", 0,
GRPC_COMPRESS_GZIP, GRPC_COMPRESS_GZIP, GRPC_STATUS_UNIMPLEMENTED, NULL);
GRPC_COMPRESS_MESSAGE_GZIP, GRPC_COMPRESS_MESSAGE_GZIP,
GRPC_STATUS_UNIMPLEMENTED, NULL);
}
void compressed_payload(grpc_end2end_test_config config) {

104
test/core/end2end/tests/stream_compression_compressed_payload.c
Unescape View File

@ -95,8 +95,8 @@ static void end_test(grpc_end2end_test_fixture *f) {
static void request_for_disabled_algorithm(
grpc_end2end_test_config config, const char *test_name,
uint32_t send_flags_bitmask,
grpc_stream_compression_algorithm algorithm_to_disable,
grpc_stream_compression_algorithm requested_client_compression_algorithm,
grpc_compression_algorithm algorithm_to_disable,
grpc_compression_algorithm requested_client_compression_algorithm,
grpc_status_code expected_error, grpc_metadata *client_metadata) {
grpc_call *c;
grpc_call *s;
@ -124,13 +124,13 @@ static void request_for_disabled_algorithm(
request_payload_slice = grpc_slice_from_copied_string(str);
request_payload = grpc_raw_byte_buffer_create(&request_payload_slice, 1);
client_args = grpc_channel_args_set_stream_compression_algorithm(
client_args = grpc_channel_args_set_compression_algorithm(
NULL, requested_client_compression_algorithm);
server_args = grpc_channel_args_set_stream_compression_algorithm(
NULL, GRPC_STREAM_COMPRESS_NONE);
server_args =
grpc_channel_args_set_compression_algorithm(NULL, GRPC_COMPRESS_NONE);
{
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
server_args = grpc_channel_args_stream_compression_algorithm_set_state(
server_args = grpc_channel_args_compression_algorithm_set_state(
&exec_ctx, &server_args, algorithm_to_disable, false);
grpc_exec_ctx_finish(&exec_ctx);
}
@ -229,11 +229,10 @@ static void request_for_disabled_algorithm(
GPR_ASSERT(status == expected_error);
char *algo_name = NULL;
GPR_ASSERT(
grpc_stream_compression_algorithm_name(algorithm_to_disable, &algo_name));
GPR_ASSERT(grpc_compression_algorithm_name(algorithm_to_disable, &algo_name));
char *expected_details = NULL;
gpr_asprintf(&expected_details,
"Stream compression algorithm '%s' is disabled.", algo_name);
"Compression algorithm '%s' is disabled.", algo_name);
/* and we expect a specific reason for it */
GPR_ASSERT(0 == grpc_slice_str_cmp(details, expected_details));
gpr_free(expected_details);
@ -270,14 +269,12 @@ static void request_for_disabled_algorithm(
static void request_with_payload_template(
grpc_end2end_test_config config, const char *test_name,
uint32_t client_send_flags_bitmask,
grpc_stream_compression_algorithm
default_client_channel_compression_algorithm,
grpc_stream_compression_algorithm
default_server_channel_compression_algorithm,
grpc_stream_compression_algorithm expected_client_compression_algorithm,
grpc_stream_compression_algorithm expected_server_compression_algorithm,
grpc_compression_algorithm default_client_channel_compression_algorithm,
grpc_compression_algorithm default_server_channel_compression_algorithm,
grpc_compression_algorithm expected_client_compression_algorithm,
grpc_compression_algorithm expected_server_compression_algorithm,
grpc_metadata *client_init_metadata, bool set_server_level,
grpc_stream_compression_level server_compression_level,
grpc_compression_level server_compression_level,
bool send_message_before_initial_metadata,
bool set_default_server_message_compression_algorithm,
grpc_compression_algorithm default_server_message_compression_algorithm) {
@ -315,13 +312,13 @@ static void request_with_payload_template(
grpc_slice response_payload_slice =
grpc_slice_from_copied_string(response_str);
client_args = grpc_channel_args_set_stream_compression_algorithm(
client_args = grpc_channel_args_set_compression_algorithm(
NULL, default_client_channel_compression_algorithm);
if (set_default_server_message_compression_algorithm) {
server_args = grpc_channel_args_set_compression_algorithm(
NULL, default_server_message_compression_algorithm);
} else {
server_args = grpc_channel_args_set_stream_compression_algorithm(
server_args = grpc_channel_args_set_compression_algorithm(
NULL, default_server_channel_compression_algorithm);
}
@ -394,26 +391,21 @@ static void request_with_payload_template(
GPR_ASSERT(GPR_BITGET(grpc_call_test_only_get_encodings_accepted_by_peer(s),
GRPC_COMPRESS_NONE) != 0);
GPR_ASSERT(GPR_BITGET(grpc_call_test_only_get_encodings_accepted_by_peer(s),
GRPC_COMPRESS_DEFLATE) != 0);
GRPC_COMPRESS_MESSAGE_DEFLATE) != 0);
GPR_ASSERT(GPR_BITGET(grpc_call_test_only_get_encodings_accepted_by_peer(s),
GRPC_COMPRESS_MESSAGE_GZIP) != 0);
GPR_ASSERT(GPR_BITGET(grpc_call_test_only_get_encodings_accepted_by_peer(s),
GRPC_COMPRESS_GZIP) != 0);
GPR_ASSERT(
GPR_BITCOUNT(grpc_call_test_only_get_stream_encodings_accepted_by_peer(
s)) == GRPC_STREAM_COMPRESS_ALGORITHMS_COUNT);
GPR_ASSERT(
GPR_BITGET(grpc_call_test_only_get_stream_encodings_accepted_by_peer(s),
GRPC_STREAM_COMPRESS_NONE) != 0);
GPR_ASSERT(
GPR_BITGET(grpc_call_test_only_get_stream_encodings_accepted_by_peer(s),
GRPC_STREAM_COMPRESS_GZIP) != 0);
GRPC_COMPRESS_STREAM_GZIP) != 0);
GPR_ASSERT(GPR_BITCOUNT(grpc_call_test_only_get_encodings_accepted_by_peer(
s)) == GRPC_COMPRESS_ALGORITHMS_COUNT);
memset(ops, 0, sizeof(ops));
op = ops;
op->op = GRPC_OP_SEND_INITIAL_METADATA;
op->data.send_initial_metadata.count = 0;
if (set_server_level) {
op->data.send_initial_metadata.maybe_stream_compression_level.is_set = true;
op->data.send_initial_metadata.maybe_stream_compression_level.level =
op->data.send_initial_metadata.maybe_compression_level.is_set = true;
op->data.send_initial_metadata.maybe_compression_level.level =
server_compression_level;
}
op->flags = 0;
@ -557,29 +549,28 @@ static void test_invoke_request_with_compressed_payload(
grpc_end2end_test_config config) {
request_with_payload_template(
config, "test_invoke_request_with_compressed_payload", 0,
GRPC_STREAM_COMPRESS_GZIP, GRPC_STREAM_COMPRESS_GZIP,
GRPC_STREAM_COMPRESS_GZIP, GRPC_STREAM_COMPRESS_GZIP, NULL,
GRPC_COMPRESS_STREAM_GZIP, GRPC_COMPRESS_STREAM_GZIP,
GRPC_COMPRESS_STREAM_GZIP, GRPC_COMPRESS_STREAM_GZIP, NULL,
false, /* ignored */
GRPC_STREAM_COMPRESS_LEVEL_NONE, false, false, GRPC_COMPRESS_NONE);
GRPC_COMPRESS_LEVEL_NONE, false, false, GRPC_COMPRESS_NONE);
}
static void test_invoke_request_with_send_message_before_initial_metadata(
grpc_end2end_test_config config) {
request_with_payload_template(
config, "test_invoke_request_with_send_message_before_initial_metadata",
0, GRPC_STREAM_COMPRESS_GZIP, GRPC_STREAM_COMPRESS_GZIP,
GRPC_STREAM_COMPRESS_GZIP, GRPC_STREAM_COMPRESS_GZIP, NULL,
0, GRPC_COMPRESS_STREAM_GZIP, GRPC_COMPRESS_STREAM_GZIP,
GRPC_COMPRESS_STREAM_GZIP, GRPC_COMPRESS_STREAM_GZIP, NULL,
false, /* ignored */
GRPC_STREAM_COMPRESS_LEVEL_NONE, true, false, GRPC_COMPRESS_NONE);
GRPC_COMPRESS_LEVEL_NONE, true, false, GRPC_COMPRESS_NONE);
}
static void test_invoke_request_with_server_level(
grpc_end2end_test_config config) {
request_with_payload_template(
config, "test_invoke_request_with_server_level", 0,
GRPC_STREAM_COMPRESS_NONE, GRPC_STREAM_COMPRESS_NONE,
GRPC_STREAM_COMPRESS_NONE, GRPC_STREAM_COMPRESS_GZIP,
/* ignored */ NULL, true, GRPC_STREAM_COMPRESS_LEVEL_HIGH, false, false,
config, "test_invoke_request_with_server_level", 0, GRPC_COMPRESS_NONE,
GRPC_COMPRESS_NONE, GRPC_COMPRESS_NONE, GRPC_COMPRESS_STREAM_GZIP,
/* ignored */ NULL, true, GRPC_COMPRESS_LEVEL_STREAM_HIGH, false, false,
GRPC_COMPRESS_NONE);
}
@ -590,7 +581,7 @@ static void test_invoke_request_with_compressed_payload_md_override(
gzip_compression_override.key =
GRPC_MDSTR_GRPC_INTERNAL_STREAM_ENCODING_REQUEST;
gzip_compression_override.value = grpc_slice_from_static_string("gzip");
gzip_compression_override.value = grpc_slice_from_static_string("stream/gzip");
memset(&gzip_compression_override.internal_data, 0,
sizeof(gzip_compression_override.internal_data));
@ -604,40 +595,35 @@ static void test_invoke_request_with_compressed_payload_md_override(
/* Channel default NONE (aka IDENTITY), call override to stream GZIP */
request_with_payload_template(
config, "test_invoke_request_with_compressed_payload_md_override_1", 0,
GRPC_STREAM_COMPRESS_NONE, GRPC_STREAM_COMPRESS_NONE,
GRPC_STREAM_COMPRESS_GZIP, GRPC_STREAM_COMPRESS_NONE,
&gzip_compression_override, false,
/*ignored*/ GRPC_STREAM_COMPRESS_LEVEL_NONE, false, false,
GRPC_COMPRESS_NONE);
GRPC_COMPRESS_NONE, GRPC_COMPRESS_NONE, GRPC_COMPRESS_STREAM_GZIP,
GRPC_COMPRESS_NONE, &gzip_compression_override, false,
/*ignored*/ GRPC_COMPRESS_LEVEL_NONE, false, false, GRPC_COMPRESS_NONE);
/* Channel default stream GZIP, call override to NONE (aka IDENTITY) */
request_with_payload_template(
config, "test_invoke_request_with_compressed_payload_md_override_3", 0,
GRPC_STREAM_COMPRESS_GZIP, GRPC_STREAM_COMPRESS_NONE,
GRPC_STREAM_COMPRESS_NONE, GRPC_STREAM_COMPRESS_NONE,
&identity_compression_override, false,
/*ignored*/ GRPC_STREAM_COMPRESS_LEVEL_NONE, false, false,
GRPC_COMPRESS_NONE);
GRPC_COMPRESS_STREAM_GZIP, GRPC_COMPRESS_NONE, GRPC_COMPRESS_NONE,
GRPC_COMPRESS_NONE, &identity_compression_override, false,
/*ignored*/ GRPC_COMPRESS_LEVEL_NONE, false, false, GRPC_COMPRESS_NONE);
}
static void test_invoke_request_with_disabled_algorithm(
grpc_end2end_test_config config) {
request_for_disabled_algorithm(
config, "test_invoke_request_with_disabled_algorithm", 0,
GRPC_STREAM_COMPRESS_GZIP, GRPC_STREAM_COMPRESS_GZIP,
GRPC_COMPRESS_STREAM_GZIP, GRPC_COMPRESS_STREAM_GZIP,
GRPC_STATUS_UNIMPLEMENTED, NULL);
}
static void test_stream_compression_override_message_compression(
grpc_end2end_test_config config) {
grpc_stream_compression_level level = GRPC_STREAM_COMPRESS_LEVEL_MED;
grpc_compression_level level = GRPC_COMPRESS_LEVEL_STREAM_MED;
request_with_payload_template(
config, "test_stream_compression_override_message_compression", 0,
GRPC_STREAM_COMPRESS_NONE, GRPC_STREAM_COMPRESS_NONE,
GRPC_STREAM_COMPRESS_NONE,
grpc_stream_compression_algorithm_for_level(
level, (1u << GRPC_STREAM_COMPRESS_ALGORITHMS_COUNT) - 1),
/* ignored */ NULL, true, level, false, true, GRPC_COMPRESS_GZIP);
GRPC_COMPRESS_NONE, GRPC_COMPRESS_NONE, GRPC_COMPRESS_NONE,
grpc_compression_algorithm_for_level(
level, (1u << GRPC_COMPRESS_ALGORITHMS_COUNT) - 1),
/* ignored */ NULL, true, level, false, true, GRPC_COMPRESS_MESSAGE_GZIP);
}
void stream_compression_compressed_payload(grpc_end2end_test_config config) {

10
test/core/end2end/tests/stream_compression_payload.c
Unescape View File

@ -265,12 +265,10 @@ static void request_response_with_payload(grpc_end2end_test_config config,
payload and status. */
static void test_invoke_request_response_with_payload(
grpc_end2end_test_config config) {
grpc_channel_args *client_args =
grpc_channel_args_set_stream_compression_algorithm(
NULL, GRPC_STREAM_COMPRESS_GZIP);
grpc_channel_args *server_args =
grpc_channel_args_set_stream_compression_algorithm(
NULL, GRPC_STREAM_COMPRESS_GZIP);
grpc_channel_args *client_args = grpc_channel_args_set_compression_algorithm(
NULL, GRPC_COMPRESS_STREAM_GZIP);
grpc_channel_args *server_args = grpc_channel_args_set_compression_algorithm(
NULL, GRPC_COMPRESS_STREAM_GZIP);
grpc_end2end_test_fixture f =
begin_test(config, "test_invoke_request_response_with_payload",
client_args, server_args);

10
test/core/end2end/tests/stream_compression_ping_pong_streaming.c
Unescape View File

@ -90,12 +90,10 @@ static void end_test(grpc_end2end_test_fixture *f) {
/* Client pings and server pongs. Repeat messages rounds before finishing. */
static void test_pingpong_streaming(grpc_end2end_test_config config,
int messages) {
grpc_channel_args *client_args =
grpc_channel_args_set_stream_compression_algorithm(
NULL, GRPC_STREAM_COMPRESS_GZIP);
grpc_channel_args *server_args =
grpc_channel_args_set_stream_compression_algorithm(
NULL, GRPC_STREAM_COMPRESS_GZIP);
grpc_channel_args *client_args = grpc_channel_args_set_compression_algorithm(
NULL, GRPC_COMPRESS_STREAM_GZIP);
grpc_channel_args *server_args = grpc_channel_args_set_compression_algorithm(
NULL, GRPC_COMPRESS_STREAM_GZIP);
grpc_end2end_test_fixture f =
begin_test(config, "test_pingpong_streaming", client_args, server_args);
grpc_call *c;

13
test/core/end2end/tests/workaround_cronet_compression.c
Unescape View File

@ -208,9 +208,9 @@ static void request_with_payload_template(
GPR_ASSERT(GPR_BITGET(grpc_call_test_only_get_encodings_accepted_by_peer(s),
GRPC_COMPRESS_NONE) != 0);
GPR_ASSERT(GPR_BITGET(grpc_call_test_only_get_encodings_accepted_by_peer(s),
GRPC_COMPRESS_DEFLATE) != 0);
GRPC_COMPRESS_MESSAGE_DEFLATE) != 0);
GPR_ASSERT(GPR_BITGET(grpc_call_test_only_get_encodings_accepted_by_peer(s),
GRPC_COMPRESS_GZIP) != 0);
GRPC_COMPRESS_MESSAGE_GZIP) != 0);
memset(ops, 0, sizeof(ops));
op = ops;
@ -365,13 +365,13 @@ typedef struct workaround_cronet_compression_config {
} workaround_cronet_compression_config;
static workaround_cronet_compression_config workaround_configs[] = {
{NULL, GRPC_COMPRESS_GZIP},
{NULL, GRPC_COMPRESS_MESSAGE_GZIP},
{"grpc-objc/1.3.0-dev grpc-c/3.0.0-dev (ios; cronet_http; gentle)",
GRPC_COMPRESS_NONE},
{"grpc-objc/1.3.0-dev grpc-c/3.0.0-dev (ios; chttp2; gentle)",
GRPC_COMPRESS_GZIP},
GRPC_COMPRESS_MESSAGE_GZIP},
{"grpc-objc/1.4.0 grpc-c/3.0.0-dev (ios; cronet_http; gentle)",
GRPC_COMPRESS_GZIP}};
GRPC_COMPRESS_MESSAGE_GZIP}};
static const size_t workaround_configs_num =
sizeof(workaround_configs) / sizeof(*workaround_configs);
@ -380,7 +380,8 @@ static void test_workaround_cronet_compression(
for (uint32_t i = 0; i < workaround_configs_num; i++) {
request_with_payload_template(
config, "test_invoke_request_with_compressed_payload", 0,
GRPC_COMPRESS_GZIP, GRPC_COMPRESS_GZIP, GRPC_COMPRESS_GZIP,
GRPC_COMPRESS_MESSAGE_GZIP, GRPC_COMPRESS_MESSAGE_GZIP,
GRPC_COMPRESS_MESSAGE_GZIP,
workaround_configs[i].expected_algorithm_from_server, NULL, false,
/* ignored */ GRPC_COMPRESS_LEVEL_NONE,
workaround_configs[i].user_agent_override);

8
test/core/surface/byte_buffer_reader_test.c
Unescape View File

@ -109,7 +109,7 @@ static void test_read_corrupted_slice(void) {
LOG_TEST("test_read_corrupted_slice");
slice = grpc_slice_from_copied_string("test");
buffer = grpc_raw_byte_buffer_create(&slice, 1);
buffer->data.raw.compression = GRPC_COMPRESS_GZIP; /* lies! */
buffer->data.raw.compression = GRPC_COMPRESS_MESSAGE_GZIP; /* lies! */
grpc_slice_unref(slice);
GPR_ASSERT(!grpc_byte_buffer_reader_init(&reader, buffer));
grpc_byte_buffer_destroy(buffer);
@ -134,7 +134,7 @@ static void read_compressed_slice(grpc_compression_algorithm algorithm,
{
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
GPR_ASSERT(
grpc_msg_compress(&exec_ctx, algorithm, &sliceb_in, &sliceb_out));
grpc_msg_compress(&exec_ctx, grpc_compression_algorithm_to_message_compression_algorithm(algorithm), &sliceb_in, &sliceb_out));
grpc_exec_ctx_finish(&exec_ctx);
}
@ -160,13 +160,13 @@ static void read_compressed_slice(grpc_compression_algorithm algorithm,
static void test_read_gzip_compressed_slice(void) {
const size_t INPUT_SIZE = 2048;
LOG_TEST("test_read_gzip_compressed_slice");
read_compressed_slice(GRPC_COMPRESS_GZIP, INPUT_SIZE);
read_compressed_slice(GRPC_COMPRESS_MESSAGE_GZIP, INPUT_SIZE);
}
static void test_read_deflate_compressed_slice(void) {
const size_t INPUT_SIZE = 2048;
LOG_TEST("test_read_deflate_compressed_slice");
read_compressed_slice(GRPC_COMPRESS_DEFLATE, INPUT_SIZE);
read_compressed_slice(GRPC_COMPRESS_MESSAGE_DEFLATE, INPUT_SIZE);
}
static void test_byte_buffer_from_reader(void) {

4
tools/codegen/core/gen_static_metadata.py
Unescape View File

@ -53,6 +53,10 @@ CONFIG = [
'grpc.max_response_message_bytes',
# well known method names
'/grpc.lb.v1.LoadBalancer/BalanceLoad',
# compression algorithm names
'message/deflate',
'message/gzip',
'stream/gzip',
# metadata elements
('grpc-status', '0'),
('grpc-status', '1'),

Write Preview
Loading…
Cancel
Save