grpc 1.9.1 → 1.10.0.pre1

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

@@ -0,0 +1,274 @@
+/*
+ *
+ * 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 "src/core/lib/compression/algorithm_metadata.h"
+#include "src/core/lib/compression/compression_internal.h"
+#include "src/core/lib/gpr/useful.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_algorithm
+grpc_compression_algorithm_to_message_compression_algorithm(
+    grpc_compression_algorithm algo) {
+  switch (algo) {
+    case GRPC_COMPRESS_DEFLATE:
+      return GRPC_MESSAGE_COMPRESS_DEFLATE;
+    case GRPC_COMPRESS_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_DEFLATE;
+        return 1;
+      case GRPC_MESSAGE_COMPRESS_GZIP:
+        *algorithm = GRPC_COMPRESS_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, const 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_compression_level level, uint32_t accepted_encodings) {
+  GRPC_API_TRACE("grpc_message_compression_algorithm_for_level(level=%d)", 1,
+                 ((int)level));
+  if (level > GRPC_COMPRESS_LEVEL_HIGH) {
+    gpr_log(GPR_ERROR, "Unknown message compression level %d.",
+            static_cast<int>(level));
+    abort();
+  }
+
+  const size_t num_supported =
+      GPR_BITCOUNT(accepted_encodings) - 1; /* discard NONE */
+  if (level == GRPC_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_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();
+  };
+}
+
+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. */
+
+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;
+}

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

@@ -0,0 +1,86 @@
+/*
+ *
+ * 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>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+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;
+
+/* Interfaces performing transformation between compression algorithms and
+ * levels. */
+
+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, const char** name);
+
+grpc_message_compression_algorithm grpc_message_compression_algorithm_for_level(
+    grpc_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. */
+
+int grpc_stream_compression_algorithm_parse(
+    grpc_slice value, grpc_stream_compression_algorithm* algorithm);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GRPC_CORE_LIB_COMPRESSION_COMPRESSION_INTERNAL_H */

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

@@ -36,23 +36,23 @@ static int zlib_body(z_stream* zs, grpc_slice_buffer* input,
   int flush;
   size_t i;
   grpc_slice outbuf = GRPC_SLICE_MALLOC(OUTPUT_BLOCK_SIZE);
-  const uInt uint_max = ~(uInt)0;
+  const uInt uint_max = ~static_cast<uInt>(0);
 
   GPR_ASSERT(GRPC_SLICE_LENGTH(outbuf) <= uint_max);
-  zs->avail_out = (uInt)GRPC_SLICE_LENGTH(outbuf);
+  zs->avail_out = static_cast<uInt> GRPC_SLICE_LENGTH(outbuf);
   zs->next_out = GRPC_SLICE_START_PTR(outbuf);
   flush = Z_NO_FLUSH;
   for (i = 0; i < input->count; i++) {
     if (i == input->count - 1) flush = Z_FINISH;
     GPR_ASSERT(GRPC_SLICE_LENGTH(input->slices[i]) <= uint_max);
-    zs->avail_in = (uInt)GRPC_SLICE_LENGTH(input->slices[i]);
+    zs->avail_in = static_cast<uInt> GRPC_SLICE_LENGTH(input->slices[i]);
     zs->next_in = GRPC_SLICE_START_PTR(input->slices[i]);
     do {
       if (zs->avail_out == 0) {
         grpc_slice_buffer_add_indexed(output, outbuf);
         outbuf = GRPC_SLICE_MALLOC(OUTPUT_BLOCK_SIZE);
         GPR_ASSERT(GRPC_SLICE_LENGTH(outbuf) <= uint_max);
-        zs->avail_out = (uInt)GRPC_SLICE_LENGTH(outbuf);
+        zs->avail_out = static_cast<uInt> GRPC_SLICE_LENGTH(outbuf);
         zs->next_out = GRPC_SLICE_START_PTR(outbuf);
       }
       r = flate(zs, flush);
@@ -141,25 +141,25 @@ static int copy(grpc_slice_buffer* input, grpc_slice_buffer* output) {
   return 1;
 }
 
-static int compress_inner(grpc_compression_algorithm algorithm,
+static int compress_inner(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(input, output, 0);
-    case GRPC_COMPRESS_GZIP:
+    case GRPC_MESSAGE_COMPRESS_GZIP:
       return zlib_compress(input, output, 1);
-    case GRPC_COMPRESS_ALGORITHMS_COUNT:
+    case GRPC_MESSAGE_COMPRESS_ALGORITHMS_COUNT:
       break;
   }
   gpr_log(GPR_ERROR, "invalid compression algorithm %d", algorithm);
   return 0;
 }
 
-int grpc_msg_compress(grpc_compression_algorithm algorithm,
+int grpc_msg_compress(grpc_message_compression_algorithm algorithm,
                       grpc_slice_buffer* input, grpc_slice_buffer* output) {
   if (!compress_inner(algorithm, input, output)) {
     copy(input, output);
@@ -168,16 +168,16 @@ int grpc_msg_compress(grpc_compression_algorithm algorithm,
   return 1;
 }
 
-int grpc_msg_decompress(grpc_compression_algorithm algorithm,
+int grpc_msg_decompress(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(input, output, 0);
-    case GRPC_COMPRESS_GZIP:
+    case GRPC_MESSAGE_COMPRESS_GZIP:
       return zlib_decompress(input, output, 1);
-    case GRPC_COMPRESS_ALGORITHMS_COUNT:
+    case GRPC_MESSAGE_COMPRESS_ALGORITHMS_COUNT:
       break;
   }
   gpr_log(GPR_ERROR, "invalid compression algorithm %d", algorithm);

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

@@ -19,19 +19,20 @@
 #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_compression_algorithm algorithm,
+int grpc_msg_compress(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_compression_algorithm algorithm,
+int grpc_msg_decompress(grpc_message_compression_algorithm algorithm,
                         grpc_slice_buffer* input, grpc_slice_buffer* output);
 
 #endif /* GRPC_CORE_LIB_COMPRESSION_MESSAGE_COMPRESS_H */