Update grpc c core to 1.44.0 (tikv#558)

This PR also uses the same bindings for both (x86_64|aarch64)_(macos|linux).
CI will check if it's OK to do so. This should make maintenance easier.

Changes from tikv#539 is also included in this PR.

Features use-bindgen is removed as it can be detected during compile time now.

This PR also rename the secure features to boringssl for better understanding.
And now only enabling openssl features will not download boringssl anymore.

Close tikv#557.
Close tikv#539.

Signed-off-by: Jay Lee <BusyJayLee@gmail.com>

Author: BusyJay

.github/workflows/ci.yml

@@ -97,9 +97,11 @@ jobs:
     - uses: actions/checkout@v2
     - run: which cargo && cargo version && clang --version && openssl version
     - run: cargo xtask submodule
-    - run: cargo build --no-default-features --features use-bindgen
-    - run: cargo build --no-default-features --features "protobuf-codec use-bindgen"
-    - run: cargo build --no-default-features --features "prost-codec use-bindgen"
+    - run: env TEST_BIND=0 cargo xtask bindgen && git diff --exit-code HEAD
+    - run: cargo xtask bindgen
+    - run: cargo build --no-default-features
+    - run: cargo build --no-default-features --features "protobuf-codec"
+    - run: cargo build --no-default-features --features "prost-codec"
     - run: cargo build
     - run: cargo test --all
 

Cargo.toml

@@ -41,14 +41,14 @@ members = [
 exclude = ["xtask"]
 
 [features]
-default = ["protobuf-codec", "secure", "use-bindgen"]
+default = ["protobuf-codec", "boringssl"]
+_secure = []
 protobuf-codec = ["protobuf"]
 prost-codec = ["prost", "bytes"]
-secure = ["grpcio-sys/secure"]
-openssl = ["secure", "grpcio-sys/openssl"]
-openssl-vendored = ["secure", "grpcio-sys/openssl-vendored"]
+boringssl = ["grpcio-sys/boringssl", "_secure"]
+openssl = ["_secure", "grpcio-sys/openssl"]
+openssl-vendored = ["_secure", "grpcio-sys/openssl-vendored"]
 no-omit-frame-pointer = ["grpcio-sys/no-omit-frame-pointer"]
-use-bindgen = ["grpcio-sys/use-bindgen"]
 
 [badges]
 travis-ci = { repository = "tikv/grpc-rs" }

README.md

@@ -29,7 +29,6 @@ This project is still under development. The following features with the check m
 - Rust >= 1.36.0
 - binutils >= 2.22
 - LLVM and Clang >= 3.9 if you need to generate bindings at compile time.
-- By default, the [secure feature](#feature-secure) is provided by boringssl. You can also use openssl instead by enabling [openssl feature](#feature-openssl).
 
 For Linux and MacOS, you also need to install gcc 4.9+ (or clang) too.
 
@@ -93,9 +92,9 @@ To include this project as a dependency:
 grpcio = "0.6"
 ```
 
-### Feature `secure`
+### Feature `boringssl`
 
-`secure` feature enables support for TLS encryption and some authentication
+`boringssl` feature enables support for TLS encryption and some authentication
 mechanism. When you do not need it, for example when working in intranet,
 you can disable it by using the following configuration:
 ```

grpc-sys/Cargo.toml

@@ -53,21 +53,24 @@ openssl-sys = { version = "0.9", optional = true, features = ["vendored"] }
 libz-sys = { version = "1.1.3", default-features = false, features = ["libc", "static"] }
 
 [features]
-default = ["use-bindgen"]
-secure = ["boringssl-src"]
-openssl = ["secure"]
+# A hidden feature indicating that secure features should be enabled.
+_secure = []
+boringssl = ["boringssl-src", "_secure"]
+openssl = ["_secure"]
 openssl-vendored = ["openssl", "openssl-sys"]
 no-omit-frame-pointer = []
-# If this feature is disabled, bindgen will not be used and the previously generated bindings will
-# be compiled instead. This only work for the supported targets and will make compilation fails for
-# the other ones.
-use-bindgen = ["bindgen"]
+# A hidden feature that is used to force regenerating bindings.
+_gen-bindings = ["bindgen"]
+_list-package = []
+
+[target.'cfg(not(all(any(target_os = "linux", target_os = "macos"), any(target_arch = "x86_64", target_arch = "aarch64"))))'.build-dependencies]
+bindgen = "0.59.0"
 
 [build-dependencies]
 cc = "1.0"
 cmake = "0.1"
 pkg-config = "0.3"
 walkdir = "2.2.9"
 # Because of rust-lang/cargo#5237, bindgen should not be upgraded util a minor or major release.
-bindgen = { version = "0.57.0", default-features = false, optional = true, features = ["runtime"] }
-boringssl-src = { version = "0.4.0", optional = true }
+bindgen = { version = "0.59.0", default-features = false, optional = true, features = ["runtime"] }
+boringssl-src = { version = "0.5.0", optional = true }

grpc-sys/bindings/aarch64-unknown-linux-gnu-bindings.rs grpc-sys/bindings/bindings.rs

@@ -1,6 +1,8 @@
 // Copyright 2019 TiKV Project Authors. Licensed under Apache-2.0.
 
+use std::collections::HashSet;
 use std::env::VarError;
+use std::fs::File;
 use std::io::prelude::*;
 use std::io::BufReader;
 use std::path::{Path, PathBuf};
@@ -10,24 +12,9 @@ use cmake::Config as CmakeConfig;
 use pkg_config::{Config as PkgConfig, Library};
 use walkdir::WalkDir;
 
-const GRPC_VERSION: &str = "1.38.0";
+const GRPC_VERSION: &str = "1.44.0";
 
-/// Following two arrays are generated by running pkg-config manually. We can
-/// also choose to run pkg-config at build time, but it will requires pkg-config
-/// in path, which is unfriendly for platforms like Windows.
-// grpc_unsecure.pc is not accurate, see also grpc/grpc#24512. Should also include "address_sorting", "upb", "cares", "z".
-#[rustfmt::skip]
-const COMMON_DEPS: &[&str] = &[
-    "absl_bad_optional_access", "absl_bad_variant_access", "absl_base", "absl_city", "absl_civil_time",
-    "absl_cord", "absl_debugging_internal", "absl_demangle_internal", "absl_exponential_biased",
-    "absl_graphcycles_internal", "absl_hash", "absl_hashtablez_sampler", "absl_int128", "absl_log_severity",
-    "absl_malloc_internal", "absl_raw_hash_set", "absl_raw_logging_internal", "absl_spinlock_wait",
-    "absl_stacktrace", "absl_status", "absl_statusor", "absl_str_format_internal", "absl_strings",
-    "absl_strings_internal", "absl_symbolize", "absl_synchronization", "absl_throw_delegate", "absl_time",
-    "absl_time_zone", "absl_wyhash", "address_sorting", "cares", "gpr", "upb", "z",
-];
-const GRPC_DEPS: &[&str] = &["grpc", "re2"];
-const GRPC_UNSECURE_DEPS: &[&str] = &["grpc_unsecure"];
+include!("link-deps.rs");
 
 fn probe_library(library: &str, cargo_metadata: bool) -> Library {
     match PkgConfig::new()
@@ -99,6 +86,68 @@ fn clean_up_stale_cache(cxx_compiler: String) {
     }
 }
 
+/// List packages needed for linking in working directory.
+fn list_packages(dst: &Path) {
+    env::set_var(
+        "PKG_CONFIG_PATH",
+        format!("{}/lib/pkgconfig", dst.display()),
+    );
+    let mut cfg = PkgConfig::new();
+    cfg.print_system_cflags(false)
+        .print_system_libs(false)
+        .env_metadata(false)
+        .cargo_metadata(false)
+        .atleast_version(GRPC_VERSION);
+    let grpc = cfg.probe("grpc").unwrap();
+    let mut grpc_libs: HashSet<_> = grpc.libs.iter().cloned().collect();
+    let grpc_unsecure = cfg.probe("grpc_unsecure").unwrap();
+    let mut grpc_unsecure_libs: HashSet<_> = grpc_unsecure.libs.iter().cloned().collect();
+
+    // grpc_unsecure.pc is not accurate, see also grpc/grpc#24512. Should also include "address_sorting", "upb", "cares", "z".
+    grpc_unsecure_libs.extend(
+        ["address_sorting", "upb", "cares", "z"]
+            .iter()
+            .map(|s| s.to_string()),
+    );
+    // There is no "rt" on Windows and MacOS.
+    grpc_libs.remove("rt");
+    grpc_unsecure_libs.remove("rt");
+
+    // ssl, crypto is managed by us according to different features.
+    grpc_libs.remove("ssl");
+    grpc_libs.remove("crypto");
+
+    let mut common_libs: Vec<_> = grpc_libs.intersection(&grpc_unsecure_libs).collect();
+    let mut secure_only: Vec<_> = grpc_libs.difference(&grpc_unsecure_libs).collect();
+    let mut unsecure_only: Vec<_> = grpc_unsecure_libs.difference(&grpc_libs).collect();
+
+    common_libs.sort();
+    secure_only.sort();
+    unsecure_only.sort();
+
+    let outputs = &[
+        ("COMMON_DEPS", common_libs),
+        ("GRPC_DEPS", secure_only),
+        ("GRPC_UNSECURE_DEPS", unsecure_only),
+    ];
+
+    let mut f = File::create("link-deps.rs").unwrap();
+    f.write_all(
+        b"/// Following two arrays are generated by running pkg-config manually. We can
+/// also choose to run pkg-config at build time, but it will requires pkg-config
+/// in path, which is unfriendly for platforms like Windows.
+",
+    )
+    .unwrap();
+    for (name, libs) in outputs {
+        writeln!(f, "const {}: &[&str] = &[", name).unwrap();
+        for lib in libs {
+            writeln!(f, "\"{}\",", lib).unwrap();
+        }
+        writeln!(f, "];").unwrap();
+    }
+}
+
 fn build_grpc(cc: &mut cc::Build, library: &str) {
     prepare_grpc();
 
@@ -165,7 +214,7 @@ fn build_grpc(cc: &mut cc::Build, library: &str) {
         }
 
         // We don't need to generate install targets.
-        config.define("gRPC_INSTALL", "false");
+        config.define("gRPC_INSTALL", cfg!(feature = "_list-package").to_string());
         // We don't need to build csharp target.
         config.define("gRPC_BUILD_CSHARP_EXT", "false");
         // We don't need to build codegen target.
@@ -175,15 +224,16 @@ fn build_grpc(cc: &mut cc::Build, library: &str) {
 
         // `package` should only be set for secure feature, otherwise cmake will always search for
         // ssl library.
-        if cfg!(feature = "secure") {
+        if cfg!(feature = "_secure") {
             config.define("gRPC_SSL_PROVIDER", "package");
         }
-        #[cfg(feature = "secure")]
+        #[cfg(feature = "_secure")]
         if cfg!(feature = "openssl") {
             if cfg!(feature = "openssl-vendored") {
                 config.register_dep("openssl");
             }
         } else {
+            #[cfg(feature = "boringssl")]
             build_boringssl(&mut config);
         }
         if cfg!(feature = "no-omit-frame-pointer") {
@@ -193,7 +243,10 @@ fn build_grpc(cc: &mut cc::Build, library: &str) {
         }
         // Uses zlib from libz-sys.
         setup_libz(&mut config);
-        config.build_target(library).uses_cxx11().build()
+        if !cfg!(feature = "_list-package") {
+            config.build_target(library);
+        }
+        config.uses_cxx11().build()
     };
 
     let lib_suffix = if target.contains("msvc") {
@@ -212,6 +265,10 @@ fn build_grpc(cc: &mut cc::Build, library: &str) {
         }
     }
 
+    if cfg!(feature = "_list-package") {
+        list_packages(&dst);
+    }
+
     let libs = if library.contains("unsecure") {
         GRPC_UNSECURE_DEPS
     } else {
@@ -221,7 +278,7 @@ fn build_grpc(cc: &mut cc::Build, library: &str) {
         println!("cargo:rustc-link-lib=static={}", l);
     }
 
-    if cfg!(feature = "secure") {
+    if cfg!(feature = "_secure") {
         if cfg!(feature = "openssl") && !cfg!(feature = "openssl-vendored") {
             figure_ssl_path(&build_dir);
         } else {
@@ -260,7 +317,7 @@ fn figure_ssl_path(build_dir: &str) {
     println!("cargo:rustc-link-lib=crypto");
 }
 
-#[cfg(feature = "secure")]
+#[cfg(feature = "boringssl")]
 fn build_boringssl(config: &mut CmakeConfig) {
     let boringssl_artifact = boringssl_src::Build::new().build();
     config.define(
@@ -304,11 +361,17 @@ fn get_env(name: &str) -> Option<String> {
 
 // Generate the bindings to grpc C-core.
 // Try to disable the generation of platform-related bindings.
-#[cfg(feature = "use-bindgen")]
+#[cfg(any(
+    feature = "_gen-bindings",
+    not(all(
+        any(target_os = "linux", target_os = "macos"),
+        any(target_arch = "x86_64", target_arch = "aarch64")
+    ))
+))]
 fn bindgen_grpc(file_path: &Path) {
     // create a config to generate binding file
     let mut config = bindgen::Builder::default();
-    if cfg!(feature = "secure") {
+    if cfg!(feature = "_secure") {
         config = config.clang_arg("-DGRPC_SYS_SECURE");
     }
 
@@ -350,22 +413,23 @@ fn bindgen_grpc(file_path: &Path) {
         .impl_debug(true)
         .size_t_is_usize(true)
         .disable_header_comment()
-        .whitelist_function(r"\bgrpc_.*")
-        .whitelist_function(r"\bgpr_.*")
-        .whitelist_function(r"\bgrpcwrap_.*")
-        .whitelist_var(r"\bGRPC_.*")
-        .whitelist_type(r"\bgrpc_.*")
-        .whitelist_type(r"\bgpr_.*")
-        .whitelist_type(r"\bgrpcwrap_.*")
-        .whitelist_type(r"\bcensus_context.*")
-        .whitelist_type(r"\bverify_peer_options.*")
-        .blacklist_type(r"(__)?pthread.*")
-        .blacklist_function(r"\bgpr_mu_.*")
-        .blacklist_function(r"\bgpr_cv_.*")
-        .blacklist_function(r"\bgpr_once_.*")
-        .blacklist_type(r"gpr_mu")
-        .blacklist_type(r"gpr_cv")
-        .blacklist_type(r"gpr_once")
+        .allowlist_function(r"\bgrpc_.*")
+        .allowlist_function(r"\bgpr_.*")
+        .allowlist_function(r"\bgrpcwrap_.*")
+        .allowlist_var(r"\bGRPC_.*")
+        .allowlist_type(r"\bgrpc_.*")
+        .allowlist_type(r"\bgpr_.*")
+        .allowlist_type(r"\bgrpcwrap_.*")
+        .allowlist_type(r"\bcensus_context.*")
+        .allowlist_type(r"\bverify_peer_options.*")
+        // Block all system headers.
+        .blocklist_file(r"^/.*")
+        .blocklist_function(r"\bgpr_mu_.*")
+        .blocklist_function(r"\bgpr_cv_.*")
+        .blocklist_function(r"\bgpr_once_.*")
+        .blocklist_type(r"gpr_mu")
+        .blocklist_type(r"gpr_cv")
+        .blocklist_type(r"gpr_once")
         .constified_enum_module(r"grpc_status_code")
         .layout_tests(gen_tests)
         .default_enum_style(bindgen::EnumVariation::Rust {
@@ -379,38 +443,47 @@ fn bindgen_grpc(file_path: &Path) {
 }
 
 // Determine if need to update bindings. Supported platforms do not
-// need to be updated by default unless the UPDATE_BIND is specified.
+// need to be updated by default unless the _gen-bindings feature is specified.
 // Other platforms use bindgen to generate the bindings every time.
 fn config_binding_path() {
     let target = env::var("TARGET").unwrap();
     let file_path: PathBuf = match target.as_str() {
-        "x86_64-unknown-linux-gnu" | "aarch64-unknown-linux-gnu" => {
+        "x86_64-unknown-linux-gnu"
+        | "aarch64-unknown-linux-gnu"
+        | "x86_64-apple-darwin"
+        | "aarch64-apple-darwin" => {
             // Cargo treats nonexistent files changed, so we only emit the rerun-if-changed
             // directive when we expect the target-specific pre-generated binding file to be
             // present.
-            println!("cargo:rerun-if-changed=bindings/{}-bindings.rs", &target);
+            println!("cargo:rerun-if-changed=bindings/bindings.rs");
 
-            let file_path = PathBuf::from(env::var("CARGO_MANIFEST_DIR").unwrap())
+            PathBuf::from(env::var("CARGO_MANIFEST_DIR").unwrap())
                 .join("bindings")
-                .join(format!("{}-bindings.rs", &target));
-
-            #[cfg(feature = "use-bindgen")]
-            if env::var("UPDATE_BIND").is_ok() {
-                bindgen_grpc(&file_path);
-            }
-
-            file_path
-        }
-        _ => {
-            let file_path = PathBuf::from(env::var("OUT_DIR").unwrap()).join("grpc-bindings.rs");
-
-            #[cfg(feature = "use-bindgen")]
-            bindgen_grpc(&file_path);
-
-            file_path
+                .join("bindings.rs")
         }
+        _ => PathBuf::from(env::var("OUT_DIR").unwrap()).join("grpc-bindings.rs"),
     };
 
+    #[cfg(any(
+        feature = "_gen-bindings",
+        not(all(
+            any(target_os = "linux", target_os = "macos"),
+            any(target_arch = "x86_64", target_arch = "aarch64")
+        ))
+    ))]
+    {
+        // On some system (like Windows), stack size of main thread may
+        // be too small.
+        let f = file_path.clone();
+        std::thread::Builder::new()
+            .stack_size(8 * 1024 * 1024)
+            .name("bindgen_grpc".to_string())
+            .spawn(move || bindgen_grpc(&f))
+            .unwrap()
+            .join()
+            .unwrap();
+    }
+
     println!(
         "cargo:rustc-env=BINDING_PATH={}",
         file_path.to_str().unwrap()
@@ -420,12 +493,11 @@ fn config_binding_path() {
 fn main() {
     println!("cargo:rerun-if-changed=grpc_wrap.cc");
     println!("cargo:rerun-if-changed=grpc");
-    println!("cargo:rerun-if-env-changed=UPDATE_BIND");
 
     // create a builder to compile grpc_wrap.cc
     let mut cc = cc::Build::new();
 
-    let library = if cfg!(feature = "secure") {
+    let library = if cfg!(feature = "_secure") {
         cc.define("GRPC_SYS_SECURE", None);
         "grpc"
     } else {

grpc-sys/bindings/x86_64-unknown-linux-gnu-bindings.rs

@@ -118,15 +118,16 @@ grpcwrap_request_call_context_create() {
  * Destroys array->metadata.
  * The array pointer itself is not freed.
  */
-void grpcwrap_metadata_array_destroy_metadata_only(grpc_metadata_array* array) {
+GPR_EXPORT void grpcwrap_metadata_array_destroy_metadata_only(
+    grpc_metadata_array* array) {
   gpr_free(array->metadata);
 }
 
 /*
  * Destroys keys, values and array->metadata.
  * The array pointer itself is not freed.
  */
-void grpcwrap_metadata_array_destroy_metadata_including_entries(
+GPR_EXPORT void grpcwrap_metadata_array_destroy_metadata_including_entries(
     grpc_metadata_array* array) {
   size_t i;
   if (array->metadata) {
@@ -221,8 +222,8 @@ grpcwrap_metadata_array_shrink_to_fit(grpc_metadata_array* array) {
 }
 
 /* Move contents of metadata array */
-void grpcwrap_metadata_array_move(grpc_metadata_array* dest,
-                                  grpc_metadata_array* src) {
+GPR_EXPORT void grpcwrap_metadata_array_move(grpc_metadata_array* dest,
+                                             grpc_metadata_array* src) {
   if (!src) {
     dest->capacity = 0;
     dest->count = 0;

grpc-sys/build.rs

@@ -0,0 +1,56 @@
+/// Following two arrays are generated by running pkg-config manually. We can
+/// also choose to run pkg-config at build time, but it will requires pkg-config
+/// in path, which is unfriendly for platforms like Windows.
+const COMMON_DEPS: &[&str] = &[
+    "absl_bad_optional_access",
+    "absl_bad_variant_access",
+    "absl_base",
+    "absl_city",
+    "absl_civil_time",
+    "absl_cord",
+    "absl_cord_internal",
+    "absl_cordz_functions",
+    "absl_cordz_handle",
+    "absl_cordz_info",
+    "absl_debugging_internal",
+    "absl_demangle_internal",
+    "absl_exponential_biased",
+    "absl_graphcycles_internal",
+    "absl_hash",
+    "absl_hashtablez_sampler",
+    "absl_int128",
+    "absl_log_severity",
+    "absl_low_level_hash",
+    "absl_malloc_internal",
+    "absl_random_distributions",
+    "absl_random_internal_platform",
+    "absl_random_internal_pool_urbg",
+    "absl_random_internal_randen",
+    "absl_random_internal_randen_hwaes",
+    "absl_random_internal_randen_hwaes_impl",
+    "absl_random_internal_randen_slow",
+    "absl_random_internal_seed_material",
+    "absl_random_seed_gen_exception",
+    "absl_random_seed_sequences",
+    "absl_raw_hash_set",
+    "absl_raw_logging_internal",
+    "absl_spinlock_wait",
+    "absl_stacktrace",
+    "absl_status",
+    "absl_statusor",
+    "absl_str_format_internal",
+    "absl_strings",
+    "absl_strings_internal",
+    "absl_symbolize",
+    "absl_synchronization",
+    "absl_throw_delegate",
+    "absl_time",
+    "absl_time_zone",
+    "address_sorting",
+    "cares",
+    "gpr",
+    "upb",
+    "z",
+];
+const GRPC_DEPS: &[&str] = &["grpc", "re2"];
+const GRPC_UNSECURE_DEPS: &[&str] = &["grpc_unsecure"];

grpc-sys/grpc

@@ -13,15 +13,14 @@ categories = ["network-programming"]
 readme = "README.md"
 
 [features]
-default = ["protobuf-codec", "use-bindgen"]
+default = ["protobuf-codec"]
 protobuf-codec = ["grpcio/protobuf-codec", "protobuf"]
 prost-codec = ["grpcio/prost-codec", "prost"]
-use-bindgen = ["grpcio/use-bindgen"]
 
 [dependencies]
 futures-executor = "0.3"
 futures-util = { version = "0.3", default-features = false, features = ["std"] }
-grpcio = { path = "..", features = ["secure"], version = "0.9.0", default-features = false }
+grpcio = { path = "..", version = "0.9.0", default-features = false }
 prost = { version = "0.8", optional = true }
 protobuf = { version = "2", optional = true }
 log = "0.4"

grpc-sys/grpc_wrap.cc

@@ -13,13 +13,12 @@ categories = ["network-programming"]
 build = "build.rs"
 
 [features]
-default = ["protobuf-codec", "use-bindgen"]
+default = ["protobuf-codec"]
 protobuf-codec = ["grpcio/protobuf-codec", "protobuf-build/grpcio-protobuf-codec"]
 prost-codec = ["prost-derive", "prost-types", "bytes", "lazy_static", "grpcio/prost-codec", "prost", "protobuf-build/grpcio-prost-codec"]
-use-bindgen = ["grpcio/use-bindgen"]
 
 [dependencies]
-grpcio = { path = "..", features = ["secure"], version = "0.9.0", default-features = false }
+grpcio = { path = "..", features = ["boringssl"], version = "0.9.0", default-features = false }
 bytes = { version = "1.0", optional = true }
 prost = { version = "0.8", optional = true }
 prost-derive = { version = "0.8", optional = true }

grpc-sys/link-deps.rs

@@ -472,7 +472,7 @@ impl ChannelBuilder {
     }
 }
 
-#[cfg(feature = "secure")]
+#[cfg(feature = "_secure")]
 mod secure_channel {
     use std::borrow::Cow;
     use std::ffi::CString;

health/Cargo.toml

@@ -12,8 +12,10 @@ framework that puts mobile and HTTP/2 first. grpcio is built on [gRPC Core] and
 
 ## Optional features
 
-- **`secure`** *(enabled by default)* - Enables support for TLS encryption and some authentication
+- **`boringssl`** *(enabled by default)* - Enables support for TLS encryption and some authentication
   mechanisms.
+- **`openssl`** - Same as `boringssl`, but base on the system openssl.
+- **`openssl-vendored`** - Same as `openssl`, but build openssl from source.
 
 */
 
@@ -39,7 +41,7 @@ mod error;
 mod log_util;
 mod metadata;
 mod quota;
-#[cfg(feature = "secure")]
+#[cfg(feature = "_secure")]
 mod security;
 mod server;
 mod task;
@@ -73,7 +75,7 @@ pub use crate::error::{Error, Result};
 pub use crate::log_util::redirect_log;
 pub use crate::metadata::{Metadata, MetadataBuilder, MetadataIter};
 pub use crate::quota::ResourceQuota;
-#[cfg(feature = "secure")]
+#[cfg(feature = "_secure")]
 pub use crate::security::{
     CertificateRequestType, ChannelCredentials, ChannelCredentialsBuilder, ServerCredentials,
     ServerCredentialsBuilder, ServerCredentialsFetcher,

proto/Cargo.toml

@@ -77,7 +77,7 @@ fn join_host_port(host: &str, port: u16) -> String {
     }
 }
 
-#[cfg(feature = "secure")]
+#[cfg(feature = "_secure")]
 mod imp {
     use super::join_host_port;
     use crate::grpc_sys::{self, grpc_server};
@@ -135,7 +135,7 @@ mod imp {
     }
 }
 
-#[cfg(not(feature = "secure"))]
+#[cfg(not(feature = "_secure"))]
 mod imp {
     use super::join_host_port;
     use crate::grpc_sys::{self, grpc_server};
@@ -396,7 +396,7 @@ impl ServerBuilder {
     }
 }
 
-#[cfg(feature = "secure")]
+#[cfg(feature = "_secure")]
 mod secure_server {
     use super::{Binder, ServerBuilder};
     use crate::grpc_sys;

src/channel.rs

@@ -21,7 +21,7 @@ protobuf = { version = "2.22", optional = true }
 prost = { version = "0.8", optional = true }
 bytes = { version = "1.0", optional = true }
 log = "0.4"
-grpcio = { path = "..", version = "0.9", default-features = false, features = ["secure"] }
+grpcio = { path = "..", version = "0.9", default-features = false, features = ["boringssl"] }
 grpcio-health = { path = "../health", version = "0.9", default-features = false }
 
 [dev-dependencies]

src/lib.rs

@@ -17,6 +17,7 @@ fn print_help() {
     eprintln!("\tsubmodule\tInit necessary submodules for compilation");
     eprintln!("\tclang-lint\tLint cpp code in grpcio-sys package");
     eprintln!("\tcodegen\tGenerate rust code for all protocols");
+    eprintln!("\trefresh-package\tRegenerate grpc-sys/link-deps.rs to show the latest linking dependencies.");
 }
 
 fn cargo() -> Command {
@@ -30,29 +31,17 @@ fn cargo() -> Command {
 }
 
 fn exec(c: &mut Command) {
-    if let Err(e) = c.status() {
-        eprintln!("failed to execute {:?}: {}", c, e);
-        process::exit(-1);
-    }
-}
-
-fn find_default_arch() -> String {
-    let s = String::from_utf8(
-        Command::new("rustc")
-            .args(&["--print", "cfg"])
-            .output()
-            .unwrap()
-            .stdout,
-    )
-    .unwrap();
-    for l in s.lines() {
-        if let Some(arch) = l.strip_prefix("target_arch=") {
-            if !arch.is_empty() {
-                return arch[1..arch.len() - 1].to_string();
+    match c.status() {
+        Err(e) => {
+            eprintln!("failed to execute {:?}: {}", c, e);
+            process::exit(-1);
+        }
+        Ok(s) => {
+            if !s.success() {
+                process::exit(s.code().unwrap_or(-1));
             }
         }
     }
-    panic!("arch not found in {:?}", s);
 }
 
 fn remove_match(data: &str, pattern: impl Fn(&str) -> bool) -> String {
@@ -68,31 +57,11 @@ fn remove_match(data: &str, pattern: impl Fn(&str) -> bool) -> String {
 }
 
 fn bindgen() {
-    let arch = match env::var("ARCH") {
-        Ok(arch) => arch,
-        Err(_) => find_default_arch(),
-    };
-    let tuple = format!("{}-unknown-linux-gnu", arch);
     exec(
         cargo()
-            .env("UPDATE_BIND", "1")
-            .args(&["build", "-p", "grpcio-sys", "--target", &tuple]),
+            .current_dir("grpc-sys")
+            .args(&["build", "-p", "grpcio-sys", "--features", "_gen-bindings"]),
     );
-    for f in fs::read_dir("grpc-sys/bindings").unwrap() {
-        let p = f.unwrap().path();
-        let mut content = String::new();
-        File::open(&p)
-            .unwrap()
-            .read_to_string(&mut content)
-            .unwrap();
-        let content = remove_match(&content, |l| {
-            l.starts_with("pub type ") && l.contains("= ::std::os::raw::")
-        });
-        File::create(&p)
-            .unwrap()
-            .write_all(content.as_bytes())
-            .unwrap();
-    }
 }
 
 fn cmd(c: &str) -> Command {
@@ -264,6 +233,15 @@ fn codegen() {
     exec(cargo().args(&["fmt", "--all"]))
 }
 
+fn refresh_link_package() {
+    exec(
+        cargo()
+            .current_dir("grpc-sys")
+            .args(&["build", "-p", "grpcio-sys", "--features", "_list-package"]),
+    );
+    exec(Command::new("rustfmt").args(&["grpc-sys/link-deps.rs"]));
+}
+
 fn main() {
     let mut args = env::args();
     if args.len() != 2 {
@@ -277,6 +255,7 @@ fn main() {
         "submodule" => submodule(),
         "clang-lint" => clang_lint(),
         "codegen" => codegen(),
+        "refresh-package" => refresh_link_package(),
         _ => print_help(),
     }
 }