Add musl generator in the CI.

emgre · emgre · commit efc79ec8ae55 · 2021-02-15T14:54:02.000-05:00
diff --git a/.cargo/config-linux-musl.toml b/.cargo/config-linux-musl.toml
@@ -0,0 +1,3 @@
+[build]
+target = "x86_64-unknown-linux-musl"
+rustflags = ["-C", "target-feature=+crt-static"]
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -16,24 +16,43 @@ jobs:
           - stable
           - beta
           - nightly
+        toolchain:
+          - default
+          - musl
+        exclude:
+          - os: windows-latest
+            toolchain: musl
     runs-on: ${{ matrix.os }}
     steps:
       - name: Checkout
         uses: actions/checkout@v1
       - name: Install Rust ${{ matrix.rust }}
+        if: ${{ matrix.toolchain != 'musl' }}
         uses: actions-rs/toolchain@v1
         with:
           profile: minimal
           toolchain: ${{ matrix.rust }}
           override: true
+      - name: Install Rust ${{ matrix.rust }} (musl)
+        if: ${{ matrix.toolchain == 'musl' }}
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: ${{ matrix.rust }}
+          target: x86_64-unknown-linux-musl
+          override: true
       - name: Copy Windows config
         if: ${{ runner.os == 'Windows' }}
         shell: pwsh
         run: Copy-Item -Path .cargo/config-windows.toml -Destination .cargo/config.toml
       - name: Copy Linux config
-        if: ${{ runner.os == 'Linux' }}
+        if: ${{ runner.os == 'Linux' && matrix.toolchain == 'default' }}
         shell: pwsh
         run: Copy-Item -Path .cargo/config-linux.toml -Destination .cargo/config.toml
+      - name: Copy Linux musl config
+        if: ${{ runner.os == 'Linux' && matrix.toolchain == 'musl' }}
+        shell: pwsh
+        run: Copy-Item -Path .cargo/config-linux-musl.toml -Destination .cargo/config.toml
       - name: Run Rust unit tests
         uses: actions-rs/cargo@v1
         with:
@@ -44,11 +63,13 @@ jobs:
           command: run
           args: --release --bin foo-bindings -- --c
       - name: .NET bindings
+        if: ${{ matrix.toolchain != 'musl' }}
         uses: actions-rs/cargo@v1
         with:
           command: run
           args: --release --bin foo-bindings -- --dotnet
       - name: Java bindings
+        if: ${{ matrix.toolchain != 'musl' }}
         uses: actions-rs/cargo@v1
         with:
           command: run
@@ -60,7 +81,7 @@ jobs:
           name: ffi-modules
           path: tests/bindings/c/generated/lib
       - name: Upload compiled Java bindings
-        if: ${{ matrix.rust == 'stable' }}
+        if: ${{ matrix.rust == 'stable' && matrix.toolchain != 'musl' }}
         uses: actions/upload-artifact@v2
         with:
           name: ffi-modules
diff --git a/ci-script/src/lib.rs b/ci-script/src/lib.rs
@@ -80,25 +80,25 @@ fn run_builder<'a, B: BindingBuilder<'a>>(
 ) -> B {
     let mut platforms = PlatformLocations::new();
     if let Some(package_src) = package_src {
-        let platform_path = [package_src, Platform::Linux.to_string()]
+        let platform_path = [package_src, Platform::Win64.to_string()]
             .iter()
             .collect::<PathBuf>();
         if platform_path.is_dir() {
-            platforms.add(Platform::Linux, platform_path);
+            platforms.add(Platform::Win64, platform_path);
         }
 
-        let platform_path = [package_src, Platform::Win64.to_string()]
+        let platform_path = [package_src, Platform::Linux.to_string()]
             .iter()
             .collect::<PathBuf>();
         if platform_path.is_dir() {
-            platforms.add(Platform::Win64, platform_path);
+            platforms.add(Platform::Linux, platform_path);
         }
 
-        let platform_path = [package_src, Platform::Win32.to_string()]
+        let platform_path = [package_src, Platform::LinuxMusl.to_string()]
             .iter()
             .collect::<PathBuf>();
         if platform_path.is_dir() {
-            platforms.add(Platform::Win32, platform_path);
+            platforms.add(Platform::LinuxMusl, platform_path);
         }
     } else {
         platforms.add(Platform::current(), ffi_path());
@@ -108,7 +108,18 @@ fn run_builder<'a, B: BindingBuilder<'a>>(
         panic!("No platforms found!");
     }
 
+    let has_dynamic_libs = platforms.has_dynamic_lib();
+
     let mut builder = B::new(settings, platforms);
+
+    if B::requires_dynamic_lib() && !has_dynamic_libs {
+        println!(
+            "Skipping {} because it requires dynamic libraries",
+            B::name()
+        );
+        return builder;
+    }
+
     builder.generate(package_src.is_some());
 
     if package_src.is_none() {
@@ -132,6 +143,8 @@ pub struct BindingBuilderSettings<'a> {
 }
 
 trait BindingBuilder<'a> {
+    fn name() -> &'static str;
+    fn requires_dynamic_lib() -> bool;
     fn new(settings: &'a BindingBuilderSettings<'a>, platforms: PlatformLocations) -> Self;
     fn generate(&mut self, is_packaging: bool);
     fn build(&mut self);
@@ -175,6 +188,14 @@ impl<'a> CBindingBuilder<'a> {
 }
 
 impl<'a> BindingBuilder<'a> for CBindingBuilder<'a> {
+    fn name() -> &'static str {
+        "c"
+    }
+
+    fn requires_dynamic_lib() -> bool {
+        false
+    }
+
     fn new(settings: &'a BindingBuilderSettings<'a>, platforms: PlatformLocations) -> Self {
         Self {
             settings,
@@ -256,6 +277,14 @@ impl<'a> DotnetBindingBuilder<'a> {
 }
 
 impl<'a> BindingBuilder<'a> for DotnetBindingBuilder<'a> {
+    fn name() -> &'static str {
+        "dotnet"
+    }
+
+    fn requires_dynamic_lib() -> bool {
+        true
+    }
+
     fn new(settings: &'a BindingBuilderSettings<'a>, platforms: PlatformLocations) -> Self {
         Self {
             settings,
@@ -359,6 +388,14 @@ impl<'a> JavaBindingBuilder<'a> {
 }
 
 impl<'a> BindingBuilder<'a> for JavaBindingBuilder<'a> {
+    fn name() -> &'static str {
+        "java"
+    }
+
+    fn requires_dynamic_lib() -> bool {
+        true
+    }
+
     fn new(settings: &'a BindingBuilderSettings<'a>, platforms: PlatformLocations) -> Self {
         Self {
             settings,
diff --git a/generators/c-oo-bindgen/src/lib.rs b/generators/c-oo-bindgen/src/lib.rs
@@ -46,7 +46,7 @@ clippy::all
 
 use crate::doc::*;
 use crate::formatting::*;
-use heck::{CamelCase, SnakeCase};
+use heck::{CamelCase, ShoutySnakeCase, SnakeCase};
 use oo_bindgen::callback::*;
 use oo_bindgen::class::*;
 use oo_bindgen::doc::*;
@@ -760,11 +760,44 @@ fn generate_cmake_config(lib: &Library, config: &CBindgenConfig) -> FormattingRe
 
     // Write each platform variation
     let mut is_first_if = true;
+
+    // Add a config value if we have two linux versions
+    let has_static_choice =
+        if config.platforms.linux.is_some() && config.platforms.linux_musl.is_some() {
+            f.writeln(&format!(
+            "set({}_STATIC_MUSL OFF CACHE BOOL \"Use statically built musl lib on Linux for {}\")",
+            lib.name.to_shouty_snake_case(),
+            lib.name
+        ))?;
+            f.newline()?;
+            true
+        } else {
+            false
+        };
+
     for p in config.platforms.iter() {
         let platform_check = match p.platform {
-            Platform::Win64 => "WIN32 AND CMAKE_SIZEOF_VOID_P EQUAL 8",
-            Platform::Win32 => "WIN32 AND CMAKE_SIZEOF_VOID_P EQUAL 4",
-            Platform::Linux => "UNIX AND CMAKE_SIZEOF_VOID_P EQUAL 8",
+            Platform::Win64 => "WIN32 AND CMAKE_SIZEOF_VOID_P EQUAL 8".to_string(),
+            Platform::Linux => {
+                if !has_static_choice {
+                    "UNIX AND CMAKE_SIZEOF_VOID_P EQUAL 8".to_string()
+                } else {
+                    format!(
+                        "UNIX AND CMAKE_SIZEOF_VOID_P EQUAL 8 AND NOT $CACHE{{{}_STATIC_MUSL}}",
+                        lib.name.to_shouty_snake_case()
+                    )
+                }
+            }
+            Platform::LinuxMusl => {
+                if !has_static_choice {
+                    "UNIX AND CMAKE_SIZEOF_VOID_P EQUAL 8".to_string()
+                } else {
+                    format!(
+                        "UNIX AND CMAKE_SIZEOF_VOID_P EQUAL 8 AND $CACHE{{{}_STATIC_MUSL}}",
+                        lib.name.to_shouty_snake_case()
+                    )
+                }
+            }
         };
 
         if is_first_if {
diff --git a/generators/dotnet-oo-bindgen/src/lib.rs b/generators/dotnet-oo-bindgen/src/lib.rs
@@ -108,7 +108,11 @@ fn generate_csproj(lib: &Library, config: &DotnetBindgenConfig) -> FormattingRes
     f.newline()?;
     f.writeln("  <ItemGroup>")?;
 
-    for p in config.platforms.iter() {
+    for p in config
+        .platforms
+        .iter()
+        .filter(|x| x.platform != Platform::LinuxMusl)
+    {
         let filename = p.bin_filename(&config.ffi_name);
         let filepath = dunce::canonicalize(p.location.join(&filename))?;
         f.writeln(&format!("    <Content Include=\"{}\" Link=\"{}\" Pack=\"true\" PackagePath=\"runtimes/{}/native\" CopyToOutputDirectory=\"PreserveNewest\" />", filepath.to_string_lossy(), filename, p.platform.to_string()))?;
diff --git a/generators/java-oo-bindgen/src/java/mod.rs b/generators/java-oo-bindgen/src/java/mod.rs
@@ -28,7 +28,11 @@ pub fn generate_java_bindings(lib: &Library, config: &JavaBindgenConfig) -> Form
     // Copy the compiled libraries to the resource folder
     let mut ffi_name = config.ffi_name.clone();
     ffi_name.push_str("_java");
-    for platform in config.platforms.iter() {
+    for platform in config
+        .platforms
+        .iter()
+        .filter(|x| x.platform != Platform::LinuxMusl)
+    {
         let mut target_dir = config.java_resource_dir();
         target_dir.push(platform.platform.to_string());
         fs::create_dir_all(&target_dir)?;
@@ -125,16 +129,6 @@ fn generate_native_func_class(lib: &Library, config: &JavaBindgenConfig) -> Form
                                 ))
                             })?;
                         }
-                        Platform::Win32 => {
-                            f.writeln("if(org.apache.commons.lang3.SystemUtils.IS_OS_WINDOWS && org.apache.commons.lang3.ArchUtils.getProcessor().is32Bit())")?;
-                            blocked(f, |f| {
-                                f.writeln(&format!(
-                                    "loadLibrary(\"{}\", \"{}\", \"dll\");",
-                                    platform.platform.to_string(),
-                                    libname
-                                ))
-                            })?;
-                        }
                         Platform::Linux => {
                             f.writeln("if(org.apache.commons.lang3.SystemUtils.IS_OS_LINUX && org.apache.commons.lang3.ArchUtils.getProcessor().is64Bit())")?;
                             blocked(f, |f| {
@@ -145,6 +139,7 @@ fn generate_native_func_class(lib: &Library, config: &JavaBindgenConfig) -> Form
                                 ))
                             })?;
                         }
+                        Platform::LinuxMusl => (), // We do not generate Java bindings for Linux musl
                     }
                 }
                 Ok(())
diff --git a/oo-bindgen/src/platforms.rs b/oo-bindgen/src/platforms.rs
diff --git a/tests/foo-ffi/Cargo.toml b/tests/foo-ffi/Cargo.toml

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+[build]`
	`2`	`+target = "x86_64-unknown-linux-musl"`
	`3`	`+rustflags = ["-C", "target-feature=+crt-static"]`