Script 'mail_helper' called by obssrc Hello community, here is the log from the commit of package python-grpcio-tools for openSUSE:Factory checked in at 2022-09-05 21:22:11 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/python-grpcio-tools (Old) and /work/SRC/openSUSE:Factory/.python-grpcio-tools.new.2083 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "python-grpcio-tools" Mon Sep 5 21:22:11 2022 rev:17 rq:1001241 version:1.48.0 Changes: -------- --- /work/SRC/openSUSE:Factory/python-grpcio-tools/python-grpcio-tools.changes 2022-06-23 10:25:29.719819851 +0200 +++ /work/SRC/openSUSE:Factory/.python-grpcio-tools.new.2083/python-grpcio-tools.changes 2022-09-05 21:22:16.985177623 +0200 @@ -1,0 +2,9 @@ +Thu Sep 1 03:49:58 UTC 2022 - Atri Bhattacharya <badshah...@gmail.com> + +- Update to version 1.48.0: + * [Aio] Ensure Core channel closes when deallocated + [gh#grpc/grpc#29797]. + * [Aio] Fix the wait_for_termination return value + [gh#grpc/grpc#29795]. + +------------------------------------------------------------------- Old: ---- grpcio-tools-1.46.3.tar.gz New: ---- grpcio-tools-1.48.0.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ python-grpcio-tools.spec ++++++ --- /var/tmp/diff_new_pack.tAx1rg/_old 2022-09-05 21:22:17.517179028 +0200 +++ /var/tmp/diff_new_pack.tAx1rg/_new 2022-09-05 21:22:17.525179049 +0200 @@ -20,7 +20,7 @@ %define skip_python2 1 Name: python-grpcio-tools -Version: 1.46.3 +Version: 1.48.0 Release: 0 Summary: Protobuf code generator for gRPC License: Apache-2.0 ++++++ grpcio-tools-1.46.3.tar.gz -> grpcio-tools-1.48.0.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/grpcio-tools-1.46.3/PKG-INFO new/grpcio-tools-1.48.0/PKG-INFO --- old/grpcio-tools-1.46.3/PKG-INFO 2022-05-20 11:08:33.375335500 +0200 +++ new/grpcio-tools-1.48.0/PKG-INFO 2022-07-19 03:23:18.280794000 +0200 @@ -1,6 +1,6 @@ Metadata-Version: 1.2 Name: grpcio-tools -Version: 1.46.3 +Version: 1.48.0 Summary: Protobuf code generator for gRPC Home-page: https://grpc.io Author: The gRPC Authors diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/grpcio-tools-1.46.3/grpc_root/include/grpc/compression.h new/grpcio-tools-1.48.0/grpc_root/include/grpc/compression.h --- old/grpcio-tools-1.46.3/grpc_root/include/grpc/compression.h 2022-05-20 11:08:19.000000000 +0200 +++ new/grpcio-tools-1.48.0/grpc_root/include/grpc/compression.h 2022-07-19 03:22:48.000000000 +0200 @@ -23,7 +23,7 @@ #include <stdlib.h> -#include <grpc/impl/codegen/compression_types.h> +#include <grpc/impl/codegen/compression_types.h> // IWYU pragma: export #include <grpc/slice.h> #ifdef __cplusplus diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/grpcio-tools-1.46.3/grpc_root/include/grpc/event_engine/event_engine.h new/grpcio-tools-1.48.0/grpc_root/include/grpc/event_engine/event_engine.h --- old/grpcio-tools-1.46.3/grpc_root/include/grpc/event_engine/event_engine.h 2022-05-20 11:08:19.000000000 +0200 +++ new/grpcio-tools-1.48.0/grpc_root/include/grpc/event_engine/event_engine.h 2022-07-19 03:22:48.000000000 +0200 @@ -21,13 +21,13 @@ #include "absl/status/status.h" #include "absl/status/statusor.h" -#include "absl/time/time.h" #include <grpc/event_engine/endpoint_config.h> #include <grpc/event_engine/memory_allocator.h> #include <grpc/event_engine/port.h> +#include <grpc/event_engine/slice_buffer.h> -// TODO(hork): Define the Endpoint::Write metrics collection system +// TODO(vigneshbabu): Define the Endpoint::Write metrics collection system namespace grpc_event_engine { namespace experimental { @@ -73,6 +73,11 @@ //////////////////////////////////////////////////////////////////////////////// class EventEngine { public: + /// A duration between two events. + /// + /// Throughout the EventEngine API durations are used to express how long + /// until an action should be performed. + using Duration = std::chrono::duration<int64_t, std::nano>; /// A custom closure type for EventEngine task execution. /// /// Throughout the EventEngine API, \a Closure ownership is retained by the @@ -138,6 +143,18 @@ /// Shuts down all connections and invokes all pending read or write /// callbacks with an error status. virtual ~Endpoint() = default; + /// A struct representing optional arguments that may be provided to an + /// EventEngine Endpoint Read API call. + /// + /// Passed as argument to an Endpoint \a Read + struct ReadArgs { + // A suggestion to the endpoint implementation to read at-least the + // specified number of bytes over the network connection before marking + // the endpoint read operation as complete. gRPC may use this argument + // to minimize the number of endpoint read API calls over the lifetime + // of a connection. + int64_t read_hint_bytes; + }; /// Reads data from the Endpoint. /// /// When data is available on the connection, that data is moved into the @@ -156,7 +173,21 @@ /// statuses to \a on_read. For example, callbacks might expect to receive /// CANCELLED on endpoint shutdown. virtual void Read(std::function<void(absl::Status)> on_read, - SliceBuffer* buffer) = 0; + SliceBuffer* buffer, const ReadArgs* args) = 0; + /// A struct representing optional arguments that may be provided to an + /// EventEngine Endpoint Write API call. + /// + /// Passed as argument to an Endpoint \a Write + struct WriteArgs { + // Represents private information that may be passed by gRPC for + // select endpoints expected to be used only within google. + void* google_specific = nullptr; + // A suggestion to the endpoint implementation to group data to be written + // into frames of the specified max_frame_size. gRPC may use this + // argument to dynamically control the max sizes of frames sent to a + // receiver in response to high receiver memory pressure. + int64_t max_frame_size; + }; /// Writes data out on the connection. /// /// \a on_writable is called when the connection is ready for more data. The @@ -176,7 +207,7 @@ /// statuses to \a on_writable. For example, callbacks might expect to /// receive CANCELLED on endpoint shutdown. virtual void Write(std::function<void(absl::Status)> on_writable, - SliceBuffer* data) = 0; + SliceBuffer* data, const WriteArgs* args) = 0; /// Returns an address in the format described in DNSResolver. The returned /// values are expected to remain valid for the life of the Endpoint. virtual const ResolvedAddress& GetPeerAddress() const = 0; @@ -243,7 +274,7 @@ const ResolvedAddress& addr, const EndpointConfig& args, MemoryAllocator memory_allocator, - absl::Time deadline) = 0; + Duration timeout) = 0; /// Request cancellation of a connection attempt. /// @@ -259,7 +290,13 @@ public: /// Task handle for DNS Resolution requests. struct LookupTaskHandle { - intptr_t key[2]; + intptr_t keys[2]; + }; + /// Optional configuration for DNSResolvers. + struct ResolverOptions { + /// If empty, default DNS servers will be used. + /// Must be in the "IP:port" format as described in naming.md. + std::string dns_server; }; /// DNS SRV record type. struct SRVRecord { @@ -293,23 +330,23 @@ /// /// If cancelled, \a on_resolve will not be executed. virtual LookupTaskHandle LookupHostname(LookupHostnameCallback on_resolve, - absl::string_view address, + absl::string_view name, absl::string_view default_port, - absl::Time deadline) = 0; + Duration timeout) = 0; /// Asynchronously perform an SRV record lookup. /// /// \a on_resolve has the same meaning and expectations as \a /// LookupHostname's \a on_resolve callback. virtual LookupTaskHandle LookupSRV(LookupSRVCallback on_resolve, absl::string_view name, - absl::Time deadline) = 0; + Duration timeout) = 0; /// Asynchronously perform a TXT record lookup. /// /// \a on_resolve has the same meaning and expectations as \a /// LookupHostname's \a on_resolve callback. virtual LookupTaskHandle LookupTXT(LookupTXTCallback on_resolve, absl::string_view name, - absl::Time deadline) = 0; + Duration timeout) = 0; /// Cancel an asynchronous lookup operation. /// /// This shares the same semantics with \a EventEngine::Cancel: successfully @@ -331,8 +368,10 @@ // de-experimentalize this API. virtual bool IsWorkerThread() = 0; - /// Creates and returns an instance of a DNSResolver. - virtual std::unique_ptr<DNSResolver> GetDNSResolver() = 0; + /// Creates and returns an instance of a DNSResolver, optionally configured by + /// the \a options struct. + virtual std::unique_ptr<DNSResolver> GetDNSResolver( + const DNSResolver::ResolverOptions& options) = 0; /// Asynchronously executes a task as soon as possible. /// @@ -349,13 +388,13 @@ /// in some scenarios. This overload is useful in situations where performance /// is not a critical concern. virtual void Run(std::function<void()> closure) = 0; - /// Synonymous with scheduling an alarm to run at time \a when. + /// Synonymous with scheduling an alarm to run after duration \a when. /// /// The \a closure will execute when time \a when arrives unless it has been /// cancelled via the \a Cancel method. If cancelled, the closure will not be /// run, nor will it be deleted. Ownership remains with the caller. - virtual TaskHandle RunAt(absl::Time when, Closure* closure) = 0; - /// Synonymous with scheduling an alarm to run at time \a when. + virtual TaskHandle RunAfter(Duration when, Closure* closure) = 0; + /// Synonymous with scheduling an alarm to run after duration \a when. /// /// The \a closure will execute when time \a when arrives unless it has been /// cancelled via the \a Cancel method. If cancelled, the closure will not be @@ -363,10 +402,10 @@ /// version's \a closure will be deleted by the EventEngine after the closure /// has been run, or upon cancellation. /// - /// This version of \a RunAt may be less performant than the \a Closure + /// This version of \a RunAfter may be less performant than the \a Closure /// version in some scenarios. This overload is useful in situations where /// performance is not a critical concern. - virtual TaskHandle RunAt(absl::Time when, std::function<void()> closure) = 0; + virtual TaskHandle RunAfter(Duration when, std::function<void()> closure) = 0; /// Request cancellation of a task. /// /// If the associated closure has already been scheduled to run, it will not @@ -375,6 +414,11 @@ /// If the associated callback has not been scheduled to run, it will be /// cancelled, and the associated std::function or \a Closure* will not be /// executed. In this case, Cancel will return true. + /// + /// Implementation note: closures should be destroyed in a timely manner after + /// execution or cancelliation (milliseconds), since any state bound to the + /// closure may need to be destroyed for things to progress (e.g., if a + /// closure holds a ref to some ref-counted object). virtual bool Cancel(TaskHandle handle) = 0; }; @@ -388,7 +432,7 @@ /// created, applications must set a custom EventEngine factory method *before* /// grpc is initialized. void SetDefaultEventEngineFactory( - const std::function<std::unique_ptr<EventEngine>()>* factory); + std::function<std::unique_ptr<EventEngine>()> factory); /// Create an EventEngine using the default factory. std::unique_ptr<EventEngine> CreateEventEngine(); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/grpcio-tools-1.46.3/grpc_root/include/grpc/event_engine/memory_allocator.h new/grpcio-tools-1.48.0/grpc_root/include/grpc/event_engine/memory_allocator.h --- old/grpcio-tools-1.46.3/grpc_root/include/grpc/event_engine/memory_allocator.h 2022-05-20 11:08:19.000000000 +0200 +++ new/grpcio-tools-1.48.0/grpc_root/include/grpc/event_engine/memory_allocator.h 2022-07-19 03:22:48.000000000 +0200 @@ -26,24 +26,9 @@ #include <grpc/event_engine/internal/memory_allocator_impl.h> #include <grpc/slice.h> -// forward-declaring an internal struct, not used publicly. -struct grpc_slice_buffer; - namespace grpc_event_engine { namespace experimental { -// TODO(nnoble): needs implementation -class SliceBuffer { - public: - SliceBuffer() { abort(); } - explicit SliceBuffer(grpc_slice_buffer*) { abort(); } - - grpc_slice_buffer* RawSliceBuffer() { return slice_buffer_; } - - private: - grpc_slice_buffer* slice_buffer_; -}; - // Tracks memory allocated by one system. // Is effectively a thin wrapper/smart pointer for a MemoryAllocatorImpl, // providing a convenient and stable API. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/grpcio-tools-1.46.3/grpc_root/include/grpc/event_engine/port.h new/grpcio-tools-1.48.0/grpc_root/include/grpc/event_engine/port.h --- old/grpcio-tools-1.46.3/grpc_root/include/grpc/event_engine/port.h 2022-05-20 11:08:19.000000000 +0200 +++ new/grpcio-tools-1.48.0/grpc_root/include/grpc/event_engine/port.h 2022-07-19 03:22:48.000000000 +0200 @@ -20,7 +20,7 @@ #if defined(GPR_ANDROID) || defined(GPR_LINUX) || defined(GPR_APPLE) || \ defined(GPR_FREEBSD) || defined(GPR_OPENBSD) || defined(GPR_SOLARIS) || \ defined(GPR_AIX) || defined(GPR_NACL) || defined(GPR_FUCHSIA) || \ - defined(GRPC_POSIX_SOCKET) + defined(GRPC_POSIX_SOCKET) || defined(GPR_NETBSD) #define GRPC_EVENT_ENGINE_POSIX #include <arpa/inet.h> #include <netdb.h> diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/grpcio-tools-1.46.3/grpc_root/include/grpc/event_engine/slice.h new/grpcio-tools-1.48.0/grpc_root/include/grpc/event_engine/slice.h --- old/grpcio-tools-1.46.3/grpc_root/include/grpc/event_engine/slice.h 1970-01-01 01:00:00.000000000 +0100 +++ new/grpcio-tools-1.48.0/grpc_root/include/grpc/event_engine/slice.h 2022-07-19 03:22:48.000000000 +0200 @@ -0,0 +1,286 @@ +// Copyright 2022 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_EVENT_ENGINE_SLICE_H +#define GRPC_EVENT_ENGINE_SLICE_H + +#include <grpc/support/port_platform.h> + +#include <string.h> + +#include <cstdint> +#include <string> +#include <utility> + +#include "absl/strings/string_view.h" + +#include <grpc/slice.h> +#include <grpc/support/log.h> + +// This public slice definition largely based of the internal grpc_core::Slice +// implementation. Changes to this implementation might warrant changes to the +// internal grpc_core::Slice type as well. + +namespace grpc_event_engine { +namespace experimental { + +// Forward declarations +class Slice; +class MutableSlice; + +namespace slice_detail { + +// Returns an empty slice. +static constexpr grpc_slice EmptySlice() { return {nullptr, {}}; } + +// BaseSlice holds the grpc_slice object, but does not apply refcounting policy. +// It does export immutable access into the slice, such that this can be shared +// by all storage policies. +class BaseSlice { + public: + BaseSlice(const BaseSlice&) = delete; + BaseSlice& operator=(const BaseSlice&) = delete; + BaseSlice(BaseSlice&& other) = delete; + BaseSlice& operator=(BaseSlice&& other) = delete; + + // Iterator access to the underlying bytes + const uint8_t* begin() const { return GRPC_SLICE_START_PTR(c_slice()); } + const uint8_t* end() const { return GRPC_SLICE_END_PTR(c_slice()); } + const uint8_t* cbegin() const { return GRPC_SLICE_START_PTR(c_slice()); } + const uint8_t* cend() const { return GRPC_SLICE_END_PTR(c_slice()); } + + // Retrieve a borrowed reference to the underlying grpc_slice. + const grpc_slice& c_slice() const { return slice_; } + + // Retrieve the underlying grpc_slice, and replace the one in this object with + // EmptySlice(). + grpc_slice TakeCSlice() { + grpc_slice out = slice_; + slice_ = EmptySlice(); + return out; + } + + // As other things... borrowed references. + absl::string_view as_string_view() const { + return absl::string_view(reinterpret_cast<const char*>(data()), size()); + } + + // Array access + uint8_t operator[](size_t i) const { + return GRPC_SLICE_START_PTR(c_slice())[i]; + } + + // Access underlying data + const uint8_t* data() const { return GRPC_SLICE_START_PTR(c_slice()); } + + // Size of the slice + size_t size() const { return GRPC_SLICE_LENGTH(c_slice()); } + size_t length() const { return size(); } + bool empty() const { return size() == 0; } + + // For inlined slices - are these two slices equal? + // For non-inlined slices - do these two slices refer to the same block of + // memory? + bool is_equivalent(const BaseSlice& other) const { + return grpc_slice_is_equivalent(slice_, other.slice_); + } + + uint32_t Hash() const; + + protected: + BaseSlice() : slice_(EmptySlice()) {} + explicit BaseSlice(const grpc_slice& slice) : slice_(slice) {} + ~BaseSlice() = default; + + void Swap(BaseSlice* other) { std::swap(slice_, other->slice_); } + void SetCSlice(const grpc_slice& slice) { slice_ = slice; } + + uint8_t* mutable_data() { return GRPC_SLICE_START_PTR(slice_); } + + grpc_slice* c_slice_ptr() { return &slice_; } + + private: + grpc_slice slice_; +}; + +inline bool operator==(const BaseSlice& a, const BaseSlice& b) { + return grpc_slice_eq(a.c_slice(), b.c_slice()) != 0; +} + +inline bool operator!=(const BaseSlice& a, const BaseSlice& b) { + return grpc_slice_eq(a.c_slice(), b.c_slice()) == 0; +} + +inline bool operator==(const BaseSlice& a, absl::string_view b) { + return a.as_string_view() == b; +} + +inline bool operator!=(const BaseSlice& a, absl::string_view b) { + return a.as_string_view() != b; +} + +inline bool operator==(absl::string_view a, const BaseSlice& b) { + return a == b.as_string_view(); +} + +inline bool operator!=(absl::string_view a, const BaseSlice& b) { + return a != b.as_string_view(); +} + +inline bool operator==(const BaseSlice& a, const grpc_slice& b) { + return grpc_slice_eq(a.c_slice(), b) != 0; +} + +inline bool operator!=(const BaseSlice& a, const grpc_slice& b) { + return grpc_slice_eq(a.c_slice(), b) == 0; +} + +inline bool operator==(const grpc_slice& a, const BaseSlice& b) { + return grpc_slice_eq(a, b.c_slice()) != 0; +} + +inline bool operator!=(const grpc_slice& a, const BaseSlice& b) { + return grpc_slice_eq(a, b.c_slice()) == 0; +} + +template <typename Out> +struct CopyConstructors { + static Out FromCopiedString(const char* s) { + return FromCopiedBuffer(s, strlen(s)); + } + static Out FromCopiedString(absl::string_view s) { + return FromCopiedBuffer(s.data(), s.size()); + } + static Out FromCopiedString(std::string s); + + static Out FromCopiedBuffer(const char* p, size_t len) { + return Out(grpc_slice_from_copied_buffer(p, len)); + } + + template <typename Buffer> + static Out FromCopiedBuffer(const Buffer& buffer) { + return FromCopiedBuffer(reinterpret_cast<const char*>(buffer.data()), + buffer.size()); + } +}; + +} // namespace slice_detail + +class MutableSlice : public slice_detail::BaseSlice, + public slice_detail::CopyConstructors<MutableSlice> { + public: + MutableSlice() = default; + explicit MutableSlice(const grpc_slice& slice); + ~MutableSlice(); + + MutableSlice(const MutableSlice&) = delete; + MutableSlice& operator=(const MutableSlice&) = delete; + MutableSlice(MutableSlice&& other) noexcept + : slice_detail::BaseSlice(other.TakeCSlice()) {} + MutableSlice& operator=(MutableSlice&& other) noexcept { + Swap(&other); + return *this; + } + + static MutableSlice CreateUninitialized(size_t length) { + return MutableSlice(grpc_slice_malloc(length)); + } + + // Return a sub slice of this one. Leaves this slice in an indeterminate but + // valid state. + MutableSlice TakeSubSlice(size_t pos, size_t n) { + return MutableSlice(grpc_slice_sub_no_ref(TakeCSlice(), pos, pos + n)); + } + + // Iterator access to the underlying bytes + uint8_t* begin() { return mutable_data(); } + uint8_t* end() { return mutable_data() + size(); } + uint8_t* data() { return mutable_data(); } + + // Array access + uint8_t& operator[](size_t i) { return mutable_data()[i]; } +}; + +class Slice : public slice_detail::BaseSlice, + public slice_detail::CopyConstructors<Slice> { + public: + Slice() = default; + ~Slice(); + explicit Slice(const grpc_slice& slice) : slice_detail::BaseSlice(slice) {} + explicit Slice(slice_detail::BaseSlice&& other) + : slice_detail::BaseSlice(other.TakeCSlice()) {} + + Slice(const Slice&) = delete; + Slice& operator=(const Slice&) = delete; + Slice(Slice&& other) noexcept : slice_detail::BaseSlice(other.TakeCSlice()) {} + Slice& operator=(Slice&& other) noexcept { + Swap(&other); + return *this; + } + + // A slice might refer to some memory that we keep a refcount to (this is + // owned), or some memory that's inlined into the slice (also owned), or some + // other block of memory that we know will be available for the lifetime of + // some operation in the common case (not owned). In the *less common* case + // that we need to keep that slice text for longer than our API's guarantee us + // access, we need to take a copy and turn this into something that we do own. + + // TakeOwned returns an owned slice regardless of current ownership, and + // leaves the current slice in a valid but externally unpredictable state - in + // doing so it can avoid adding a ref to the underlying slice. + Slice TakeOwned(); + + // AsOwned returns an owned slice but does not mutate the current slice, + // meaning that it may add a reference to the underlying slice. + Slice AsOwned() const; + + // TakeMutable returns a MutableSlice, and leaves the current slice in an + // indeterminate but valid state. + // A mutable slice requires only one reference to the bytes of the slice - + // this can be achieved either with inlined storage or with a single + // reference. + // If the current slice is refcounted and there are more than one references + // to that slice, then the slice is copied in order to achieve a mutable + // version. + MutableSlice TakeMutable(); + + // Return a sub slice of this one. Leaves this slice in an indeterminate but + // valid state. + Slice TakeSubSlice(size_t pos, size_t n) { + return Slice(grpc_slice_sub_no_ref(TakeCSlice(), pos, pos + n)); + } + + // Return a sub slice of this one. Adds a reference to the underlying slice. + Slice RefSubSlice(size_t pos, size_t n) const { + return Slice(grpc_slice_sub(c_slice(), pos, pos + n)); + } + + // Split this slice, returning a new slice containing (split:end] and + // leaving this slice with [begin:split). + Slice Split(size_t split) { + return Slice(grpc_slice_split_tail(c_slice_ptr(), split)); + } + + Slice Ref() const; + + Slice Copy() const { return Slice(grpc_slice_copy(c_slice())); } + + static Slice FromRefcountAndBytes(grpc_slice_refcount* r, + const uint8_t* begin, const uint8_t* end); +}; + +} // namespace experimental +} // namespace grpc_event_engine + +#endif // GRPC_EVENT_ENGINE_SLICE_H diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/grpcio-tools-1.46.3/grpc_root/include/grpc/event_engine/slice_buffer.h new/grpcio-tools-1.48.0/grpc_root/include/grpc/event_engine/slice_buffer.h --- old/grpcio-tools-1.46.3/grpc_root/include/grpc/event_engine/slice_buffer.h 1970-01-01 01:00:00.000000000 +0100 +++ new/grpcio-tools-1.48.0/grpc_root/include/grpc/event_engine/slice_buffer.h 2022-07-19 03:22:48.000000000 +0200 @@ -0,0 +1,118 @@ +// Copyright 2022 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_EVENT_ENGINE_SLICE_BUFFER_H +#define GRPC_EVENT_ENGINE_SLICE_BUFFER_H + +#include <grpc/support/port_platform.h> + +#include <string.h> + +#include <cstdint> +#include <string> + +#include "absl/strings/string_view.h" +#include "absl/utility/utility.h" + +#include <grpc/event_engine/slice.h> +#include <grpc/slice.h> +#include <grpc/slice_buffer.h> +#include <grpc/support/log.h> + +namespace grpc_event_engine { +namespace experimental { + +/// A Wrapper around \a grpc_slice_buffer pointer. +/// +/// A slice buffer holds the memory for a collection of slices. +/// The SliceBuffer object itself is meant to only hide the C-style API, +/// and won't hold the data itself. In terms of lifespan, the +/// grpc_slice_buffer ought to be kept somewhere inside the caller's objects, +/// like a transport or an endpoint. +/// +/// This lifespan rule is likely to change in the future, as we may +/// collapse the grpc_slice_buffer structure straight into this class. +/// +/// The SliceBuffer API is basically a replica of the grpc_slice_buffer's, +/// and its documentation will move here once we remove the C structure, +/// which should happen before the Event Engine's API is no longer +/// an experimental API. +class SliceBuffer { + public: + explicit SliceBuffer() { grpc_slice_buffer_init(&slice_buffer_); } + SliceBuffer(const SliceBuffer& other) = delete; + SliceBuffer(SliceBuffer&& other) noexcept + : slice_buffer_(other.slice_buffer_) { + grpc_slice_buffer_init(&slice_buffer_); + grpc_slice_buffer_swap(&slice_buffer_, &other.slice_buffer_); + } + /// Upon destruction, the underlying raw slice buffer is cleaned out and all + /// slices are unreffed. + ~SliceBuffer() { grpc_slice_buffer_destroy(&slice_buffer_); } + + SliceBuffer& operator=(const SliceBuffer&) = delete; + SliceBuffer& operator=(SliceBuffer&& other) noexcept { + grpc_slice_buffer_swap(&slice_buffer_, &other.slice_buffer_); + return *this; + } + + /// Appends a new slice into the SliceBuffer and makes an attempt to merge + /// this slice with the last slice in the SliceBuffer. + void Append(Slice slice); + + /// Adds a new slice into the SliceBuffer at the next available index. + /// Returns the index at which the new slice is added. + size_t AppendIndexed(Slice slice); + + /// Returns the number of slices held by the SliceBuffer. + size_t Count() { return slice_buffer_.count; } + + /// Removes/deletes the last n bytes in the SliceBuffer. + void RemoveLastNBytes(size_t n) { + grpc_slice_buffer_trim_end(&slice_buffer_, n, nullptr); + } + + /// Move the first n bytes of the SliceBuffer into a memory pointed to by dst. + void MoveFirstNBytesIntoBuffer(size_t n, void* dst) { + grpc_slice_buffer_move_first_into_buffer(&slice_buffer_, n, dst); + } + + /// Removes and unrefs all slices in the SliceBuffer. + void Clear() { grpc_slice_buffer_reset_and_unref(&slice_buffer_); } + + /// Removes the first slice in the SliceBuffer and returns it. + Slice TakeFirst(); + + /// Prepends the slice to the the front of the SliceBuffer. + void Prepend(Slice slice); + + /// Increased the ref-count of slice at the specified index and returns the + /// associated slice. + Slice RefSlice(size_t index); + + /// The total number of bytes held by the SliceBuffer + size_t Length() { return slice_buffer_.length; } + + /// Return a pointer to the back raw grpc_slice_buffer + grpc_slice_buffer* c_slice_buffer() { return &slice_buffer_; } + + private: + /// The backing raw slice buffer. + grpc_slice_buffer slice_buffer_; +}; + +} // namespace experimental +} // namespace grpc_event_engine + +#endif // GRPC_EVENT_ENGINE_SLICE_BUFFER_H diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/grpcio-tools-1.46.3/grpc_root/include/grpc/grpc.h new/grpcio-tools-1.48.0/grpc_root/include/grpc/grpc.h --- old/grpcio-tools-1.46.3/grpc_root/include/grpc/grpc.h 2022-05-20 11:08:19.000000000 +0200 +++ new/grpcio-tools-1.48.0/grpc_root/include/grpc/grpc.h 2022-07-19 03:22:48.000000000 +0200 @@ -24,8 +24,8 @@ #include <stddef.h> #include <grpc/byte_buffer.h> -#include <grpc/impl/codegen/connectivity_state.h> -#include <grpc/impl/codegen/grpc_types.h> +#include <grpc/impl/codegen/connectivity_state.h> // IWYU pragma: export +#include <grpc/impl/codegen/grpc_types.h> // IWYU pragma: export #include <grpc/impl/codegen/propagation_bits.h> #include <grpc/slice.h> #include <grpc/status.h> @@ -542,7 +542,7 @@ /** EXPERIMENTAL. Dumps xDS configs as a serialized ClientConfig proto. The full name of the proto is envoy.service.status.v3.ClientConfig. */ -GRPCAPI grpc_slice grpc_dump_xds_configs(); +GRPCAPI grpc_slice grpc_dump_xds_configs(void); /** Fetch a vtable for a grpc_channel_arg that points to a grpc_resource_quota */ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/grpcio-tools-1.46.3/grpc_root/include/grpc/grpc_security.h new/grpcio-tools-1.48.0/grpc_root/include/grpc/grpc_security.h --- old/grpcio-tools-1.46.3/grpc_root/include/grpc/grpc_security.h 2022-05-20 11:08:19.000000000 +0200 +++ new/grpcio-tools-1.48.0/grpc_root/include/grpc/grpc_security.h 2022-07-19 03:22:48.000000000 +0200 @@ -1050,6 +1050,17 @@ /** * EXPERIMENTAL API - Subject to change * + * Factory function for an internal verifier that won't perform any + * post-handshake verification. Note: using this solely without any other + * authentication mechanisms on the peer identity will leave your applications + * to the MITM(Man-In-The-Middle) attacks. Users should avoid doing so in + * production environments. + */ +grpc_tls_certificate_verifier* grpc_tls_certificate_verifier_no_op_create(); + +/** + * EXPERIMENTAL API - Subject to change + * * Factory function for an internal verifier that will do the default hostname * check. */ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/grpcio-tools-1.46.3/grpc_root/include/grpc/impl/codegen/compression_types.h new/grpcio-tools-1.48.0/grpc_root/include/grpc/impl/codegen/compression_types.h --- old/grpcio-tools-1.46.3/grpc_root/include/grpc/impl/codegen/compression_types.h 2022-05-20 11:08:19.000000000 +0200 +++ new/grpcio-tools-1.48.0/grpc_root/include/grpc/impl/codegen/compression_types.h 2022-07-19 03:22:48.000000000 +0200 @@ -19,7 +19,8 @@ #ifndef GRPC_IMPL_CODEGEN_COMPRESSION_TYPES_H #define GRPC_IMPL_CODEGEN_COMPRESSION_TYPES_H -// IWYU pragma: private +// IWYU pragma: private, include <grpc/compression.h> +// IWYU pragma: friend "src/.*" #include <grpc/impl/codegen/port_platform.h> diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/grpcio-tools-1.46.3/grpc_root/include/grpc/impl/codegen/connectivity_state.h new/grpcio-tools-1.48.0/grpc_root/include/grpc/impl/codegen/connectivity_state.h --- old/grpcio-tools-1.46.3/grpc_root/include/grpc/impl/codegen/connectivity_state.h 2022-05-20 11:08:19.000000000 +0200 +++ new/grpcio-tools-1.48.0/grpc_root/include/grpc/impl/codegen/connectivity_state.h 2022-07-19 03:22:48.000000000 +0200 @@ -19,7 +19,8 @@ #ifndef GRPC_IMPL_CODEGEN_CONNECTIVITY_STATE_H #define GRPC_IMPL_CODEGEN_CONNECTIVITY_STATE_H -// IWYU pragma: private +// IWYU pragma: private, include <grpc/grpc.h> +// IWYU pragma: friend "src/.*" #ifdef __cplusplus extern "C" { diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/grpcio-tools-1.46.3/grpc_root/include/grpc/impl/codegen/gpr_types.h new/grpcio-tools-1.48.0/grpc_root/include/grpc/impl/codegen/gpr_types.h --- old/grpcio-tools-1.46.3/grpc_root/include/grpc/impl/codegen/gpr_types.h 2022-05-20 11:08:19.000000000 +0200 +++ new/grpcio-tools-1.48.0/grpc_root/include/grpc/impl/codegen/gpr_types.h 2022-07-19 03:22:48.000000000 +0200 @@ -19,7 +19,8 @@ #ifndef GRPC_IMPL_CODEGEN_GPR_TYPES_H #define GRPC_IMPL_CODEGEN_GPR_TYPES_H -// IWYU pragma: private +// IWYU pragma: private, include <grpc/grpc.h> +// IWYU pragma: friend "src/.*" #include <grpc/impl/codegen/port_platform.h> diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/grpcio-tools-1.46.3/grpc_root/include/grpc/impl/codegen/grpc_types.h new/grpcio-tools-1.48.0/grpc_root/include/grpc/impl/codegen/grpc_types.h --- old/grpcio-tools-1.46.3/grpc_root/include/grpc/impl/codegen/grpc_types.h 2022-05-20 11:08:19.000000000 +0200 +++ new/grpcio-tools-1.48.0/grpc_root/include/grpc/impl/codegen/grpc_types.h 2022-07-19 03:22:48.000000000 +0200 @@ -19,7 +19,8 @@ #ifndef GRPC_IMPL_CODEGEN_GRPC_TYPES_H #define GRPC_IMPL_CODEGEN_GRPC_TYPES_H -// IWYU pragma: private +// IWYU pragma: private, include <grpc/grpc.h> +// IWYU pragma: friend "src/.*" #include <grpc/impl/codegen/port_platform.h> diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/grpcio-tools-1.46.3/grpc_root/include/grpc/impl/codegen/port_platform.h new/grpcio-tools-1.48.0/grpc_root/include/grpc/impl/codegen/port_platform.h --- old/grpcio-tools-1.46.3/grpc_root/include/grpc/impl/codegen/port_platform.h 2022-05-20 11:08:19.000000000 +0200 +++ new/grpcio-tools-1.48.0/grpc_root/include/grpc/impl/codegen/port_platform.h 2022-07-19 03:22:48.000000000 +0200 @@ -49,10 +49,11 @@ #endif // GPR_ABSEIL_SYNC /* - * Defines GRPC_ERROR_IS_ABSEIL_STATUS to use absl::Status for grpc_error_handle + * Defines GRPC_ERROR_IS_NOT_ABSEIL_STATUS to not use absl::Status for + * grpc_error_handle. This is a temporary knob for migration process. */ -#ifndef GRPC_ERROR_IS_ABSEIL_STATUS -// #define GRPC_ERROR_IS_ABSEIL_STATUS 1 +#ifndef GRPC_ERROR_IS_NOT_ABSEIL_STATUS +#define GRPC_ERROR_IS_ABSEIL_STATUS 1 #endif /* Get windows.h included everywhere (we need it) */ @@ -207,6 +208,7 @@ #define GPR_CPU_POSIX 1 #define GPR_PLATFORM_STRING "asylo" #define GPR_GCC_SYNC 1 +#define GPR_POSIX_STAT 1 #define GPR_POSIX_SYNC 1 #define GPR_POSIX_STRING 1 #define GPR_POSIX_LOG 1 @@ -219,6 +221,8 @@ #define GRPC_TIMER_USE_GENERIC 1 #define GRPC_POSIX_NO_SPECIAL_WAKEUP_FD 1 #define GRPC_POSIX_WAKEUP_FD 1 +#define GRPC_HAVE_MSG_NOSIGNAL 1 +#define GRPC_HAVE_UNIX_SOCKET 1 #define GRPC_ARES 0 #define GPR_NO_AUTODETECT_PLATFORM 1 #elif defined(__APPLE__) @@ -352,6 +356,32 @@ #else /* _LP64 */ #define GPR_ARCH_32 1 #endif /* _LP64 */ +#elif defined(__NetBSD__) +// NetBSD is a community-supported platform. +// Please contact Thomas Klausner <w...@netbsd.org> for support. +#define GPR_PLATFORM_STRING "netbsd" +#ifndef _BSD_SOURCE +#define _BSD_SOURCE +#endif +#define GPR_NETBSD 1 +#define GPR_CPU_POSIX 1 +#define GPR_GCC_ATOMIC 1 +#define GPR_GCC_TLS 1 +#define GPR_POSIX_LOG 1 +#define GPR_POSIX_ENV 1 +#define GPR_POSIX_TMPFILE 1 +#define GPR_POSIX_STAT 1 +#define GPR_POSIX_STRING 1 +#define GPR_POSIX_SUBPROCESS 1 +#define GPR_POSIX_SYNC 1 +#define GPR_POSIX_TIME 1 +#define GPR_GETPID_IN_UNISTD_H 1 +#define GPR_SUPPORT_CHANNELS_FROM_FD 1 +#ifdef _LP64 +#define GPR_ARCH_64 1 +#else /* _LP64 */ +#define GPR_ARCH_32 1 +#endif /* _LP64 */ #elif defined(__native_client__) #define GPR_PLATFORM_STRING "nacl" #ifndef _BSD_SOURCE @@ -404,6 +434,32 @@ #define GPR_HAS_PTHREAD_H 1 #define GPR_GETPID_IN_UNISTD_H 1 #define GRPC_ROOT_PEM_PATH "/config/ssl/cert.pem" +#elif defined(__HAIKU__) +#define GPR_PLATFORM_STRING "haiku" +// Haiku is a community-supported platform. +// Please contact Jerome Duval <jerome.du...@gmail.com> for support. +#ifndef _BSD_SOURCE +#define _BSD_SOURCE +#endif +#define GPR_HAIKU 1 +#define GPR_CPU_POSIX 1 +#define GPR_GCC_ATOMIC 1 +#define GPR_POSIX_LOG 1 +#define GPR_POSIX_ENV 1 +#define GPR_POSIX_TMPFILE 1 +#define GPR_POSIX_STAT 1 +#define GPR_POSIX_STRING 1 +#define GPR_POSIX_SUBPROCESS 1 +#define GPR_POSIX_SYNC 1 +#define GPR_POSIX_TIME 1 +#define GPR_HAS_PTHREAD_H 1 +#define GPR_GETPID_IN_UNISTD_H 1 +#define GPR_SUPPORT_CHANNELS_FROM_FD 1 +#ifdef _LP64 +#define GPR_ARCH_64 1 +#else /* _LP64 */ +#define GPR_ARCH_32 1 +#endif /* _LP64 */ #else #error "Could not auto-detect platform" #endif @@ -528,6 +584,19 @@ #define GRPC_MUST_USE_RESULT #define GPR_ALIGN_STRUCT(n) #endif +#ifdef USE_STRICT_WARNING +/* When building with USE_STRICT_WARNING (which -Werror), types with this + attribute will be treated as annotated with warn_unused_result, enforcing + returned values of this type should be used. + This is added in grpc::Status in mind to address the issue where it always + has this annotation internally but OSS doesn't, sometimes causing internal + build failure. To prevent this, this is added while not introducing + a breaking change to existing user code which may not use returned values + of grpc::Status. */ +#define GRPC_MUST_USE_RESULT_WHEN_USE_STRICT_WARNING GRPC_MUST_USE_RESULT +#else +#define GRPC_MUST_USE_RESULT_WHEN_USE_STRICT_WARNING +#endif #endif #ifndef GRPC_UNUSED @@ -547,14 +616,43 @@ #endif #endif /* GPR_PRINT_FORMAT_CHECK */ +#ifndef GPR_HAS_CPP_ATTRIBUTE +#ifdef __has_cpp_attribute +#define GPR_HAS_CPP_ATTRIBUTE(a) __has_cpp_attribute(a) +#else +#define GPR_HAS_CPP_ATTRIBUTE(a) 0 +#endif +#endif /* GPR_HAS_CPP_ATTRIBUTE */ + +#ifndef GPR_HAS_ATTRIBUTE +#ifdef __has_attribute +#define GPR_HAS_ATTRIBUTE(a) __has_attribute(a) +#else +#define GPR_HAS_ATTRIBUTE(a) 0 +#endif +#endif /* GPR_HAS_ATTRIBUTE */ + +#if GPR_HAS_ATTRIBUTE(noreturn) +#define GPR_ATTRIBUTE_NORETURN __attribute__((noreturn)) +#else +#define GPR_ATTRIBUTE_NORETURN +#endif + #if GPR_FORBID_UNREACHABLE_CODE #define GPR_UNREACHABLE_CODE(STATEMENT) #else -#define GPR_UNREACHABLE_CODE(STATEMENT) \ - do { \ - gpr_log(GPR_ERROR, "Should never reach here."); \ - abort(); \ - STATEMENT; \ +#ifdef __cplusplus +extern "C" { +#endif +extern void gpr_unreachable_code(const char* reason, const char* file, + int line) GPR_ATTRIBUTE_NORETURN; +#ifdef __cplusplus +} +#endif +#define GPR_UNREACHABLE_CODE(STATEMENT) \ + do { \ + gpr_unreachable_code(#STATEMENT, __FILE__, __LINE__); \ + STATEMENT; \ } while (0) #endif /* GPR_FORBID_UNREACHABLE_CODE */ @@ -570,22 +668,6 @@ #define CENSUSAPI GRPCAPI #endif -#ifndef GPR_HAS_CPP_ATTRIBUTE -#ifdef __has_cpp_attribute -#define GPR_HAS_CPP_ATTRIBUTE(a) __has_cpp_attribute(a) -#else -#define GPR_HAS_CPP_ATTRIBUTE(a) 0 -#endif -#endif /* GPR_HAS_CPP_ATTRIBUTE */ - -#ifndef GPR_HAS_ATTRIBUTE -#ifdef __has_attribute -#define GPR_HAS_ATTRIBUTE(a) __has_attribute(a) -#else -#define GPR_HAS_ATTRIBUTE(a) 0 -#endif -#endif /* GPR_HAS_ATTRIBUTE */ - #ifndef GPR_HAS_FEATURE #ifdef __has_feature #define GPR_HAS_FEATURE(a) __has_feature(a) @@ -692,21 +774,6 @@ #define __STDC_FORMAT_MACROS #endif -/* Selectively enable EventEngine on specific platforms. This default can be - * overridden using the GRPC_USE_EVENT_ENGINE compiler flag. - */ -#ifndef GRPC_USE_EVENT_ENGINE -/* Not enabled by default on any platforms yet. (2021.06) */ -#elif GRPC_USE_EVENT_ENGINE == 0 -/* Building with `-DGRPC_USE_EVENT_ENGINE=0` will override the default. */ -#undef GRPC_USE_EVENT_ENGINE -#endif /* GRPC_USE_EVENT_ENGINE */ - -#ifdef GRPC_USE_EVENT_ENGINE -#undef GPR_SUPPORT_CHANNELS_FROM_FD -#define GRPC_ARES 0 -#endif /* GRPC_USE_EVENT_ENGINE */ - #define GRPC_CALLBACK_API_NONEXPERIMENTAL /* clang 11 with msan miscompiles destruction of [[no_unique_address]] members diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/grpcio-tools-1.46.3/grpc_root/include/grpc/impl/codegen/slice.h new/grpcio-tools-1.48.0/grpc_root/include/grpc/impl/codegen/slice.h --- old/grpcio-tools-1.46.3/grpc_root/include/grpc/impl/codegen/slice.h 2022-05-20 11:08:19.000000000 +0200 +++ new/grpcio-tools-1.48.0/grpc_root/include/grpc/impl/codegen/slice.h 2022-07-19 03:22:48.000000000 +0200 @@ -19,7 +19,7 @@ #ifndef GRPC_IMPL_CODEGEN_SLICE_H #define GRPC_IMPL_CODEGEN_SLICE_H -// IWYU pragma: private, include <grpc/slice.h> +// IWYU pragma: private #include <grpc/impl/codegen/port_platform.h> diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/grpcio-tools-1.46.3/grpc_root/include/grpcpp/ext/call_metric_recorder.h new/grpcio-tools-1.48.0/grpc_root/include/grpcpp/ext/call_metric_recorder.h --- old/grpcio-tools-1.46.3/grpc_root/include/grpcpp/ext/call_metric_recorder.h 1970-01-01 01:00:00.000000000 +0100 +++ new/grpcio-tools-1.48.0/grpc_root/include/grpcpp/ext/call_metric_recorder.h 2022-07-19 03:22:48.000000000 +0200 @@ -0,0 +1,94 @@ +/* + * + * Copyright 2022 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 GRPCPP_EXT_CALL_METRIC_RECORDER_H +#define GRPCPP_EXT_CALL_METRIC_RECORDER_H + +#include <memory> +#include <string> + +#include "absl/strings/string_view.h" +#include "absl/types/optional.h" + +#include <grpcpp/impl/codegen/slice.h> +#include <grpcpp/impl/codegen/sync.h> + +namespace grpc_core { +class Arena; +struct BackendMetricData; +} // namespace grpc_core + +namespace grpc { +class ServerBuilder; + +namespace experimental { +class OrcaServerInterceptor; + +// Registers the per-rpc orca load reporter into the \a ServerBuilder. +// Once this is done, the server will automatically send the load metrics +// after each RPC as they were reported. In order to report load metrics, +// call the \a ServerContext::ExperimentalGetCallMetricRecorder() method to +// retrieve the recorder for the current call. +void EnableCallMetricRecording(ServerBuilder*); + +/// Records call metrics for the purpose of load balancing. +/// During an RPC, call \a ServerContext::ExperimentalGetCallMetricRecorder() +/// method to retrive the recorder for the current call. +class CallMetricRecorder { + public: + explicit CallMetricRecorder(grpc_core::Arena* arena); + ~CallMetricRecorder(); + + /// Records a call metric measurement for CPU utilization. + /// Multiple calls to this method will override the stored value. + CallMetricRecorder& RecordCpuUtilizationMetric(double value); + + /// Records a call metric measurement for memory utilization. + /// Multiple calls to this method will override the stored value. + CallMetricRecorder& RecordMemoryUtilizationMetric(double value); + + /// Records a call metric measurement for utilization. + /// Multiple calls to this method with the same name will + /// override the corresponding stored value. The lifetime of the + /// name string needs to be longer than the lifetime of the RPC + /// itself, since it's going to be sent as trailers after the RPC + /// finishes. It is assumed the strings are common names that + /// are global constants. + CallMetricRecorder& RecordUtilizationMetric(string_ref name, double value); + + /// Records a call metric measurement for request cost. + /// Multiple calls to this method with the same name will + /// override the corresponding stored value. The lifetime of the + /// name string needs to be longer than the lifetime of the RPC + /// itself, since it's going to be sent as trailers after the RPC + /// finishes. It is assumed the strings are common names that + /// are global constants. + CallMetricRecorder& RecordRequestCostMetric(string_ref name, double value); + + private: + absl::optional<std::string> CreateSerializedReport(); + + internal::Mutex mu_; + grpc_core::BackendMetricData* backend_metric_data_ ABSL_GUARDED_BY(&mu_); + friend class experimental::OrcaServerInterceptor; +}; + +} // namespace experimental +} // namespace grpc + +#endif // GRPCPP_EXT_CALL_METRIC_RECORDER_H diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/grpcio-tools-1.46.3/grpc_root/include/grpcpp/impl/codegen/core_codegen.h new/grpcio-tools-1.48.0/grpc_root/include/grpcpp/impl/codegen/core_codegen.h --- old/grpcio-tools-1.46.3/grpc_root/include/grpcpp/impl/codegen/core_codegen.h 2022-05-20 11:08:19.000000000 +0200 +++ new/grpcio-tools-1.48.0/grpc_root/include/grpcpp/impl/codegen/core_codegen.h 2022-07-19 03:22:48.000000000 +0200 @@ -107,6 +107,8 @@ grpc_slice grpc_slice_sub(grpc_slice s, size_t begin, size_t end) override; void grpc_slice_buffer_add(grpc_slice_buffer* sb, grpc_slice slice) override; void grpc_slice_buffer_pop(grpc_slice_buffer* sb) override; + void grpc_slice_buffer_add_indexed(grpc_slice_buffer* sb, + grpc_slice slice) override; grpc_slice grpc_slice_from_static_buffer(const void* buffer, size_t length) override; grpc_slice grpc_slice_from_copied_buffer(const void* buffer, diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/grpcio-tools-1.46.3/grpc_root/include/grpcpp/impl/codegen/core_codegen_interface.h new/grpcio-tools-1.48.0/grpc_root/include/grpcpp/impl/codegen/core_codegen_interface.h --- old/grpcio-tools-1.46.3/grpc_root/include/grpcpp/impl/codegen/core_codegen_interface.h 2022-05-20 11:08:19.000000000 +0200 +++ new/grpcio-tools-1.48.0/grpc_root/include/grpcpp/impl/codegen/core_codegen_interface.h 2022-07-19 03:22:48.000000000 +0200 @@ -127,6 +127,8 @@ virtual grpc_slice grpc_slice_sub(grpc_slice s, size_t begin, size_t end) = 0; virtual void grpc_slice_buffer_add(grpc_slice_buffer* sb, grpc_slice slice) = 0; + virtual void grpc_slice_buffer_add_indexed(grpc_slice_buffer* sb, + grpc_slice slice) = 0; virtual void grpc_slice_buffer_pop(grpc_slice_buffer* sb) = 0; virtual grpc_slice grpc_slice_from_static_buffer(const void* buffer, size_t length) = 0; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/grpcio-tools-1.46.3/grpc_root/include/grpcpp/impl/codegen/interceptor.h new/grpcio-tools-1.48.0/grpc_root/include/grpcpp/impl/codegen/interceptor.h --- old/grpcio-tools-1.46.3/grpc_root/include/grpcpp/impl/codegen/interceptor.h 2022-05-20 11:08:19.000000000 +0200 +++ new/grpcio-tools-1.48.0/grpc_root/include/grpcpp/impl/codegen/interceptor.h 2022-07-19 03:22:48.000000000 +0200 @@ -21,13 +21,16 @@ // IWYU pragma: private, include <grpcpp/support/interceptor.h> +#include <map> #include <memory> +#include <string> #include <grpc/impl/codegen/grpc_types.h> #include <grpcpp/impl/codegen/byte_buffer.h> #include <grpcpp/impl/codegen/config.h> #include <grpcpp/impl/codegen/core_codegen_interface.h> #include <grpcpp/impl/codegen/metadata_map.h> +#include <grpcpp/impl/codegen/string_ref.h> namespace grpc { diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/grpcio-tools-1.46.3/grpc_root/include/grpcpp/impl/codegen/proto_buffer_writer.h new/grpcio-tools-1.48.0/grpc_root/include/grpcpp/impl/codegen/proto_buffer_writer.h --- old/grpcio-tools-1.46.3/grpc_root/include/grpcpp/impl/codegen/proto_buffer_writer.h 2022-05-20 11:08:19.000000000 +0200 +++ new/grpcio-tools-1.48.0/grpc_root/include/grpcpp/impl/codegen/proto_buffer_writer.h 2022-07-19 03:22:48.000000000 +0200 @@ -110,7 +110,12 @@ // On win x64, int is only 32bit GPR_CODEGEN_ASSERT(GRPC_SLICE_LENGTH(slice_) <= INT_MAX); byte_count_ += * size = static_cast<int>(GRPC_SLICE_LENGTH(slice_)); - g_core_codegen_interface->grpc_slice_buffer_add(slice_buffer_, slice_); + // Using grpc_slice_buffer_add could modify slice_ and merge it with the + // previous slice. Therefore, use grpc_slice_buffer_add_indexed method to + // ensure the slice gets added at a separate index. It can then be kept + // around and popped later in the BackUp function. + g_core_codegen_interface->grpc_slice_buffer_add_indexed(slice_buffer_, + slice_); return true; } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/grpcio-tools-1.46.3/grpc_root/include/grpcpp/impl/codegen/security/auth_context.h new/grpcio-tools-1.48.0/grpc_root/include/grpcpp/impl/codegen/security/auth_context.h --- old/grpcio-tools-1.46.3/grpc_root/include/grpcpp/impl/codegen/security/auth_context.h 2022-05-20 11:08:19.000000000 +0200 +++ new/grpcio-tools-1.48.0/grpc_root/include/grpcpp/impl/codegen/security/auth_context.h 2022-07-19 03:22:48.000000000 +0200 @@ -36,9 +36,14 @@ typedef std::pair<string_ref, string_ref> AuthProperty; -class AuthPropertyIterator - : public std::iterator<std::input_iterator_tag, const AuthProperty> { +class AuthPropertyIterator { public: + using iterator_category = std::forward_iterator_tag; + using value_type = const AuthProperty; + using pointer = void; + using reference = void; + using difference_type = std::ptrdiff_t; + ~AuthPropertyIterator(); AuthPropertyIterator& operator++(); AuthPropertyIterator operator++(int); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/grpcio-tools-1.46.3/grpc_root/include/grpcpp/impl/codegen/server_context.h new/grpcio-tools-1.48.0/grpc_root/include/grpcpp/impl/codegen/server_context.h --- old/grpcio-tools-1.46.3/grpc_root/include/grpcpp/impl/codegen/server_context.h 2022-05-20 11:08:19.000000000 +0200 +++ new/grpcio-tools-1.48.0/grpc_root/include/grpcpp/impl/codegen/server_context.h 2022-07-19 03:22:48.000000000 +0200 @@ -117,6 +117,11 @@ class DefaultReactorTestPeer; } // namespace testing +namespace experimental { +class OrcaServerInterceptor; +class CallMetricRecorder; +} // namespace experimental + /// Base class of ServerContext. class ServerContextBase { public: @@ -283,6 +288,19 @@ /// Applications never need to call this method. grpc_call* c_call() { return call_.call; } + /// Get the \a CallMetricRecorder object for the current RPC. + /// Use it to record metrics during your RPC to send back to the + /// client in order to make load balancing decisions. This will + /// return nullptr if the feature hasn't been enabled using + /// \a EnableCallMetricRecording. + experimental::CallMetricRecorder* ExperimentalGetCallMetricRecorder() { + return call_metric_recorder_; + } + + /// EXPERIMENTAL API + /// Returns the call's authority. + grpc::string_ref ExperimentalGetAuthority() const; + protected: /// Async only. Has to be called before the rpc starts. /// Returns the tag in completion queue when the rpc finishes. @@ -388,6 +406,7 @@ friend class grpc::ClientContext; friend class grpc::GenericServerContext; friend class grpc::GenericCallbackServerContext; + friend class grpc::experimental::OrcaServerInterceptor; /// Prevent copying. ServerContextBase(const ServerContextBase&); @@ -429,6 +448,8 @@ } } + void CreateCallMetricRecorder(); + struct CallWrapper { ~CallWrapper(); @@ -466,6 +487,7 @@ grpc::experimental::ServerRpcInfo* rpc_info_ = nullptr; RpcAllocatorState* message_allocator_state_ = nullptr; ContextAllocator* context_allocator_ = nullptr; + experimental::CallMetricRecorder* call_metric_recorder_ = nullptr; class Reactor : public grpc::ServerUnaryReactor { public: diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/grpcio-tools-1.46.3/grpc_root/include/grpcpp/impl/codegen/status.h new/grpcio-tools-1.48.0/grpc_root/include/grpcpp/impl/codegen/status.h --- old/grpcio-tools-1.46.3/grpc_root/include/grpcpp/impl/codegen/status.h 2022-05-20 11:08:19.000000000 +0200 +++ new/grpcio-tools-1.48.0/grpc_root/include/grpcpp/impl/codegen/status.h 2022-07-19 03:22:48.000000000 +0200 @@ -21,6 +21,8 @@ // IWYU pragma: private, include <grpcpp/support/status.h> +#include <grpc/impl/codegen/port_platform.h> + #include <grpc/impl/codegen/status.h> #include <grpcpp/impl/codegen/config.h> #include <grpcpp/impl/codegen/status_code_enum.h> @@ -30,7 +32,7 @@ /// Did it work? If it didn't, why? /// /// See \a grpc::StatusCode for details on the available code and their meaning. -class Status { +class GRPC_MUST_USE_RESULT_WHEN_USE_STRICT_WARNING Status { public: /// Construct an OK instance. Status() : code_(StatusCode::OK) { @@ -90,6 +92,10 @@ /// Construct an instance with associated \a code and \a error_message. /// It is an error to construct an OK status with non-empty \a error_message. + /// Note that \a message is intentionally accepted as a const reference + /// instead of a value (which results in a copy instead of a move) to allow + /// for easy transition to absl::Status in the future which accepts an + /// absl::string_view as a parameter. Status(StatusCode code, const std::string& error_message) : code_(code), error_message_(error_message) {} diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/grpcio-tools-1.46.3/grpc_root/include/grpcpp/impl/codegen/status_code_enum.h new/grpcio-tools-1.48.0/grpc_root/include/grpcpp/impl/codegen/status_code_enum.h --- old/grpcio-tools-1.46.3/grpc_root/include/grpcpp/impl/codegen/status_code_enum.h 2022-05-20 11:08:19.000000000 +0200 +++ new/grpcio-tools-1.48.0/grpc_root/include/grpcpp/impl/codegen/status_code_enum.h 2022-07-19 03:22:48.000000000 +0200 @@ -19,7 +19,7 @@ #ifndef GRPCPP_IMPL_CODEGEN_STATUS_CODE_ENUM_H #define GRPCPP_IMPL_CODEGEN_STATUS_CODE_ENUM_H -// IWYU pragma: private, include <grpcpp/support/status_code_enum.h> +// IWYU pragma: private, include <grpcpp/support/status.h> namespace grpc { diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/grpcio-tools-1.46.3/grpc_root/include/grpcpp/security/auth_metadata_processor.h new/grpcio-tools-1.48.0/grpc_root/include/grpcpp/security/auth_metadata_processor.h --- old/grpcio-tools-1.46.3/grpc_root/include/grpcpp/security/auth_metadata_processor.h 2022-05-20 11:08:19.000000000 +0200 +++ new/grpcio-tools-1.48.0/grpc_root/include/grpcpp/security/auth_metadata_processor.h 2022-07-19 03:22:48.000000000 +0200 @@ -30,6 +30,8 @@ /// Interface allowing custom server-side authorization based on credentials /// encoded in metadata. Objects of this type can be passed to /// \a ServerCredentials::SetAuthMetadataProcessor(). +/// Please also check out \a grpc::experimental::Interceptor for another way to +/// do customized operations on the information provided by a specific call. class AuthMetadataProcessor { public: typedef std::multimap<grpc::string_ref, grpc::string_ref> InputMetadata; @@ -41,15 +43,25 @@ /// a different thread from the one processing the call. virtual bool IsBlocking() const { return true; } - /// context is read/write: it contains the properties of the channel peer and - /// it is the job of the Process method to augment it with properties derived - /// from the passed-in auth_metadata. - /// consumed_auth_metadata needs to be filled with metadata that has been - /// consumed by the processor and will be removed from the call. - /// response_metadata is the metadata that will be sent as part of the - /// response. - /// If the return value is not Status::OK, the rpc call will be aborted with - /// the error code and error message sent back to the client. + /// Processes a Call associated with a connection. + /// auth_metadata: the authentication metadata associated with the particular + /// call + /// context: contains the connection-level info, e.g. the peer identity. This + /// parameter is readable and writable. Note that since the information is + /// shared for all calls associated with the connection, if the + /// implementation updates the info in a specific call, all the subsequent + /// calls will see the updates. A typical usage of context is to use + /// |auth_metadata| to infer the peer identity, and augment it with + /// properties. + /// consumed_auth_metadata: contains the metadata that the implementation + /// wants to remove from the current call, so that the server application is + /// no longer able to see it anymore. A typical usage would be to do token + /// authentication in the first call, and then remove the token information + /// for all subsequent calls. + /// response_metadata(CURRENTLY NOT SUPPORTED): the metadata that will be sent + /// as part of the response. + /// return: if the return value is not Status::OK, the rpc call will be + /// aborted with the error code and error message sent back to the client. virtual grpc::Status Process(const InputMetadata& auth_metadata, grpc::AuthContext* context, OutputMetadata* consumed_auth_metadata, diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/grpcio-tools-1.46.3/grpc_root/include/grpcpp/security/tls_certificate_verifier.h new/grpcio-tools-1.48.0/grpc_root/include/grpcpp/security/tls_certificate_verifier.h --- old/grpcio-tools-1.46.3/grpc_root/include/grpcpp/security/tls_certificate_verifier.h 2022-05-20 11:08:19.000000000 +0200 +++ new/grpcio-tools-1.48.0/grpc_root/include/grpcpp/security/tls_certificate_verifier.h 2022-07-19 03:22:48.000000000 +0200 @@ -214,6 +214,19 @@ request_map_ ABSL_GUARDED_BY(mu_); }; +// A CertificateVerifier that doesn't perform any additional checks other than +// certificate verification, if specified. +// Note: using this solely without any other authentication mechanisms on the +// peer identity will leave your applications to the MITM(Man-In-The-Middle) +// attacks. Users should avoid doing so in production environments. +class NoOpCertificateVerifier : public CertificateVerifier { + public: + NoOpCertificateVerifier(); +}; + +// A CertificateVerifier that will perform hostname verification, to see if the +// target name set from the client side matches the identity information +// specified on the server's certificate. class HostNameCertificateVerifier : public CertificateVerifier { public: HostNameCertificateVerifier(); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/grpcio-tools-1.46.3/grpc_root/include/grpcpp/server_builder.h new/grpcio-tools-1.48.0/grpc_root/include/grpcpp/server_builder.h --- old/grpcio-tools-1.46.3/grpc_root/include/grpcpp/server_builder.h 2022-05-20 11:08:19.000000000 +0200 +++ new/grpcio-tools-1.48.0/grpc_root/include/grpcpp/server_builder.h 2022-07-19 03:22:48.000000000 +0200 @@ -59,6 +59,7 @@ class CallbackGenericService; namespace experimental { +class OrcaServerInterceptorFactory; // EXPERIMENTAL API: // Interface for a grpc server to build transports with connections created out // of band. @@ -352,6 +353,7 @@ private: friend class grpc::testing::ServerBuilderPluginTest; + friend class grpc::experimental::OrcaServerInterceptorFactory; struct SyncServerSettings { SyncServerSettings() @@ -402,6 +404,9 @@ std::vector< std::unique_ptr<grpc::experimental::ServerInterceptorFactoryInterface>> interceptor_creators_; + std::vector< + std::unique_ptr<grpc::experimental::ServerInterceptorFactoryInterface>> + internal_interceptor_creators_; std::vector<std::shared_ptr<grpc::internal::ExternalConnectionAcceptorImpl>> acceptors_; grpc_server_config_fetcher* server_config_fetcher_ = nullptr; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/grpcio-tools-1.46.3/grpc_root/src/compiler/csharp_generator.cc new/grpcio-tools-1.48.0/grpc_root/src/compiler/csharp_generator.cc --- old/grpcio-tools-1.46.3/grpc_root/src/compiler/csharp_generator.cc 2022-05-20 11:08:19.000000000 +0200 +++ new/grpcio-tools-1.48.0/grpc_root/src/compiler/csharp_generator.cc 2022-07-19 03:22:48.000000000 +0200 @@ -801,7 +801,7 @@ out.PrintRaw(leading_comments.c_str()); } - out.Print("#pragma warning disable 0414, 1591\n"); + out.Print("#pragma warning disable 0414, 1591, 8981\n"); out.Print("#region Designer generated code\n"); out.Print("\n"); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/grpcio-tools-1.46.3/grpc_tools/_protoc_compiler.cpp new/grpcio-tools-1.48.0/grpc_tools/_protoc_compiler.cpp --- old/grpcio-tools-1.46.3/grpc_tools/_protoc_compiler.cpp 2022-05-20 11:08:33.000000000 +0200 +++ new/grpcio-tools-1.48.0/grpc_tools/_protoc_compiler.cpp 2022-07-19 03:23:17.000000000 +0200 @@ -13,7 +13,7 @@ "grpc_tools/main.h" ], "extra_compile_args": [ - "-std=c++11", + "-std=c++14", "-fno-wrapv", "-frtti" ], diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/grpcio-tools-1.46.3/grpc_version.py new/grpcio-tools-1.48.0/grpc_version.py --- old/grpcio-tools-1.46.3/grpc_version.py 2022-05-20 11:06:34.000000000 +0200 +++ new/grpcio-tools-1.48.0/grpc_version.py 2022-07-19 03:18:48.000000000 +0200 @@ -14,5 +14,5 @@ # AUTO-GENERATED FROM `$REPO_ROOT/templates/tools/distrib/python/grpcio_tools/grpc_version.py.template`!!! -VERSION = '1.46.3' +VERSION = '1.48.0' PROTOBUF_VERSION = '3.19.4' diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/grpcio-tools-1.46.3/grpcio_tools.egg-info/PKG-INFO new/grpcio-tools-1.48.0/grpcio_tools.egg-info/PKG-INFO --- old/grpcio-tools-1.46.3/grpcio_tools.egg-info/PKG-INFO 2022-05-20 11:08:33.000000000 +0200 +++ new/grpcio-tools-1.48.0/grpcio_tools.egg-info/PKG-INFO 2022-07-19 03:23:17.000000000 +0200 @@ -1,6 +1,6 @@ Metadata-Version: 1.2 Name: grpcio-tools -Version: 1.46.3 +Version: 1.48.0 Summary: Protobuf code generator for gRPC Home-page: https://grpc.io Author: The gRPC Authors diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/grpcio-tools-1.46.3/grpcio_tools.egg-info/SOURCES.txt new/grpcio-tools-1.48.0/grpcio_tools.egg-info/SOURCES.txt --- old/grpcio-tools-1.46.3/grpcio_tools.egg-info/SOURCES.txt 2022-05-20 11:08:33.000000000 +0200 +++ new/grpcio-tools-1.48.0/grpcio_tools.egg-info/SOURCES.txt 2022-07-19 03:23:17.000000000 +0200 @@ -107,6 +107,8 @@ grpc_root/include/grpc/event_engine/memory_allocator.h grpc_root/include/grpc/event_engine/memory_request.h grpc_root/include/grpc/event_engine/port.h +grpc_root/include/grpc/event_engine/slice.h +grpc_root/include/grpc/event_engine/slice_buffer.h grpc_root/include/grpc/event_engine/internal/memory_allocator_impl.h grpc_root/include/grpc/impl/codegen/README.md grpc_root/include/grpc/impl/codegen/atm.h @@ -168,6 +170,7 @@ grpc_root/include/grpcpp/server_posix.h grpc_root/include/grpcpp/xds_server_builder.h grpc_root/include/grpcpp/ext/admin_services.h +grpc_root/include/grpcpp/ext/call_metric_recorder.h grpc_root/include/grpcpp/ext/channelz_service_plugin.h grpc_root/include/grpcpp/ext/health_check_service_server_builder_option.h grpc_root/include/grpcpp/ext/orca_service.h diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/grpcio-tools-1.46.3/grpcio_tools.egg-info/requires.txt new/grpcio-tools-1.48.0/grpcio_tools.egg-info/requires.txt --- old/grpcio-tools-1.46.3/grpcio_tools.egg-info/requires.txt 2022-05-20 11:08:33.000000000 +0200 +++ new/grpcio-tools-1.48.0/grpcio_tools.egg-info/requires.txt 2022-07-19 03:23:17.000000000 +0200 @@ -1,3 +1,3 @@ protobuf<4.0dev,>=3.12.0 -grpcio>=1.46.3 +grpcio>=1.48.0 setuptools diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/grpcio-tools-1.46.3/setup.py new/grpcio-tools-1.48.0/setup.py --- old/grpcio-tools-1.46.3/setup.py 2022-05-20 11:06:34.000000000 +0200 +++ new/grpcio-tools-1.48.0/setup.py 2022-07-19 03:18:48.000000000 +0200 @@ -88,7 +88,7 @@ code_test = (b'#include <atomic>\n' + b'int main() { return std::atomic<int64_t>{}; }') cxx = os.environ.get('CXX', 'c++') - cpp_test = subprocess.Popen([cxx, '-x', 'c++', '-std=c++11', '-'], + cpp_test = subprocess.Popen([cxx, '-x', 'c++', '-std=c++14', '-'], stdin=PIPE, stdout=PIPE, stderr=PIPE) @@ -98,7 +98,7 @@ # Double-check to see if -latomic actually can solve the problem. # https://github.com/grpc/grpc/issues/22491 cpp_test = subprocess.Popen( - [cxx, '-x', 'c++', '-std=c++11', '-', '-latomic'], + [cxx, '-x', 'c++', '-std=c++14', '-', '-latomic'], stdin=PIPE, stdout=PIPE, stderr=PIPE) @@ -134,7 +134,7 @@ EXTRA_ENV_COMPILE_ARGS = os.environ.get('GRPC_PYTHON_CFLAGS', None) EXTRA_ENV_LINK_ARGS = os.environ.get('GRPC_PYTHON_LDFLAGS', None) if EXTRA_ENV_COMPILE_ARGS is None: - EXTRA_ENV_COMPILE_ARGS = '-std=c++11' + EXTRA_ENV_COMPILE_ARGS = '-std=c++14' if 'win32' in sys.platform: if sys.version_info < (3, 5): # We use define flags here and don't directly add to DEFINE_MACROS below to