No static libs (#95)

* don't build or copy the static filename

* completely remove all cargo invocations or dependencies on compile time environment varibles. Specific the artifact path externally

* first stab at modified CI script

* change to how doxygen docs are built

* you have to run the Java tests ATM to produce the docs

* add ability to set the target triple when not building for host

* don't package FFI libs into the nuget that don't have a platform string

* map 2 MUSL targets to .NET rids

* simplify the defaults so that it's easy to use the CI script when developing

Author: jadamcrain

.github/workflows/ci.yml

@@ -79,29 +79,17 @@ jobs:
           toolchain: stable
           override: true
       - name: Install doxygen 1.9.3
-        run: wget -q https://www.doxygen.nl/files/doxygen-1.9.3.linux.bin.tar.gz -O- | sudo tar --strip-components=1 -C /usr -xz doxygen-1.9.3
+        run: wget -q https://www.doxygen.nl/files/doxygen-1.9.5.linux.bin.tar.gz -O- | sudo tar --strip-components=1 -C /usr -xz doxygen-1.9.5
       - name: Caching
         uses: Swatinem/rust-cache@v1
-      - name: Build
-        uses: actions-rs/cargo@v1
-        with:
-          command: build
-          args: --release
+      - name: Build FFI and JNI shared libraries
+        run: cargo build --release -p foo-ffi -p foo-ffi-java
       - name: C bindings
-        uses: actions-rs/cargo@v1
-        with:
-          command: run
-          args: --release --bin foo-bindings -- --c --doxygen
+        run: cargo run --release --bin foo-bindings -- --doxygen --c --no-tests  -a ./target/release
       - name: .NET bindings
-        uses: actions-rs/cargo@v1
-        with:
-          command: run
-          args: --release --bin foo-bindings -- --dotnet --doxygen
+        run: cargo run --release --bin foo-bindings -- --doxygen --dotnet --no-tests -a ./target/release
       - name: Java bindings
-        uses: actions-rs/cargo@v1
-        with:
-          command: run
-          args: --release --bin foo-bindings -- --java
+        run: cargo run --release --bin foo-bindings -- --java -a ./target/release
       - name: Extract documentation
         run: |
           mkdir -p ~/doc
@@ -144,20 +132,11 @@ jobs:
       - name: Build FFI and JNI
         run: cargo build -p foo-ffi -p foo-ffi-java --release --target ${{ matrix.target }}
       - name: C bindings
-        uses: actions-rs/cargo@v1
-        with:
-          command: run
-          args: --release --target ${{ matrix.target }} --bin foo-bindings -- --c ${{ matrix.extra-params }}
+        run: cargo run --release --bin foo-bindings -- --c ${{ matrix.extra-params }} -r ${{ matrix.target }} -a ./target/${{ matrix.target }}/release
       - name: .NET bindings
-        uses: actions-rs/cargo@v1
-        with:
-          command: run
-          args: --release --target ${{ matrix.target }} --bin foo-bindings -- --dotnet ${{ matrix.extra-params }}
+        run: cargo run --release --bin foo-bindings -- --dotnet ${{ matrix.extra-params }} -r ${{ matrix.target }} -a ./target/${{ matrix.target }}/release
       - name: Java bindings
-        uses: actions-rs/cargo@v1
-        with:
-          command: run
-          args: --release --target ${{ matrix.target }} --bin foo-bindings -- --java ${{ matrix.extra-params }}
+        run: cargo run --release --bin foo-bindings -- --java ${{ matrix.extra-params }} -r ${{ matrix.target }} -a ./target/${{ matrix.target }}/release
       - name: Upload compiled FFI modules
         uses: actions/upload-artifact@v2
         with:
@@ -190,20 +169,11 @@ jobs:
       - name: Build FFI and JNI
         run: cargo build -p foo-ffi -p foo-ffi-java --release
       - name: C bindings
-        uses: actions-rs/cargo@v1
-        with:
-          command: run
-          args: --release --bin foo-bindings -- --c
+        run: cargo run --release --bin foo-bindings -- --c
       - name: .NET bindings
-        uses: actions-rs/cargo@v1
-        with:
-          command: run
-          args: --release --bin foo-bindings -- --dotnet
+        run: cargo run --release --bin foo-bindings -- --dotnet
       - name: Java bindings
-        uses: actions-rs/cargo@v1
-        with:
-          command: run
-          args: --release --bin foo-bindings -- --java
+        run: cargo run --release --bin foo-bindings -- --java
       - name: Upload compiled FFI modules
         uses: actions/upload-artifact@v2
         with:
@@ -243,20 +213,12 @@ jobs:
           override: true
       - name: Install Rust Cross
         run: cargo install cross
-      - name: Build FFI and JNI
+      - name: Build FFI and JNI shared libraries
         run: cross build -p foo-ffi -p foo-ffi-java --release --target ${{ matrix.target }}
-      - name: C bindings
-        uses: actions-rs/cargo@v1
-        with:
-          use-cross: true
-          command: run
-          args: --release --target ${{ matrix.target }} --bin foo-bindings -- --c --no-tests
-      - name: Java bindings
-        uses: actions-rs/cargo@v1
-        with:
-          use-cross: true
-          command: run
-          args: --release --target ${{ matrix.target }} --bin foo-bindings -- --java --no-tests
+      - name: Generate C bindings
+        run: cargo run --release --bin foo-bindings -- --c --no-tests -r ${{ matrix.target }} -a ./target/${{ matrix.target }}/release
+      - name: Generate Java bindings
+        run: cargo run --release --bin foo-bindings -- --java --no-tests -r ${{ matrix.target }} -a ./target/${{ matrix.target }}/release
       - name: Upload compiled FFI modules
         uses: actions/upload-artifact@v2
         with:
@@ -293,10 +255,7 @@ jobs:
           name: ffi-modules
           path: ffi-modules
       - name: Package all bindings
-        uses: actions-rs/cargo@v1
-        with:
-          command: run
-          args: --bin foo-bindings -- --package ./ffi-modules
+        run: cargo run --bin foo-bindings -- --package ./ffi-modules
       - name: Upload .NET bindings
         uses: actions/upload-artifact@v2
         with:

ci-script/build.rs

@@ -42,7 +42,6 @@ impl BindingBuilder for CBindingBuilder {
                 output_dir: self.output_dir(),
                 ffi_target_name: self.settings.ffi_target_name,
                 ffi_name: self.settings.ffi_name,
-                is_release: env!("PROFILE") == "release",
                 extra_files: self.extra_files.clone(),
                 platform_location: platform.clone(),
                 generate_doxygen,

ci-script/src/builders/c.rs

@@ -1,6 +1,6 @@
 use crate::{BindingBuilder, BindingBuilderSettings};
 use dotnet_oo_bindgen::TargetFramework;
-use oo_bindgen::backend::PlatformLocations;
+use oo_bindgen::backend::{logged, PlatformLocations};
 use std::path::PathBuf;
 use std::process::Command;
 
@@ -48,7 +48,7 @@ impl BindingBuilder for DotnetBindingBuilder {
         if build_dir.exists() {
             std::fs::remove_dir_all(&build_dir).unwrap();
         }
-        std::fs::create_dir_all(&build_dir).unwrap();
+        logged::create_dir_all(&build_dir).unwrap();
 
         let config = dotnet_oo_bindgen::DotnetBindgenConfig {
             output_dir: build_dir,

ci-script/src/builders/dotnet.rs

@@ -53,7 +53,7 @@ impl BindingBuilder for JavaBindingBuilder {
         "java"
     }
 
-    fn generate(&mut self, is_packaging: bool, _generate_doxygen: bool) {
+    fn generate(&mut self, _is_packaging: bool, _generate_doxygen: bool) {
         let config = java_oo_bindgen::JavaBindgenConfig {
             java_output_dir: self.java_build_dir(),
             ffi_name: self.settings.ffi_name,
@@ -63,20 +63,6 @@ impl BindingBuilder for JavaBindingBuilder {
             platforms: self.platforms.clone(),
         };
 
-        // Generate Java JNI shared library if we are not packaging
-        if !is_packaging {
-            let mut cmd = Command::new("cargo");
-
-            cmd.args(&["build", "-p", self.settings.jni_target_name]);
-
-            if env!("PROFILE") == "release" {
-                cmd.arg("--release");
-            }
-
-            let result = cmd.status().unwrap();
-            assert!(result.success());
-        }
-
         // Clear/create Java generated files
         let build_dir = self.java_build_dir();
         if build_dir.exists() {

ci-script/src/builders/java.rs

@@ -14,6 +14,13 @@ pub(crate) struct Args {
     /// build the Java bindings
     #[arg(long = "java", default_value_t = false)]
     pub(crate) build_java: bool,
+    /// Path to where the compiled FFI/JNI shared libraries reside or a directory with multiple target triple dirs if packaging.
+    /// If not specified, ./release/target is assumed
+    #[arg(long = "artifact-dir", short = 'a')]
+    pub(crate) artifact_dir: Option<PathBuf>,
+    /// Target triple to use to lookup the platform for generation, otherwise assume the HOST platform.
+    #[arg(long = "target", short = 'r')]
+    pub(crate) target_triple: Option<String>,
     /// Target .NET framework, which indirectly determines the C# language version
     #[arg(value_enum, short = 't', long = "target-dotnet-framework", default_value_t = TargetFramework::NetStandard2_0)]
     pub(crate) target_framework: TargetFramework,
@@ -24,8 +31,8 @@ pub(crate) struct Args {
     #[arg(long = "no-tests", default_value_t = false)]
     pub(crate) no_tests: bool,
     /// Generate package from the provided directory
-    #[arg(long = "package")]
-    pub(crate) package: Option<PathBuf>,
+    #[arg(long = "package", short = 'k')]
+    pub(crate) package_dir: Option<PathBuf>,
     /// Path(s) to extra files to include in the generated bindings
     #[arg(short = 'f', long = "extra-files")]
     pub(crate) extra_files: Vec<PathBuf>,

ci-script/src/cli.rs

@@ -11,6 +11,7 @@ use std::rc::Rc;
 use oo_bindgen::backend::*;
 use oo_bindgen::model::Library;
 
+use crate::cli::Args;
 use clap::Parser;
 
 const SUPPORTED_PLATFORMS: &[&Platform] = &[
@@ -30,18 +31,16 @@ fn is_officially_supported(p: &Platform) -> bool {
 }
 
 pub fn run(settings: BindingBuilderSettings) {
-    let args = crate::cli::Args::parse();
+    let args: Args = crate::cli::Args::parse();
 
     let mut run_tests = !args.no_tests;
 
     // if no languages are selected, we build all of them
     let run_all = !args.build_c && !args.build_dotnet && !args.build_java;
 
-    let package = args.package.is_some();
-
     let mut platforms = PlatformLocations::new();
-    if let Some(package_src) = args.package {
-        for entry in fs::read_dir(package_src).unwrap() {
+    if let Some(dir) = &args.package_dir {
+        for entry in fs::read_dir(dir).unwrap() {
             let entry = entry.unwrap();
             let path = entry.path();
             if path.is_dir() {
@@ -51,14 +50,40 @@ pub fn run(settings: BindingBuilderSettings) {
             }
         }
     } else {
-        let current_platform =
-            Platform::guess_current().expect("could not determine current platform");
-        platforms.add(current_platform.clone(), ffi_path());
+        let artifact_dir = match args.artifact_dir {
+            Some(x) => {
+                tracing::info!("Artifact dir is {}", x.display());
+                x
+            }
+            None => {
+                let x: PathBuf = "./target/release".into();
+                tracing::info!("No artifact dir specified, assuming: {}", x.display());
+                x
+            }
+        };
+
+        let platform = match args.target_triple {
+            None => {
+                let platform =
+                    Platform::guess_current().expect("Could not determine current platform");
+                tracing::info!(
+                    "No target platform specified assuming target is the host platform: {}",
+                    platform
+                );
+                platform
+            }
+            Some(tt) => match Platform::find(&tt) {
+                None => panic!("Unable to determine Platform from target triple: {}", tt),
+                Some(x) => x,
+            },
+        };
+
+        platforms.add(platform.clone(), artifact_dir);
 
-        if !is_officially_supported(current_platform) {
+        if !is_officially_supported(platform) {
             println!(
                 "WARNING: building for an unsupported platform: {}",
-                current_platform.target_triple
+                platform.target_triple
             );
             if run_tests {
                 println!("Skipping tests an unsupported platform");
@@ -67,15 +92,21 @@ pub fn run(settings: BindingBuilderSettings) {
         }
     }
 
+    let is_packaging = args.package_dir.is_some();
+
     assert!(!platforms.is_empty(), "No platforms found!");
 
+    for p in platforms.iter() {
+        tracing::info!("Platform {} in {}", p.platform, p.location.display());
+    }
+
     if args.build_c || run_all {
         let mut builder = crate::builders::c::CBindingBuilder::new(
             settings.clone(),
             platforms.clone(),
             &args.extra_files,
         );
-        builder.run(run_tests, package, args.generate_doxygen);
+        builder.run(run_tests, is_packaging, args.generate_doxygen);
     }
     if args.build_dotnet || run_all {
         let mut builder = crate::builders::dotnet::DotnetBindingBuilder::new(
@@ -84,19 +115,15 @@ pub fn run(settings: BindingBuilderSettings) {
             platforms.clone(),
             &args.extra_files,
         );
-        builder.run(run_tests, package, args.generate_doxygen);
+        builder.run(run_tests, is_packaging, args.generate_doxygen);
     }
     if args.build_java || run_all {
         let mut builder =
             crate::builders::java::JavaBindingBuilder::new(settings, platforms, &args.extra_files);
-        builder.run(run_tests, package, args.generate_doxygen);
+        builder.run(run_tests, is_packaging, args.generate_doxygen);
     }
 }
 
-fn ffi_path() -> PathBuf {
-    [env!("TARGET_DIR"), "deps"].iter().collect()
-}
-
 #[derive(Clone)]
 pub struct BindingBuilderSettings {
     /// FFI target name (as specified in with `cargo build -p <...>`)