Merge pull request #25 from jjs-dev/ci-matrix

MikailBag · web-flow · commit 5bf59594c68f · 2020-11-04T15:11:27.000+03:00
Use build matrix in CI tests
diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml
@@ -33,38 +33,32 @@ jobs:
       - name: Run clippy
         run: |
           cargo clippy --workspace -- -Dclippy::all -Dwarnings
-  check-platform-support:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions-rs/toolchain@v1.0.6
-        with:
-          toolchain: stable
-      - name: Remove cargo config
-        run: rm -rf .cargo
-      - name: Check musl
-        run: |
-          rustup target add x86_64-unknown-linux-musl
-          cargo check -p minion -p minion-ffi -p minion-cli --target x86_64-unknown-linux-musl
-  tests:
-    runs-on: ubuntu-latest
+  tests-linux:
+    strategy:
+      matrix:
+        os: 
+          - 'ubuntu-latest'
+          - 'macos-latest'
+        rust-target:
+          - 'x86_64-unknown-linux-gnu'
+          - 'x86_64-unknown-linux-musl'
+        cgroups:
+          - 'cgroup-v1'
+          - 'cgroup-v2'
+    runs-on: ${{ matrix.os }}
     steps:
       - uses: actions/checkout@v2
       - uses: actions-rs/toolchain@v1.0.6
         with: 
-          toolchain: nightly
+          toolchain: stable
           override: true
-      - name: Compile tests
-        run: |
-          rm -rf .cargo
-          cd minion-tests 
-          TARGET=x86_64-unknown-linux-musl
-          rustup target add $TARGET
-          cargo build -Zunstable-options --out-dir=../out --target=$TARGET
-      - name: Run tests
-        run: |
-          sudo ./out/minion-tests --trace
-        timeout-minutes: 3 
+      - name: Test
+        run: bash ci/linux.sh
+        timeout-minutes: 10
+        env:
+          CI_TARGET: ${{ matrix.rust-target }}
+          CI_CGROUPS: ${{ matrix.cgroups }}
+          CI_OS: ${{ matrix.os }}
       - name: Collect logs
         if: always()
         run: |
@@ -75,6 +69,7 @@ jobs:
         with:
           path: /tmp/logs
           name: tests-trace
+
   nightly-checks:
     runs-on: ubuntu-latest
     steps:
diff --git a/ci/linux.sh b/ci/linux.sh
@@ -0,0 +1,75 @@
+set -euo pipefail
+echo "::group::Info"
+echo "Target: $CI_TARGET"
+echo "Cgroup version: $CI_CGROUPS"
+echo "Operating system: $CI_OS"
+
+echo "this is hack, ignore this file" >> ./stracez-dummy 
+
+if [[ $CI_OS == "ubuntu-latest" ]]; then
+  if [[ $CI_CGROUPS == "cgroup-v2" ]]; then
+    echo "Skipping: cgroup v2 runs in macos"
+    exit 0
+  fi
+fi 
+if [[ $CI_OS == "macos-latest" ]]; then
+  if [[ $CI_CGROUPS == "cgroup-v1" ]]; then
+    echo "Skipping: cgroup v1 does not need virtualization"
+    exit 0
+  fi
+  if [[ $CI_TARGET == "x86_64-unknown-linux-gnu" ]]; then
+    echo "Skipping: we will not run test on gnu targets anyway"
+    exit 0
+  fi
+fi
+
+echo "::group::Preparing"
+
+if [[ $CI_CGROUPS == "cgroup-v2" ]] && [ -z "${CI_VM+set}" ]; then
+  echo "::group::Preparing virtual machine"
+  vagrant --version
+cat > Vagrantfile <<EOF
+Vagrant.configure("2") do |config|
+  config.vm.box = "fedora/32-cloud-base"
+
+  config.vm.provider "virtualbox" do |vb|
+    vb.memory = "900"
+  end
+end
+EOF
+  top -l 1
+  cat Vagrantfile
+  sudo vagrant up
+  echo "::group::Installing packages"
+  sudo vagrant ssh --command "sudo dnf install -y gcc gcc-c++ strace"
+  echo "::group::Installing rust"
+  sudo vagrant ssh --command "curl https://sh.rustup.rs -sSf | sh -s -- -y --profile minimal --default-toolchain stable"
+  echo "::group::Entering VM"
+  sudo vagrant ssh --command "bash -c 'cd /vagrant && CI_OS=$CI_OS CI_CGROUPS=$CI_CGROUPS CI_TARGET=$CI_TARGET CI_VM=1 bash ci/linux.sh'"
+  exit 0
+fi
+
+rustup target add $CI_TARGET  
+
+if [[ $CI_CGROUPS == "cgroup-v2" ]]; then
+  echo "::group::Some cgroup hacks"
+  sudo mkdir /sys/fs/cgroup/minion
+  echo "+cpu +memory +pids" | sudo tee /sys/fs/cgroup/cgroup.subtree_control | sudo tee /sys/fs/cgroup/minion/cgroup.subtree_control
+fi
+
+echo "::group::Compiling tests"
+echo '[build]
+rustflags=["--cfg", "minion_ci"]' > .cargo/config
+
+export RUSTC_BOOTSTRAP=1
+cargo build -p minion-tests -Zunstable-options --out-dir=./out --target=$CI_TARGET
+
+echo "::group::Skip running if needed"
+if [[ $CI_TARGET == "x86_64-unknown-linux-gnu" ]]; then
+  echo "skipping: static binary required on linux"
+  exit 0
+fi
+
+echo "::group::Running tests"
+sudo --preserve-env ./out/minion-tests --trace
+
diff --git a/minion-tests/src/master.rs b/minion-tests/src/master.rs
@@ -84,6 +84,11 @@ fn execute_single_test(case: &dyn TestCase, exec_opts: ExecuteOptions) -> Outcom
     };
 
     cmd.env_clear();
+    if cfg!(minion_ci) {
+        if let Ok(cgroups) = std::env::var("CI_CGROUPS") {
+            cmd.env("CI_CGROUPS", cgroups);
+        }
+    }
     cmd.env(crate::WORKER_ENV_NAME, "1");
     cmd.env("TEST", case.name());
     let status = cmd.status().unwrap();
diff --git a/src/linux/cgroup.rs b/src/linux/cgroup.rs
@@ -73,14 +73,14 @@ impl Driver {
     pub(in crate::linux) fn new(
         settings: &crate::linux::Settings,
     ) -> Result<Driver, crate::linux::Error> {
-        let cgroup_version = detect::CgroupVersion::detect();
+        // TODO: take cgroupfs as prefix
+        let (cgroup_version, cgroupfs_path) = detect::CgroupVersion::detect(None);
         let mut cgroup_prefix = Vec::new();
         for comp in settings.cgroup_prefix.components() {
             if let std::path::Component::Normal(n) = comp {
                 cgroup_prefix.push(n.to_os_string());
             }
         }
-        let cgroupfs_path = "/sys/fs/cgroup".into();
         Ok(Driver {
             version: cgroup_version,
             cgroup_prefix,
@@ -92,7 +92,7 @@ impl Driver {
         cgroup_id: &str,
         limits: &ResourceLimits,
     ) -> JoinHandle {
-        match CgroupVersion::detect() {
+        match self.version {
             CgroupVersion::V1 => JoinHandle::V1(self.setup_cgroups_v1(limits, cgroup_id)),
             CgroupVersion::V2 => JoinHandle::V2(self.setup_cgroups_v2(limits, cgroup_id)),
         }
diff --git a/src/linux/cgroup/detect.rs b/src/linux/cgroup/detect.rs
@@ -1,4 +1,7 @@
 //! This module is responsible for CGroup version detection
+
+use std::path::PathBuf;
+
 #[derive(Eq, PartialEq, Debug)]
 pub(in crate::linux) enum CgroupVersion {
     /// Legacy
@@ -8,21 +11,34 @@ pub(in crate::linux) enum CgroupVersion {
 }
 
 impl CgroupVersion {
-    pub(in crate::linux) fn detect() -> CgroupVersion {
-        let stat = nix::sys::statfs::statfs("/sys/fs/cgroup")
-            .expect("/sys/fs/cgroup is not root of cgroupfs");
+    pub(in crate::linux) fn detect(hint: Option<PathBuf>) -> (CgroupVersion, PathBuf) {
+        let path = hint
+            .or_else(|| Some(std::env::var_os("MINION_CGROUPFS")?.into()))
+            .unwrap_or_else(|| "/sys/fs/cgroup".into());
+        let stat = nix::sys::statfs::statfs(&path)
+            .unwrap_or_else(|_| panic!("{} is not root of cgroupfs", path.display()));
         let ty = stat.filesystem_type();
         // man 2 statfs
         match ty.0 {
-            0x0027_e0eb => return CgroupVersion::V1,
-            0x6367_7270 => return CgroupVersion::V2,
+            0x0027_e0eb => return (CgroupVersion::V1, path),
+            0x6367_7270 => return (CgroupVersion::V2, path),
             _ => (),
         };
-        let p = std::path::Path::new("/sys/fs/cgroup");
-        if p.join("cgroup.subtree_control").exists() {
+        let vers = if path.join("cgroup.subtree_control").exists() {
             CgroupVersion::V2
         } else {
             CgroupVersion::V1
+        };
+
+        if cfg!(minion_ci) {
+            let expected_version = match std::env::var("CI_CGROUPS").unwrap().as_str() {
+                "cgroup-v1" => CgroupVersion::V1,
+                "cgroup-v2" => CgroupVersion::V2,
+                _ => panic!(),
+            };
+
+            assert_eq!(vers, expected_version);
         }
+        (vers, path)
     }
 }
diff --git a/src/linux/check.rs b/src/linux/check.rs
@@ -78,7 +78,7 @@ fn find_lca<'a>(a: &'a [String], b: &'a [String]) -> &'a [String] {
 
 /// `crate::check()` on linux
 pub fn check() -> Result<(), String> {
-    if CgroupVersion::detect() == CgroupVersion::V1 {
+    if CgroupVersion::detect(None).0 == CgroupVersion::V1 {
         if unsafe { libc::geteuid() } != 0 {
             return Err("Root is required to use legacy cgroups".to_string());
         }

Original file line number	Diff line number	Diff line change
`@@ -78,7 +78,7 @@ fn find_lca<'a>(a: &'a [String], b: &'a [String]) -> &'a [String] {`
`78`	`78`
`79`	`79`	/// `crate::check()` on linux
`80`	`80`	`pub fn check() -> Result<(), String> {`
`81`		`- if CgroupVersion::detect() == CgroupVersion::V1 {`
	`81`	`+ if CgroupVersion::detect(None).0 == CgroupVersion::V1 {`
`82`	`82`	`if unsafe { libc::geteuid() } != 0 {`
`83`	`83`	`return Err("Root is required to use legacy cgroups".to_string());`
`84`	`84`	`}`