grpc 1.47.0-x86_64-linux → 1.49.0.pre1-x86_64-linux

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

@@ -1,103 +0,0 @@
-// Copyright 2021 gRPC authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/slice/slice_split.h"
-
-#include <stddef.h>
-#include <stdint.h>
-#include <string.h>
-
-#include <grpc/slice_buffer.h>
-#include <grpc/support/log.h>
-
-/** Finds the initial (\a begin) and final (\a end) offsets of the next
- * substring from \a str + \a read_offset until the next \a sep or the end of \a
- * str.
- *
- * Returns 1 and updates \a begin and \a end. Returns 0 otherwise. */
-static int slice_find_separator_offset(const grpc_slice str, const char* sep,
-                                       const size_t read_offset, size_t* begin,
-                                       size_t* end) {
-  size_t i;
-  const uint8_t* str_ptr = GRPC_SLICE_START_PTR(str) + read_offset;
-  const size_t str_len = GRPC_SLICE_LENGTH(str) - read_offset;
-  const size_t sep_len = strlen(sep);
-  if (str_len < sep_len) {
-    return 0;
-  }
-
-  for (i = 0; i <= str_len - sep_len; i++) {
-    if (memcmp(str_ptr + i, sep, sep_len) == 0) {
-      *begin = read_offset;
-      *end = read_offset + i;
-      return 1;
-    }
-  }
-  return 0;
-}
-
-static void skip_leading_trailing_spaces(const uint8_t* str_buffer,
-                                         size_t* begin, size_t* end) {
-  while (*begin < *end && str_buffer[*begin] == ' ') {
-    (*begin)++;
-  }
-  while (*begin < *end && str_buffer[*end - 1] == ' ') {
-    (*end)--;
-  }
-}
-
-static void grpc_slice_split_inner(grpc_slice str, const char* sep,
-                                   grpc_slice_buffer* dst, bool no_space) {
-  const size_t sep_len = strlen(sep);
-  size_t begin, end;
-  const uint8_t* str_buffer = GRPC_SLICE_START_PTR(str);
-  size_t sep_pos;
-
-  GPR_ASSERT(sep_len > 0);
-
-  if (slice_find_separator_offset(str, sep, 0, &begin, &end) != 0) {
-    do {
-      sep_pos = end;
-      if (no_space) {
-        skip_leading_trailing_spaces(str_buffer, &begin, &end);
-      }
-      grpc_slice_buffer_add_indexed(dst, grpc_slice_sub(str, begin, end));
-    } while (slice_find_separator_offset(str, sep, sep_pos + sep_len, &begin,
-                                         &end) != 0);
-    begin = sep_pos + sep_len;
-    end = GRPC_SLICE_LENGTH(str);
-    if (no_space) {
-      skip_leading_trailing_spaces(str_buffer, &begin, &end);
-    }
-    grpc_slice_buffer_add_indexed(dst, grpc_slice_sub(str, begin, end));
-  } else { /* no sep found, add whole input */
-    begin = 0;
-    end = GRPC_SLICE_LENGTH(str);
-    if (no_space) {
-      skip_leading_trailing_spaces(str_buffer, &begin, &end);
-    }
-    grpc_slice_buffer_add_indexed(dst, grpc_slice_sub(str, begin, end));
-  }
-}
-
-void grpc_slice_split(grpc_slice str, const char* sep, grpc_slice_buffer* dst) {
-  grpc_slice_split_inner(str, sep, dst, false);
-}
-
-void grpc_slice_split_without_space(grpc_slice str, const char* sep,
-                                    grpc_slice_buffer* dst) {
-  grpc_slice_split_inner(str, sep, dst, true);
-}

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

@@ -1,36 +0,0 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#ifndef GRPC_CORE_LIB_SLICE_SLICE_SPLIT_H
-#define GRPC_CORE_LIB_SLICE_SLICE_SPLIT_H
-
-#include <grpc/support/port_platform.h>
-
-#include <grpc/slice.h>
-
-/** Split \a str by the separator \a sep. Results are stored in \a dst, which
- * should be a properly initialized instance. */
-void grpc_slice_split(grpc_slice str, const char* sep, grpc_slice_buffer* dst);
-
-/** Split \a str by the separator \a sep and remove the leading and trailing
- * spaces of each resulting token. Results are stored in \a dst, which should be
- * a properly initialized instance. */
-void grpc_slice_split_without_space(grpc_slice str, const char* sep,
-                                    grpc_slice_buffer* dst);
-
-#endif /* GRPC_CORE_LIB_SLICE_SLICE_SPLIT_H */

data/src/core/lib/transport/byte_stream.cc

@@ -1,165 +0,0 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/transport/byte_stream.h"
-
-#include <memory>
-#include <utility>
-
-#include <grpc/slice_buffer.h>
-#include <grpc/support/log.h>
-
-#include "src/core/lib/slice/slice_internal.h"
-#include "src/core/lib/slice/slice_refcount.h"
-
-namespace grpc_core {
-
-//
-// SliceBufferByteStream
-//
-
-SliceBufferByteStream::SliceBufferByteStream(grpc_slice_buffer* slice_buffer,
-                                             uint32_t flags)
-    : ByteStream(static_cast<uint32_t>(slice_buffer->length), flags) {
-  GPR_ASSERT(slice_buffer->length <= UINT32_MAX);
-  grpc_slice_buffer_init(&backing_buffer_);
-  grpc_slice_buffer_swap(slice_buffer, &backing_buffer_);
-  if (backing_buffer_.count == 0) {
-    grpc_slice_buffer_add_indexed(&backing_buffer_, grpc_empty_slice());
-    GPR_ASSERT(backing_buffer_.count > 0);
-  }
-}
-
-SliceBufferByteStream::~SliceBufferByteStream() {}
-
-void SliceBufferByteStream::Orphan() {
-  grpc_slice_buffer_destroy_internal(&backing_buffer_);
-  GRPC_ERROR_UNREF(shutdown_error_);
-  shutdown_error_ = GRPC_ERROR_NONE;
-  // Note: We do not actually delete the object here, since
-  // SliceBufferByteStream is usually allocated as part of a larger
-  // object and has an OrphanablePtr of itself passed down through the
-  // filter stack.
-}
-
-bool SliceBufferByteStream::Next(size_t /*max_size_hint*/,
-                                 grpc_closure* /*on_complete*/) {
-  GPR_DEBUG_ASSERT(backing_buffer_.count > 0);
-  return true;
-}
-
-grpc_error_handle SliceBufferByteStream::Pull(grpc_slice* slice) {
-  if (GPR_UNLIKELY(shutdown_error_ != GRPC_ERROR_NONE)) {
-    return GRPC_ERROR_REF(shutdown_error_);
-  }
-  *slice = grpc_slice_buffer_take_first(&backing_buffer_);
-  return GRPC_ERROR_NONE;
-}
-
-void SliceBufferByteStream::Shutdown(grpc_error_handle error) {
-  GRPC_ERROR_UNREF(shutdown_error_);
-  shutdown_error_ = error;
-}
-
-//
-// ByteStreamCache
-//
-
-ByteStreamCache::ByteStreamCache(OrphanablePtr<ByteStream> underlying_stream)
-    : underlying_stream_(std::move(underlying_stream)),
-      length_(underlying_stream_->length()),
-      flags_(underlying_stream_->flags()) {
-  grpc_slice_buffer_init(&cache_buffer_);
-}
-
-ByteStreamCache::~ByteStreamCache() { Destroy(); }
-
-void ByteStreamCache::Destroy() {
-  underlying_stream_.reset();
-  if (cache_buffer_.length > 0) {
-    grpc_slice_buffer_destroy_internal(&cache_buffer_);
-  }
-}
-
-//
-// ByteStreamCache::CachingByteStream
-//
-
-ByteStreamCache::CachingByteStream::CachingByteStream(ByteStreamCache* cache)
-    : ByteStream(cache->length_, cache->flags_), cache_(cache) {}
-
-ByteStreamCache::CachingByteStream::~CachingByteStream() {}
-
-void ByteStreamCache::CachingByteStream::Orphan() {
-  GRPC_ERROR_UNREF(shutdown_error_);
-  shutdown_error_ = GRPC_ERROR_NONE;
-  // Note: We do not actually delete the object here, since
-  // CachingByteStream is usually allocated as part of a larger
-  // object and has an OrphanablePtr of itself passed down through the
-  // filter stack.
-}
-
-bool ByteStreamCache::CachingByteStream::Next(size_t max_size_hint,
-                                              grpc_closure* on_complete) {
-  if (shutdown_error_ != GRPC_ERROR_NONE) return true;
-  if (cursor_ < cache_->cache_buffer_.count) return true;
-  GPR_ASSERT(cache_->underlying_stream_ != nullptr);
-  return cache_->underlying_stream_->Next(max_size_hint, on_complete);
-}
-
-grpc_error_handle ByteStreamCache::CachingByteStream::Pull(grpc_slice* slice) {
-  if (shutdown_error_ != GRPC_ERROR_NONE) {
-    return GRPC_ERROR_REF(shutdown_error_);
-  }
-  if (cursor_ < cache_->cache_buffer_.count) {
-    *slice = grpc_slice_ref_internal(cache_->cache_buffer_.slices[cursor_]);
-    ++cursor_;
-    offset_ += GRPC_SLICE_LENGTH(*slice);
-    return GRPC_ERROR_NONE;
-  }
-  GPR_ASSERT(cache_->underlying_stream_ != nullptr);
-  grpc_error_handle error = cache_->underlying_stream_->Pull(slice);
-  if (error == GRPC_ERROR_NONE) {
-    grpc_slice_buffer_add(&cache_->cache_buffer_,
-                          grpc_slice_ref_internal(*slice));
-    ++cursor_;
-    offset_ += GRPC_SLICE_LENGTH(*slice);
-    // Orphan the underlying stream if it's been drained.
-    if (offset_ == cache_->underlying_stream_->length()) {
-      cache_->underlying_stream_.reset();
-    }
-  }
-  return error;
-}
-
-void ByteStreamCache::CachingByteStream::Shutdown(grpc_error_handle error) {
-  GRPC_ERROR_UNREF(shutdown_error_);
-  shutdown_error_ = GRPC_ERROR_REF(error);
-  if (cache_->underlying_stream_ != nullptr) {
-    cache_->underlying_stream_->Shutdown(error);
-  }
-}
-
-void ByteStreamCache::CachingByteStream::Reset() {
-  cursor_ = 0;
-  offset_ = 0;
-}
-
-}  // namespace grpc_core

data/src/core/lib/transport/byte_stream.h

@@ -1,170 +0,0 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#ifndef GRPC_CORE_LIB_TRANSPORT_BYTE_STREAM_H
-#define GRPC_CORE_LIB_TRANSPORT_BYTE_STREAM_H
-
-#include <grpc/support/port_platform.h>
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <grpc/slice.h>
-
-#include "src/core/lib/gprpp/orphanable.h"
-#include "src/core/lib/iomgr/closure.h"
-#include "src/core/lib/iomgr/error.h"
-
-/** Internal bit flag for grpc_begin_message's \a flags signaling the use of
- * compression for the message. (Does not apply for stream compression.) */
-#define GRPC_WRITE_INTERNAL_COMPRESS (0x80000000u)
-/** Internal bit flag for determining whether the message was compressed and had
- * to be decompressed by the message_decompress filter. (Does not apply for
- * stream compression.) */
-#define GRPC_WRITE_INTERNAL_TEST_ONLY_WAS_COMPRESSED (0x40000000u)
-/** Mask of all valid internal flags. */
-#define GRPC_WRITE_INTERNAL_USED_MASK \
-  (GRPC_WRITE_INTERNAL_COMPRESS | GRPC_WRITE_INTERNAL_TEST_ONLY_WAS_COMPRESSED)
-
-namespace grpc_core {
-
-class ByteStream : public Orphanable {
- public:
-  ~ByteStream() override {}
-
-  // Returns true if the bytes are available immediately (in which case
-  // on_complete will not be called), or false if the bytes will be available
-  // asynchronously (in which case on_complete will be called when they
-  // are available). Should not be called if there is no data left on the
-  // stream.
-  //
-  // max_size_hint can be set as a hint as to the maximum number
-  // of bytes that would be acceptable to read.
-  virtual bool Next(size_t max_size_hint, grpc_closure* on_complete) = 0;
-
-  // Returns the next slice in the byte stream when it is available, as
-  // indicated by Next().
-  //
-  // Once a slice is returned into *slice, it is owned by the caller.
-  virtual grpc_error_handle Pull(grpc_slice* slice) = 0;
-
-  // Shuts down the byte stream.
-  //
-  // If there is a pending call to on_complete from Next(), it will be
-  // invoked with the error passed to Shutdown().
-  //
-  // The next call to Pull() (if any) will return the error passed to
-  // Shutdown().
-  virtual void Shutdown(grpc_error_handle error) = 0;
-
-  uint32_t length() const { return length_; }
-  uint32_t flags() const { return flags_; }
-
-  void set_flags(uint32_t flags) { flags_ = flags; }
-
- protected:
-  ByteStream(uint32_t length, uint32_t flags)
-      : length_(length), flags_(flags) {}
-
- private:
-  const uint32_t length_;
-  uint32_t flags_;
-};
-
-//
-// SliceBufferByteStream
-//
-// A ByteStream that wraps a slice buffer.
-//
-
-class SliceBufferByteStream : public ByteStream {
- public:
-  // Removes all slices in slice_buffer, leaving it empty.
-  SliceBufferByteStream(grpc_slice_buffer* slice_buffer, uint32_t flags);
-
-  ~SliceBufferByteStream() override;
-
-  void Orphan() override;
-
-  bool Next(size_t max_size_hint, grpc_closure* on_complete) override;
-  grpc_error_handle Pull(grpc_slice* slice) override;
-  void Shutdown(grpc_error_handle error) override;
-
- private:
-  grpc_error_handle shutdown_error_ = GRPC_ERROR_NONE;
-  grpc_slice_buffer backing_buffer_;
-};
-
-//
-// CachingByteStream
-//
-// A ByteStream that that wraps an underlying byte stream but caches
-// the resulting slices in a slice buffer.  If an initial attempt fails
-// without fully draining the underlying stream, a new caching stream
-// can be created from the same underlying cache, in which case it will
-// return whatever is in the backing buffer before continuing to read the
-// underlying stream.
-//
-// NOTE: No synchronization is done, so it is not safe to have multiple
-// CachingByteStreams simultaneously drawing from the same underlying
-// ByteStreamCache at the same time.
-//
-
-class ByteStreamCache {
- public:
-  class CachingByteStream : public ByteStream {
-   public:
-    explicit CachingByteStream(ByteStreamCache* cache);
-
-    ~CachingByteStream() override;
-
-    void Orphan() override;
-
-    bool Next(size_t max_size_hint, grpc_closure* on_complete) override;
-    grpc_error_handle Pull(grpc_slice* slice) override;
-    void Shutdown(grpc_error_handle error) override;
-
-    // Resets the byte stream to the start of the underlying stream.
-    void Reset();
-
-   private:
-    ByteStreamCache* cache_;
-    size_t cursor_ = 0;
-    size_t offset_ = 0;
-    grpc_error_handle shutdown_error_ = GRPC_ERROR_NONE;
-  };
-
-  explicit ByteStreamCache(OrphanablePtr<ByteStream> underlying_stream);
-
-  ~ByteStreamCache();
-
-  // Must not be destroyed while still in use by a CachingByteStream.
-  void Destroy();
-
-  grpc_slice_buffer* cache_buffer() { return &cache_buffer_; }
-
- private:
-  OrphanablePtr<ByteStream> underlying_stream_;
-  uint32_t length_;
-  uint32_t flags_;
-  grpc_slice_buffer cache_buffer_;
-};
-
-}  // namespace grpc_core
-
-#endif /* GRPC_CORE_LIB_TRANSPORT_BYTE_STREAM_H */

data/third_party/abseil-cpp/absl/cleanup/cleanup.h

@@ -1,140 +0,0 @@
-// Copyright 2021 The Abseil 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
-//
-//      https://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.
-//
-// -----------------------------------------------------------------------------
-// File: cleanup.h
-// -----------------------------------------------------------------------------
-//
-// `absl::Cleanup` implements the scope guard idiom, invoking the contained
-// callback's `operator()() &&` on scope exit.
-//
-// Example:
-//
-// ```
-//   absl::Status CopyGoodData(const char* source_path, const char* sink_path) {
-//     FILE* source_file = fopen(source_path, "r");
-//     if (source_file == nullptr) {
-//       return absl::NotFoundError("No source file");  // No cleanups execute
-//     }
-//
-//     // C++17 style cleanup using class template argument deduction
-//     absl::Cleanup source_closer = [source_file] { fclose(source_file); };
-//
-//     FILE* sink_file = fopen(sink_path, "w");
-//     if (sink_file == nullptr) {
-//       return absl::NotFoundError("No sink file");  // First cleanup executes
-//     }
-//
-//     // C++11 style cleanup using the factory function
-//     auto sink_closer = absl::MakeCleanup([sink_file] { fclose(sink_file); });
-//
-//     Data data;
-//     while (ReadData(source_file, &data)) {
-//       if (!data.IsGood()) {
-//         absl::Status result = absl::FailedPreconditionError("Read bad data");
-//         return result;  // Both cleanups execute
-//       }
-//       SaveData(sink_file, &data);
-//     }
-//
-//     return absl::OkStatus();  // Both cleanups execute
-//   }
-// ```
-//
-// Methods:
-//
-// `std::move(cleanup).Cancel()` will prevent the callback from executing.
-//
-// `std::move(cleanup).Invoke()` will execute the callback early, before
-// destruction, and prevent the callback from executing in the destructor.
-//
-// Usage:
-//
-// `absl::Cleanup` is not an interface type. It is only intended to be used
-// within the body of a function. It is not a value type and instead models a
-// control flow construct. Check out `defer` in Golang for something similar.
-
-#ifndef ABSL_CLEANUP_CLEANUP_H_
-#define ABSL_CLEANUP_CLEANUP_H_
-
-#include <utility>
-
-#include "absl/base/config.h"
-#include "absl/base/macros.h"
-#include "absl/cleanup/internal/cleanup.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-template <typename Arg, typename Callback = void()>
-class ABSL_MUST_USE_RESULT Cleanup final {
-  static_assert(cleanup_internal::WasDeduced<Arg>(),
-                "Explicit template parameters are not supported.");
-
-  static_assert(cleanup_internal::ReturnsVoid<Callback>(),
-                "Callbacks that return values are not supported.");
-
- public:
-  Cleanup(Callback callback) : storage_(std::move(callback)) {}  // NOLINT
-
-  Cleanup(Cleanup&& other) = default;
-
-  void Cancel() && {
-    ABSL_HARDENING_ASSERT(storage_.IsCallbackEngaged());
-    storage_.DestroyCallback();
-  }
-
-  void Invoke() && {
-    ABSL_HARDENING_ASSERT(storage_.IsCallbackEngaged());
-    storage_.InvokeCallback();
-    storage_.DestroyCallback();
-  }
-
-  ~Cleanup() {
-    if (storage_.IsCallbackEngaged()) {
-      storage_.InvokeCallback();
-      storage_.DestroyCallback();
-    }
-  }
-
- private:
-  cleanup_internal::Storage<Callback> storage_;
-};
-
-// `absl::Cleanup c = /* callback */;`
-//
-// C++17 type deduction API for creating an instance of `absl::Cleanup`
-#if defined(ABSL_HAVE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION)
-template <typename Callback>
-Cleanup(Callback callback) -> Cleanup<cleanup_internal::Tag, Callback>;
-#endif  // defined(ABSL_HAVE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION)
-
-// `auto c = absl::MakeCleanup(/* callback */);`
-//
-// C++11 type deduction API for creating an instance of `absl::Cleanup`
-template <typename... Args, typename Callback>
-absl::Cleanup<cleanup_internal::Tag, Callback> MakeCleanup(Callback callback) {
-  static_assert(cleanup_internal::WasDeduced<cleanup_internal::Tag, Args...>(),
-                "Explicit template parameters are not supported.");
-
-  static_assert(cleanup_internal::ReturnsVoid<Callback>(),
-                "Callbacks that return values are not supported.");
-
-  return {std::move(callback)};
-}
-
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_CLEANUP_CLEANUP_H_