grpc 1.67.0 → 1.69.0.pre1

data/src/core/xds/xds_client/xds_client.h

@@ -17,6 +17,9 @@
 #ifndef GRPC_SRC_CORE_XDS_XDS_CLIENT_XDS_CLIENT_H
 #define GRPC_SRC_CORE_XDS_XDS_CLIENT_XDS_CLIENT_H
 
+#include <grpc/event_engine/event_engine.h>
+#include <grpc/support/port_platform.h>
+
 #include <map>
 #include <memory>
 #include <set>
@@ -28,26 +31,22 @@
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
-#include "upb/reflection/def.hpp"
-
-#include <grpc/event_engine/event_engine.h>
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/debug/trace.h"
-#include "src/core/lib/gprpp/dual_ref_counted.h"
-#include "src/core/lib/gprpp/orphanable.h"
-#include "src/core/lib/gprpp/ref_counted.h"
-#include "src/core/lib/gprpp/ref_counted_ptr.h"
-#include "src/core/lib/gprpp/sync.h"
-#include "src/core/lib/gprpp/time.h"
-#include "src/core/lib/gprpp/work_serializer.h"
-#include "src/core/lib/uri/uri_parser.h"
+#include "src/core/util/dual_ref_counted.h"
+#include "src/core/util/orphanable.h"
+#include "src/core/util/ref_counted.h"
+#include "src/core/util/ref_counted_ptr.h"
+#include "src/core/util/sync.h"
+#include "src/core/util/time.h"
+#include "src/core/util/uri.h"
+#include "src/core/util/work_serializer.h"
 #include "src/core/xds/xds_client/xds_api.h"
 #include "src/core/xds/xds_client/xds_bootstrap.h"
-#include "src/core/xds/xds_client/xds_client_stats.h"
+#include "src/core/xds/xds_client/xds_locality.h"
 #include "src/core/xds/xds_client/xds_metrics.h"
 #include "src/core/xds/xds_client/xds_resource_type.h"
 #include "src/core/xds/xds_client/xds_transport.h"
+#include "upb/reflection/def.hpp"
 
 namespace grpc_core {
 
@@ -84,22 +83,14 @@ class XdsClient : public DualRefCounted<XdsClient> {
   };
 
   XdsClient(
-      std::unique_ptr<XdsBootstrap> bootstrap,
-      OrphanablePtr<XdsTransportFactory> transport_factory,
+      std::shared_ptr<XdsBootstrap> bootstrap,
+      RefCountedPtr<XdsTransportFactory> transport_factory,
       std::shared_ptr<grpc_event_engine::experimental::EventEngine> engine,
       std::unique_ptr<XdsMetricsReporter> metrics_reporter,
       std::string user_agent_name, std::string user_agent_version,
       Duration resource_request_timeout = Duration::Seconds(15));
   ~XdsClient() override;
 
-  const XdsBootstrap& bootstrap() const {
-    return *bootstrap_;  // ctor asserts that it is non-null
-  }
-
-  XdsTransportFactory* transport_factory() const {
-    return transport_factory_.get();
-  }
-
   // Start and cancel watch for a resource.
   //
   // The XdsClient takes ownership of the watcher, but the caller may
@@ -126,29 +117,16 @@ class XdsClient : public DualRefCounted<XdsClient> {
                            ResourceWatcherInterface* watcher,
                            bool delay_unsubscription = false);
 
-  // Adds and removes drop stats for cluster_name and eds_service_name.
-  RefCountedPtr<XdsClusterDropStats> AddClusterDropStats(
-      const XdsBootstrap::XdsServer& xds_server, absl::string_view cluster_name,
-      absl::string_view eds_service_name);
-  void RemoveClusterDropStats(absl::string_view xds_server,
-                              absl::string_view cluster_name,
-                              absl::string_view eds_service_name,
-                              XdsClusterDropStats* cluster_drop_stats);
-
-  // Adds and removes locality stats for cluster_name and eds_service_name
-  // for the specified locality.
-  RefCountedPtr<XdsClusterLocalityStats> AddClusterLocalityStats(
-      const XdsBootstrap::XdsServer& xds_server, absl::string_view cluster_name,
-      absl::string_view eds_service_name,
-      RefCountedPtr<XdsLocalityName> locality);
-  void RemoveClusterLocalityStats(
-      absl::string_view xds_server, absl::string_view cluster_name,
-      absl::string_view eds_service_name,
-      const RefCountedPtr<XdsLocalityName>& locality,
-      XdsClusterLocalityStats* cluster_locality_stats);
-
   // Resets connection backoff state.
-  void ResetBackoff();
+  virtual void ResetBackoff();
+
+  const XdsBootstrap& bootstrap() const {
+    return *bootstrap_;  // ctor asserts that it is non-null
+  }
+
+  XdsTransportFactory* transport_factory() const {
+    return transport_factory_.get();
+  }
 
   grpc_event_engine::experimental::EventEngine* engine() {
     return engine_.get();
@@ -212,7 +190,6 @@ class XdsClient : public DualRefCounted<XdsClient> {
     class RetryableCall;
 
     class AdsCall;
-    class LrsCall;
 
     XdsChannel(WeakRefCountedPtr<XdsClient> xds_client,
                const XdsBootstrap::XdsServer& server);
@@ -220,13 +197,9 @@ class XdsClient : public DualRefCounted<XdsClient> {
 
     XdsClient* xds_client() const { return xds_client_.get(); }
     AdsCall* ads_call() const;
-    LrsCall* lrs_call() const;
 
     void ResetBackoff();
 
-    void MaybeStartLrsCall();
-    void StopLrsCallLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsClient::mu_);
-
     // Returns non-OK if there has been an error since the last time the
     // ADS stream saw a response.
     const absl::Status& status() const { return status_; }
@@ -242,6 +215,8 @@ class XdsClient : public DualRefCounted<XdsClient> {
     absl::string_view server_uri() const { return server_.server_uri(); }
 
    private:
+    class ConnectivityFailureWatcher;
+
     // Attempts to find a suitable Xds fallback server. Returns true if
     // a connection to a suitable server had been established.
     bool MaybeFallbackLocked(const std::string& authority,
@@ -262,13 +237,14 @@ class XdsClient : public DualRefCounted<XdsClient> {
 
     const XdsBootstrap::XdsServer& server_;  // Owned by bootstrap.
 
-    OrphanablePtr<XdsTransportFactory::XdsTransport> transport_;
+    RefCountedPtr<XdsTransportFactory::XdsTransport> transport_;
+    RefCountedPtr<XdsTransportFactory::XdsTransport::ConnectivityFailureWatcher>
+        failure_watcher_;
 
     bool shutting_down_ = false;
 
     // The retryable ADS and LRS calls.
     OrphanablePtr<RetryableCall<AdsCall>> ads_call_;
-    OrphanablePtr<RetryableCall<LrsCall>> lrs_call_;
 
     // Stores the most recent accepted resource version for each resource type.
     std::map<const XdsResourceType*, std::string /*version*/>
@@ -292,30 +268,6 @@ class XdsClient : public DualRefCounted<XdsClient> {
         resource_map;
   };
 
-  struct LoadReportState {
-    struct LocalityState {
-      XdsClusterLocalityStats* locality_stats = nullptr;
-      XdsClusterLocalityStats::Snapshot deleted_locality_stats;
-    };
-
-    XdsClusterDropStats* drop_stats = nullptr;
-    XdsClusterDropStats::Snapshot deleted_drop_stats;
-    std::map<RefCountedPtr<XdsLocalityName>, LocalityState,
-             XdsLocalityName::Less>
-        locality_stats;
-    Timestamp last_report_time = Timestamp::Now();
-  };
-
-  // Load report data.
-  using LoadReportMap = std::map<
-      std::pair<std::string /*cluster_name*/, std::string /*eds_service_name*/>,
-      LoadReportState>;
-
-  struct LoadReportServer {
-    RefCountedPtr<XdsChannel> xds_channel;
-    LoadReportMap load_report_map;
-  };
-
   // Sends an error notification to a specific set of watchers.
   void NotifyWatchersOnErrorLocked(
       const std::map<ResourceWatcherInterface*,
@@ -334,22 +286,20 @@ class XdsClient : public DualRefCounted<XdsClient> {
   const XdsResourceType* GetResourceTypeLocked(absl::string_view resource_type)
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
 
+  bool HasUncachedResources(const AuthorityState& authority_state);
+
   absl::StatusOr<XdsResourceName> ParseXdsResourceName(
       absl::string_view name, const XdsResourceType* type);
   static std::string ConstructFullXdsResourceName(
       absl::string_view authority, absl::string_view resource_type,
       const XdsResourceKey& key);
 
-  XdsApi::ClusterLoadReportMap BuildLoadReportSnapshotLocked(
-      const XdsBootstrap::XdsServer& xds_server, bool send_all_clusters,
-      const std::set<std::string>& clusters) ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
   RefCountedPtr<XdsChannel> GetOrCreateXdsChannelLocked(
       const XdsBootstrap::XdsServer& server, const char* reason)
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
-  bool HasUncachedResources(const AuthorityState& authority_state);
 
-  std::unique_ptr<XdsBootstrap> bootstrap_;
-  OrphanablePtr<XdsTransportFactory> transport_factory_;
+  std::shared_ptr<XdsBootstrap> bootstrap_;
+  RefCountedPtr<XdsTransportFactory> transport_factory_;
   const Duration request_timeout_;
   const bool xds_federation_enabled_;
   XdsApi api_;
@@ -371,9 +321,6 @@ class XdsClient : public DualRefCounted<XdsClient> {
   std::map<std::string /*authority*/, AuthorityState> authority_state_map_
       ABSL_GUARDED_BY(mu_);
 
-  std::map<std::string /*XdsServer key*/, LoadReportServer, std::less<>>
-      xds_load_report_server_map_ ABSL_GUARDED_BY(mu_);
-
   // Stores started watchers whose resource name was not parsed successfully,
   // waiting to be cancelled or reset in Orphan().
   std::map<ResourceWatcherInterface*, RefCountedPtr<ResourceWatcherInterface>>

data/src/core/xds/xds_client/xds_locality.h

@@ -0,0 +1,102 @@
+//
+//
+// Copyright 2018 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_SRC_CORE_XDS_XDS_CLIENT_XDS_LOCALITY_H
+#define GRPC_SRC_CORE_XDS_XDS_CLIENT_XDS_LOCALITY_H
+
+#include <string>
+#include <utility>
+
+#include "absl/strings/str_format.h"
+#include "absl/strings/string_view.h"
+#include "src/core/resolver/endpoint_addresses.h"
+#include "src/core/util/ref_counted.h"
+#include "src/core/util/ref_counted_ptr.h"
+#include "src/core/util/ref_counted_string.h"
+#include "src/core/util/useful.h"
+
+namespace grpc_core {
+
+// An xDS locality name.
+class XdsLocalityName final : public RefCounted<XdsLocalityName> {
+ public:
+  struct Less {
+    bool operator()(const XdsLocalityName* lhs,
+                    const XdsLocalityName* rhs) const {
+      if (lhs == nullptr || rhs == nullptr) return QsortCompare(lhs, rhs);
+      return lhs->Compare(*rhs) < 0;
+    }
+
+    bool operator()(const RefCountedPtr<XdsLocalityName>& lhs,
+                    const RefCountedPtr<XdsLocalityName>& rhs) const {
+      return (*this)(lhs.get(), rhs.get());
+    }
+  };
+
+  XdsLocalityName(std::string region, std::string zone, std::string sub_zone)
+      : region_(std::move(region)),
+        zone_(std::move(zone)),
+        sub_zone_(std::move(sub_zone)),
+        human_readable_string_(
+            absl::StrFormat("{region=\"%s\", zone=\"%s\", sub_zone=\"%s\"}",
+                            region_, zone_, sub_zone_)) {}
+
+  bool operator==(const XdsLocalityName& other) const {
+    return region_ == other.region_ && zone_ == other.zone_ &&
+           sub_zone_ == other.sub_zone_;
+  }
+
+  bool operator!=(const XdsLocalityName& other) const {
+    return !(*this == other);
+  }
+
+  int Compare(const XdsLocalityName& other) const {
+    int cmp_result = region_.compare(other.region_);
+    if (cmp_result != 0) return cmp_result;
+    cmp_result = zone_.compare(other.zone_);
+    if (cmp_result != 0) return cmp_result;
+    return sub_zone_.compare(other.sub_zone_);
+  }
+
+  const std::string& region() const { return region_; }
+  const std::string& zone() const { return zone_; }
+  const std::string& sub_zone() const { return sub_zone_; }
+
+  const RefCountedStringValue& human_readable_string() const {
+    return human_readable_string_;
+  }
+
+  // Channel args traits.
+  static absl::string_view ChannelArgName() {
+    return GRPC_ARG_NO_SUBCHANNEL_PREFIX "xds_locality_name";
+  }
+  static int ChannelArgsCompare(const XdsLocalityName* a,
+                                const XdsLocalityName* b) {
+    return a->Compare(*b);
+  }
+
+ private:
+  std::string region_;
+  std::string zone_;
+  std::string sub_zone_;
+  RefCountedStringValue human_readable_string_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_XDS_XDS_CLIENT_XDS_LOCALITY_H

data/src/core/xds/xds_client/xds_metrics.h

@@ -17,10 +17,10 @@
 #ifndef GRPC_SRC_CORE_XDS_XDS_CLIENT_XDS_METRICS_H
 #define GRPC_SRC_CORE_XDS_XDS_CLIENT_XDS_METRICS_H
 
-#include "absl/strings/string_view.h"
-
 #include <grpc/support/port_platform.h>
 
+#include "absl/strings/string_view.h"
+
 namespace grpc_core {
 
 // An interface for XdsClient to report metrics.

data/src/core/xds/xds_client/xds_resource_type.h

@@ -16,19 +16,18 @@
 
 #ifndef GRPC_SRC_CORE_XDS_XDS_CLIENT_XDS_RESOURCE_TYPE_H
 #define GRPC_SRC_CORE_XDS_XDS_CLIENT_XDS_RESOURCE_TYPE_H
+#include <grpc/support/port_platform.h>
+
 #include <memory>
 #include <string>
 
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
-#include "upb/mem/arena.h"
-#include "upb/reflection/def.h"
-
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/debug/trace.h"
 #include "src/core/xds/xds_client/xds_bootstrap.h"
+#include "upb/mem/arena.h"
+#include "upb/reflection/def.h"
 
 namespace grpc_core {
 

data/src/core/xds/xds_client/xds_resource_type_impl.h

@@ -16,14 +16,13 @@
 
 #ifndef GRPC_SRC_CORE_XDS_XDS_CLIENT_XDS_RESOURCE_TYPE_IMPL_H
 #define GRPC_SRC_CORE_XDS_XDS_CLIENT_XDS_RESOURCE_TYPE_IMPL_H
+#include <grpc/support/port_platform.h>
+
 #include <memory>
 #include <utility>
 
 #include "absl/strings/string_view.h"
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/util/ref_counted_ptr.h"
 #include "src/core/xds/xds_client/xds_client.h"
 #include "src/core/xds/xds_client/xds_resource_type.h"
 

data/src/core/xds/xds_client/xds_transport.h

@@ -17,25 +17,22 @@
 #ifndef GRPC_SRC_CORE_XDS_XDS_CLIENT_XDS_TRANSPORT_H
 #define GRPC_SRC_CORE_XDS_XDS_CLIENT_XDS_TRANSPORT_H
 
-#include <functional>
 #include <memory>
 #include <string>
 
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/gprpp/orphanable.h"
+#include "src/core/util/dual_ref_counted.h"
+#include "src/core/util/orphanable.h"
 #include "src/core/xds/xds_client/xds_bootstrap.h"
 
 namespace grpc_core {
 
 // A factory for creating new XdsTransport instances.
-class XdsTransportFactory : public InternallyRefCounted<XdsTransportFactory> {
+class XdsTransportFactory : public DualRefCounted<XdsTransportFactory> {
  public:
   // Represents a transport for xDS communication (e.g., a gRPC channel).
-  class XdsTransport : public InternallyRefCounted<XdsTransport> {
+  class XdsTransport : public DualRefCounted<XdsTransport> {
    public:
     // Represents a bidi streaming RPC call.
     class StreamingCall : public InternallyRefCounted<StreamingCall> {
@@ -63,6 +60,25 @@ class XdsTransportFactory : public InternallyRefCounted<XdsTransportFactory> {
       virtual void StartRecvMessage() = 0;
     };
 
+    // A watcher for connectivity failures.
+    class ConnectivityFailureWatcher
+        : public RefCounted<ConnectivityFailureWatcher> {
+     public:
+      // Will be invoked whenever there is a connectivity failure on the
+      // transport.
+      virtual void OnConnectivityFailure(absl::Status status) = 0;
+    };
+
+    explicit XdsTransport(const char* trace = nullptr)
+        : DualRefCounted(trace) {}
+
+    // Starts a connectivity failure watcher on the transport.
+    virtual void StartConnectivityFailureWatch(
+        RefCountedPtr<ConnectivityFailureWatcher> watcher) = 0;
+    // Stops a connectivity failure watcher on the transport.
+    virtual void StopConnectivityFailureWatch(
+        const RefCountedPtr<ConnectivityFailureWatcher>& watcher) = 0;
+
     // Create a streaming call on this transport for the specified method.
     // Events on the stream will be reported to event_handler.
     virtual OrphanablePtr<StreamingCall> CreateStreamingCall(
@@ -73,15 +89,14 @@ class XdsTransportFactory : public InternallyRefCounted<XdsTransportFactory> {
     virtual void ResetBackoff() = 0;
   };
 
-  // Creates a new transport for the specified server.
-  // The on_connectivity_failure callback will be invoked whenever there is
-  // a connectivity failure on the transport.
+  // Returns a transport for the specified server.  If there is already
+  // a transport for the server, returns a new ref to that transport;
+  // otherwise, creates a new transport.
+  //
   // *status will be set if there is an error creating the channel,
   // although the returned channel must still accept calls (which may fail).
-  virtual OrphanablePtr<XdsTransport> Create(
-      const XdsBootstrap::XdsServer& server,
-      std::function<void(absl::Status)> on_connectivity_failure,
-      absl::Status* status) = 0;
+  virtual RefCountedPtr<XdsTransport> GetTransport(
+      const XdsBootstrap::XdsServer& server, absl::Status* status) = 0;
 };
 
 }  // namespace grpc_core

data/src/ruby/ext/grpc/extconf.rb

@@ -29,7 +29,7 @@ grpc_root = File.expand_path(File.join(File.dirname(__FILE__), '../../../..'))
 
 grpc_config = ENV['GRPC_CONFIG'] || 'opt'
 
-ENV['MACOSX_DEPLOYMENT_TARGET'] = '10.10'
+ENV['MACOSX_DEPLOYMENT_TARGET'] = '10.14'
 
 def debug_symbols_output_dir
   d = ENV['GRPC_RUBY_DEBUG_SYMBOLS_OUTPUT_DIR']

data/src/ruby/ext/grpc/rb_byte_buffer.c

@@ -20,13 +20,13 @@
 
 #include "rb_byte_buffer.h"
 
-#include "rb_grpc.h"
-#include "rb_grpc_imports.generated.h"
-
 #include <grpc/byte_buffer_reader.h>
 #include <grpc/grpc.h>
 #include <grpc/slice.h>
 
+#include "rb_grpc.h"
+#include "rb_grpc_imports.generated.h"
+
 grpc_byte_buffer* grpc_rb_s_to_byte_buffer(char* string, size_t length) {
   grpc_slice slice = grpc_slice_from_copied_buffer(string, length);
   grpc_byte_buffer* buffer = grpc_raw_byte_buffer_create(&slice, 1);

data/src/ruby/ext/grpc/rb_call.c

@@ -20,17 +20,17 @@
 
 #include "rb_call.h"
 
+#include <grpc/grpc.h>
+#include <grpc/impl/codegen/compression_types.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+
 #include "rb_byte_buffer.h"
 #include "rb_call_credentials.h"
 #include "rb_completion_queue.h"
 #include "rb_grpc.h"
 #include "rb_grpc_imports.generated.h"
 
-#include <grpc/grpc.h>
-#include <grpc/impl/codegen/compression_types.h>
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-
 /* grpc_rb_cCall is the Call class whose instances proxy grpc_call. */
 static VALUE grpc_rb_cCall;
 

data/src/ruby/ext/grpc/rb_call_credentials.c

@@ -20,6 +20,11 @@
 
 #include "rb_call_credentials.h"
 
+#include <grpc/credentials.h>
+#include <grpc/grpc.h>
+#include <grpc/grpc_security.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
 #include <ruby/thread.h>
 
 #include "rb_call.h"
@@ -27,12 +32,6 @@
 #include "rb_grpc.h"
 #include "rb_grpc_imports.generated.h"
 
-#include <grpc/credentials.h>
-#include <grpc/grpc.h>
-#include <grpc/grpc_security.h>
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-
 /* grpc_rb_cCallCredentials is the ruby class that proxies
  * grpc_call_credentials */
 static VALUE grpc_rb_cCallCredentials = Qnil;

data/src/ruby/ext/grpc/rb_channel.c

@@ -20,6 +20,12 @@
 
 #include "rb_channel.h"
 
+#include <grpc/credentials.h>
+#include <grpc/grpc.h>
+#include <grpc/grpc_security.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/time.h>
 #include <ruby/thread.h>
 
 #include "rb_byte_buffer.h"
@@ -32,13 +38,6 @@
 #include "rb_server.h"
 #include "rb_xds_channel_credentials.h"
 
-#include <grpc/credentials.h>
-#include <grpc/grpc.h>
-#include <grpc/grpc_security.h>
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-#include <grpc/support/time.h>
-
 /* id_channel is the name of the hidden ivar that preserves a reference to the
  * channel on a call, so that calls are not GCed before their channel.  */
 static ID id_channel;

data/src/ruby/ext/grpc/rb_channel_args.c

@@ -20,14 +20,14 @@
 
 #include "rb_channel_args.h"
 
-#include "rb_grpc.h"
-#include "rb_grpc_imports.generated.h"
-
 #include <grpc/grpc.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
+#include "rb_grpc.h"
+#include "rb_grpc_imports.generated.h"
+
 static rb_data_type_t grpc_rb_channel_args_data_type = {
     "grpc_channel_args",
     {GRPC_RB_GC_NOT_MARKED,

data/src/ruby/ext/grpc/rb_channel_credentials.c

@@ -20,17 +20,16 @@
 
 #include "rb_channel_credentials.h"
 
-#include <string.h>
-
-#include "rb_call_credentials.h"
-#include "rb_grpc.h"
-#include "rb_grpc_imports.generated.h"
-
 #include <grpc/credentials.h>
 #include <grpc/grpc.h>
 #include <grpc/grpc_security.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
+#include <string.h>
+
+#include "rb_call_credentials.h"
+#include "rb_grpc.h"
+#include "rb_grpc_imports.generated.h"
 
 /* grpc_rb_cChannelCredentials is the ruby class that proxies
    grpc_channel_credentials. */

data/src/ruby/ext/grpc/rb_channel_credentials.h

@@ -21,9 +21,8 @@
 
 #include <ruby/ruby.h>
 
-#include <stdbool.h>
-
 #include <grpc/grpc_security.h>
+#include <stdbool.h>
 
 /* Initializes the ruby ChannelCredentials class. */
 void Init_grpc_channel_credentials();

data/src/ruby/ext/grpc/rb_completion_queue.c

@@ -20,15 +20,14 @@
 
 #include "rb_completion_queue.h"
 
+#include <grpc/grpc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/time.h>
 #include <ruby/thread.h>
 
 #include "rb_grpc.h"
 #include "rb_grpc_imports.generated.h"
 
-#include <grpc/grpc.h>
-#include <grpc/support/log.h>
-#include <grpc/support/time.h>
-
 /* Used to allow grpc_completion_queue_next call to release the GIL */
 typedef struct next_call_stack {
   grpc_completion_queue* cq;

data/src/ruby/ext/grpc/rb_compression_options.c

@@ -20,12 +20,6 @@
 
 #include "rb_compression_options.h"
 
-#include <string.h>
-
-#include "rb_byte_buffer.h"
-#include "rb_grpc.h"
-#include "rb_grpc_imports.generated.h"
-
 #include <grpc/compression.h>
 #include <grpc/grpc.h>
 #include <grpc/impl/codegen/compression_types.h>
@@ -33,6 +27,11 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
+#include <string.h>
+
+#include "rb_byte_buffer.h"
+#include "rb_grpc.h"
+#include "rb_grpc_imports.generated.h"
 
 static VALUE grpc_rb_cCompressionOptions = Qnil;
 
@@ -296,7 +295,7 @@ VALUE grpc_rb_compression_options_level_value_to_name_internal(
  * Fails if the enum value is invalid. */
 VALUE grpc_rb_compression_options_algorithm_value_to_name_internal(
     grpc_compression_algorithm internal_value) {
-  char* algorithm_name = NULL;
+  const char* algorithm_name = NULL;
 
   if (!grpc_compression_algorithm_name(internal_value, &algorithm_name)) {
     rb_raise(rb_eArgError, "Failed to convert algorithm value to name");