Merge pull request #41 from stepfunc/feature/ci-musl

Add musl generator in the CI

Author: emgre

.cargo/config-linux-musl.toml

@@ -0,0 +1,3 @@
+[build]
+target = "x86_64-unknown-linux-musl"
+rustflags = ["-C", "target-feature=+crt-static"]

.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

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,

generators/c-oo-bindgen/src/lib.rs

@@ -785,11 +785,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 {

generators/dotnet-oo-bindgen/src/lib.rs

@@ -110,7 +110,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()))?;

generators/java-oo-bindgen/src/java/mod.rs

@@ -29,7 +29,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)?;
@@ -127,16 +131,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| {
@@ -147,6 +141,7 @@ fn generate_native_func_class(lib: &Library, config: &JavaBindgenConfig) -> Form
                                 ))
                             })?;
                         }
+                        Platform::LinuxMusl => (), // We do not generate Java bindings for Linux musl
                     }
                 }
                 Ok(())

oo-bindgen/src/platforms.rs

@@ -3,30 +3,36 @@ use std::path::PathBuf;
 #[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
 pub enum Platform {
     Win64,
-    Win32,
     Linux,
+    LinuxMusl,
 }
 
 impl Platform {
     pub fn current() -> Self {
-        if cfg!(target_os = "windows") && cfg!(target_pointer_width = "32") {
-            return Self::Win32;
-        }
         if cfg!(target_os = "windows") && cfg!(target_pointer_width = "64") {
             return Self::Win64;
         }
-        if cfg!(target_os = "linux") && cfg!(target_pointer_width = "64") {
+        if cfg!(target_os = "linux")
+            && cfg!(target_pointer_width = "64")
+            && !cfg!(target_env = "musl")
+        {
             return Self::Linux;
         }
+        if cfg!(target_os = "linux")
+            && cfg!(target_pointer_width = "64")
+            && cfg!(target_env = "musl")
+        {
+            return Self::LinuxMusl;
+        }
 
         unimplemented!("Current platform is not supported")
     }
 
     pub fn to_string(&self) -> &'static str {
         match self {
             Self::Win64 => "win-x64",
-            Self::Win32 => "win-x32",
             Self::Linux => "linux",
+            Self::LinuxMusl => "linux-musl",
         }
     }
 }
@@ -43,40 +49,42 @@ impl PlatformLocation {
 
     pub fn lib_filename<T: AsRef<str>>(&self, libname: T) -> String {
         match self.platform {
-            Platform::Win64 | Platform::Win32 => format!("{}.dll.lib", libname.as_ref()),
+            Platform::Win64 => format!("{}.dll.lib", libname.as_ref()),
             Platform::Linux => format!("lib{}.so", libname.as_ref()),
+            Platform::LinuxMusl => format!("lib{}.a", libname.as_ref()),
         }
     }
 
     pub fn bin_filename<T: AsRef<str>>(&self, libname: T) -> String {
         match self.platform {
-            Platform::Win64 | Platform::Win32 => format!("{}.dll", libname.as_ref()),
+            Platform::Win64 => format!("{}.dll", libname.as_ref()),
             Platform::Linux => format!("lib{}.so", libname.as_ref()),
+            Platform::LinuxMusl => format!("lib{}.a", libname.as_ref()),
         }
     }
 }
 
 #[derive(Clone)]
 pub struct PlatformLocations {
     pub win64: Option<PathBuf>,
-    pub win32: Option<PathBuf>,
     pub linux: Option<PathBuf>,
+    pub linux_musl: Option<PathBuf>,
 }
 
 impl PlatformLocations {
     pub fn new() -> Self {
         PlatformLocations {
             win64: None,
-            win32: None,
             linux: None,
+            linux_musl: None,
         }
     }
 
     pub fn add(&mut self, platform: Platform, location: PathBuf) {
         match platform {
             Platform::Win64 => self.win64 = Some(location),
-            Platform::Win32 => self.win32 = Some(location),
             Platform::Linux => self.linux = Some(location),
+            Platform::LinuxMusl => self.linux_musl = Some(location),
         }
     }
 
@@ -85,17 +93,21 @@ impl PlatformLocations {
         if let Some(loc) = &self.win64 {
             vec.push(PlatformLocation::new(Platform::Win64, loc.clone()))
         }
-        if let Some(loc) = &self.win32 {
-            vec.push(PlatformLocation::new(Platform::Win32, loc.clone()))
-        }
         if let Some(loc) = &self.linux {
             vec.push(PlatformLocation::new(Platform::Linux, loc.clone()))
         }
+        if let Some(loc) = &self.linux_musl {
+            vec.push(PlatformLocation::new(Platform::LinuxMusl, loc.clone()))
+        }
         vec.into_iter()
     }
 
     pub fn is_empty(&self) -> bool {
-        self.win64.is_none() && self.win32.is_none() && self.linux.is_none()
+        self.win64.is_none() && self.linux.is_none() && self.linux_musl.is_none()
+    }
+
+    pub fn has_dynamic_lib(&self) -> bool {
+        self.win64.is_some() || self.linux.is_some()
     }
 }