ppc/mize
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

packaging stuff

Browse Source
This commit is contained in:
Sebastian Moser
2025-04-30 17:00:54 +02:00
parent d9ee9b5be4
commit 2fcc3da677
6 changed files with 305 additions and 256 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Cargo.toml
View File

@@ -1,6 +1,6 @@
[package] [package]
name = "mize" name = "mize"
version = "0.0.0" version = "0.0.1"
edition = "2021" edition = "2021"
license = "GPL-3.0" license = "GPL-3.0"
description = 'A strongly typed "filesystem" for the age of connectivity.' description = 'A strongly typed "filesystem" for the age of connectivity.'

2
dev Normal file
View File

@@ -0,0 +1,2 @@
nix develop . --override-input nixpkgs github:NixOS/nixpkgs/ea6033ce4ddf2c0ede2ea147a450d4f880796128

17
flake.nix
View File

@@ -73,7 +73,7 @@ let
mizeLib = import ./lib.nix { mizeLib = import ./lib.nix {
inherit inputs nixpkgs pkgs self osCrane defaultMizeConfig mize_modules; inherit inputs nixpkgs pkgs self osCrane defaultMizeConfig mize_modules;
inherit rust-overlay crane fenix; inherit rust-overlay crane fenix;
localSystem = system; buildSystem = system;
stdenv = pkgs.stdenv; stdenv = pkgs.stdenv;
}; };
@@ -91,12 +91,19 @@ in {
mizes = map mizeLib.buildMizeForSystem systems; mizes = map mizeLib.buildMizeForSystem systems;
in builtins.listToAttrs ( map ( mize: { name = mize.system.name; value = mize; } ) mizes ); in builtins.listToAttrs ( map ( mize: { name = mize.system.name; value = mize; } ) mizes );
#pkgsCross = import nixpkgs { localSystem = system; crossSystem = { config = "x86_64-pc-windows-gnu"; }; overlays = [ rust-overlay.overlays.default ]; }; dist = mizeLib.dist systems;
random = mizeLib.random systems;
inherit mizeLib;
#pkgsCross = import nixpkgs { buildSystem = system; crossSystem = { config = "x86_64-pc-windows-gnu"; }; overlays = [ rust-overlay.overlays.default ]; };
pkgsTest = pkgs; pkgsTest = pkgs;
#pkgsCross = import nixpkgs { localSystem = system; crossSystem = { config = "x86_64-w64-windows-mingw"; }; overlays = [ rust-overlay.overlays.default ]; }; #pkgsCross = import nixpkgs { buildSystem = system; crossSystem = { config = "x86_64-w64-windows-mingw"; }; overlays = [ rust-overlay.overlays.default ]; };
pkgsCross = import nixpkgs { localSystem = system; crossSystem = { config = "x86_64-unknown-linux-gnu"; }; overlays = [ rust-overlay.overlays.default ]; }; pkgsCross = import nixpkgs { buildSystem = system; crossSystem = { config = "x86_64-unknown-linux-gnu"; }; overlays = [ rust-overlay.overlays.default ]; };
craneLib = (crane.mkLib pkgsCross).overrideToolchain (p: p.rust-bin.stable.latest.default); craneLib = (crane.mkLib pkgsCross).overrideToolchain (p: p.rust-bin.stable.latest.default);
@@ -114,8 +121,6 @@ in {
}; };
}; };
webfiles = mizeLib.webfiles systems;
default = osCrane.buildPackage { default = osCrane.buildPackage {
src = "${self}"; src = "${self}";
cargoExtraArgs = "--bin mize --features os-target"; cargoExtraArgs = "--bin mize --features os-target";

300
lib.nix
View File

@@ -3,12 +3,13 @@
, self , self
, defaultMizeConfig , defaultMizeConfig
, mize_modules , mize_modules
, localSystem , buildSystem
, nixpkgs , nixpkgs
, rust-overlay , rust-overlay
, crane , crane
, fenix , fenix
, stdenv , stdenv
, lib ? pkgs.lib
, ... , ...
}: }:
rec { rec {
@@ -17,25 +18,20 @@ rec {
getCrossSystem = system: let getCrossSystem = system: let
crossSystem = (if builtins.isString system then (pkgs.lib.systems.parse.mkSystemFromString system) else system) hostSystem = (if builtins.isString system then (pkgs.lib.systems.parse.mkSystemFromString system) else system)
// rec { // rec {
name = if crossSystem.vendor != "unknown" name = if hostSystem.vendor != "unknown"
then "${crossSystem.cpu.name}-${crossSystem.kernel.name}-${crossSystem.abi.name}" then "${hostSystem.cpu.name}-${hostSystem.kernel.name}-${hostSystem.abi.name}"
else "${crossSystem.cpu.name}-${crossSystem.vendor.name}-${crossSystem.kernel.name}-${crossSystem.abi.name}"; else "${hostSystem.cpu.name}-${hostSystem.vendor.name}-${hostSystem.kernel.name}-${hostSystem.abi.name}";
nameFull = "${crossSystem.cpu.name}-${crossSystem.vendor.name}-${crossSystem.kernel.name}-${crossSystem.abi.name}"; nameFull = "${hostSystem.cpu.name}-${hostSystem.vendor.name}-${hostSystem.kernel.name}-${hostSystem.abi.name}";
nameRust = nameFull; nameRust = nameFull;
config = nameFull; config = nameFull;
isCross = system != buildSystem;
isNative = system == buildSystem;
}; };
in crossSystem; in hostSystem;
buildMizeForSystem = system: let
crossSystem = getCrossSystem system;
pkgsCross = import nixpkgs { inherit localSystem crossSystem; overlays = [ rust-overlay.overlays.default ]; };
pkgsNative = import nixpkgs { inherit localSystem; overlays = [ rust-overlay.overlays.default ]; };
# get a list of all modules # get a list of all modules
# aka folders with a mize_module.nix in them # aka folders with a mize_module.nix in them
module_list_drv = path: pkgs.stdenv.mkDerivation { module_list_drv = path: pkgs.stdenv.mkDerivation {
@@ -54,20 +50,6 @@ rec {
''; '';
}; };
mize_module_path = builtins.getEnv "MIZE_MODULE_PATH";
dirs_from_path = pkgs.lib.lists.remove "" (pkgs.lib.strings.splitString ":" mize_module_path);
dirs_in_nix_store = map (path: builtins.fetchGit {
url = path;
}) dirs_from_path;
from_env_var = map findModules dirs_in_nix_store;
mizeMdules = let
from_mize_modules_repo = findModules mize_modules;
mize_module_no_repo = builtins.getEnv "MIZE_MODULE_NO_REPO";
in pkgs.lib.lists.flatten (from_env_var ++ (if mize_module_no_repo != "" then [] else from_mize_modules_repo));
findModules = path: let findModules = path: let
mize_module_no_externals = builtins.getEnv "MIZE_MODULE_NO_EXTERNALS"; mize_module_no_externals = builtins.getEnv "MIZE_MODULE_NO_EXTERNALS";
module_list_string = builtins.readFile "${module_list_drv path}/modules_to_build"; module_list_string = builtins.readFile "${module_list_drv path}/modules_to_build";
@@ -76,33 +58,55 @@ rec {
in module_list ++ (if mize_module_no_externals != "" then [] else (map getExternals module_list)); in module_list ++ (if mize_module_no_externals != "" then [] else (map getExternals module_list));
modulesFileList = let
from_mize_modules_repo = findModules mize_modules;
mize_module_no_repo = builtins.getEnv "MIZE_MODULE_NO_REPO";
in pkgs.lib.lists.flatten (from_env_var ++ (if mize_module_no_repo != "" then [] else from_mize_modules_repo) ++ (findModules self));
mize_module_path = builtins.getEnv "MIZE_MODULE_PATH";
dirs_from_path = pkgs.lib.lists.remove "" (pkgs.lib.strings.splitString ":" mize_module_path);
dirs_in_nix_store = map (path: builtins.fetchGit {
url = path;
}) dirs_from_path;
from_env_var = map findModules dirs_in_nix_store;
buildMizeForSystem = system: let
hostSystem = getCrossSystem system;
pkgsCross = import nixpkgs { inherit buildSystem hostSystem; overlays = [ rust-overlay.overlays.default ]; };
pkgsNative = import nixpkgs { inherit buildSystem; overlays = [ rust-overlay.overlays.default ]; };
craneLib = craneLib =
if crossSystem.kernel.name == "windows" if hostSystem.kernel.name == "windows"
then then
(crane.mkLib pkgs).overrideToolchain (fenix.packages.${localSystem}.combine [ (crane.mkLib pkgs).overrideToolchain (fenix.packages.${buildSystem}.combine [
#fenix.packages.${localSystem}.minimal.rustc #fenix.packages.${buildSystem}.minimal.rustc
#fenix.packages.${localSystem}.minimal.cargo #fenix.packages.${buildSystem}.minimal.cargo
fenix.packages.${localSystem}.stable.toolchain fenix.packages.${buildSystem}.stable.toolchain
fenix.packages.${localSystem}.targets."${crossSystem.cpu.name}-pc-windows-gnu".stable.toolchain fenix.packages.${buildSystem}.targets."${hostSystem.cpu.name}-pc-windows-gnu".stable.toolchain
]) ])
else if crossSystem.cpu.name == "wasm32" else if hostSystem.cpu.name == "wasm32"
then then
(crane.mkLib pkgs).overrideToolchain (fenix.packages.${localSystem}.combine [ (crane.mkLib pkgs).overrideToolchain (fenix.packages.${buildSystem}.combine [
fenix.packages.${localSystem}.targets.wasm32-unknown-unknown.latest.toolchain fenix.packages.${buildSystem}.targets.wasm32-unknown-unknown.latest.toolchain
fenix.packages.${localSystem}.latest.toolchain fenix.packages.${buildSystem}.latest.toolchain
]) ])
else if crossSystem.name == "x86_64-linux-gnu" else if hostSystem.name == "x86_64-linux-gnu"
then then
builtins.trace "x86_64-linux-gnu hackfix...." builtins.trace "x86_64-linux-gnu hackfix...."
(crane.mkLib pkgs).overrideToolchain (fenix.packages.${localSystem}.combine [ (crane.mkLib pkgs).overrideToolchain (fenix.packages.${buildSystem}.combine [
fenix.packages.${localSystem}.stable.toolchain fenix.packages.${buildSystem}.stable.toolchain
]) ])
else else
(crane.mkLib pkgsCross).overrideToolchain (p: fenix.packages.${localSystem}.stable.toolchain) (crane.mkLib pkgsCross).overrideToolchain (p: fenix.packages.${buildSystem}.stable.toolchain)
; ;
toolchain_version_drv = pkgs.stdenv.mkDerivation { toolchain_version_drv = pkgs.stdenv.mkDerivation {
@@ -125,13 +129,14 @@ rec {
mkSelString = attrs: builtins.toJSON (attrs // { mkSelString = attrs: builtins.toJSON (attrs // {
inherit toolchain_version; inherit toolchain_version;
system = crossSystem.nameFull; system = hostSystem.nameFull;
mize_version = main-default.version; mize_version = "0.0.1";
}); });
toolchain_version = pkgs.lib.strings.removeSuffix "\n" (builtins.readFile "${toolchain_version_drv}/rustc-version"); toolchain_version = pkgs.lib.strings.removeSuffix "\n" (builtins.readFile "${toolchain_version_drv}/rustc-version");
mkMizeModule = attrs: (if builtins.hasAttr "drvFunc" attrs then attrs.drvFunc else pkgsCross.stdenv.mkDerivation) ( rec { mkMizeModule = attrs: (if builtins.hasAttr "drvFunc" attrs then attrs.drvFunc else pkgsCross.stdenv.mkDerivation) ( rec {
name = attrs.modName; name = attrs.modName;
inherit (attrs) modName; inherit (attrs) modName;
@@ -139,24 +144,34 @@ rec {
inherit (attrs) modName; inherit (attrs) modName;
}); });
hash = builtins.substring 0 32 (builtins.hashString "sha256" selector_string); hash = builtins.substring 0 32 (builtins.hashString "sha256" selector_string);
} // attrs); }
// (lib.attrsets.removeAttrs attrs ["drvFunc"] )
);
########## build Rust Module ########## build a Rust Module
mkMizeRustModule = attrs: craneLib.buildPackage (attrs // { mkMizeRustModule = attrs: mkMizeModule (
# general stuff
{
drvFunc = craneLib.buildPackage;
MIZE_BUILD_CONFIG = mizeBuildConfigStr; MIZE_BUILD_CONFIG = mizeBuildConfigStr;
mizeInstallPhase = attrs.mizeInstallPhase or '' mizeInstallPhase = attrs.mizeInstallPhase or ''
mkdir -p $out/lib/ mkdir -p $out/lib/
cp $build_dir/target/${crossSystem.nameRust}/$debugOrRelease/libmize_module_${attrs.modName}.so $out/lib/ cp $build_dir/target/${hostSystem.nameRust}/$debugOrRelease/libmize_module_${attrs.modName}.so $out/lib/
''; '';
mizeBuildPhase = attrs.mizeBuildPhase or '' mizeBuildPhase = attrs.mizeBuildPhase or ''
cargo --color always build --target ${crossSystem.nameRust} --manifest-path $build_dir/Cargo.toml --lib cargo --color always build --target ${hostSystem.nameRust} --manifest-path $build_dir/Cargo.toml --lib
''; '';
selector_string = mkSelString (attrs.select or {} // { selector_string = mkSelString (attrs.select or {} // {
inherit (attrs) modName; inherit (attrs) modName;
}); });
}
# linux specific stuff
// (lib.attrsets.optionalAttrs (hostSystem.kernel.name == "linux") {
# rename the so library, in case the lib.name in your Cargo.toml is not like mize_module_mylib # rename the so library, in case the lib.name in your Cargo.toml is not like mize_module_mylib
postInstall = (attrs.postInstall or "") + '' postInstall = (attrs.postInstall or "") + ''
if [ ! -f "$out/lib/libmize_module_${attrs.modName}" ]; then if [ ! -f "$out/lib/libmize_module_${attrs.modName}" ]; then
@@ -168,32 +183,35 @@ rec {
echo "$FILE" echo "$FILE"
fi fi
''; '';
} })
# linux specific stuff
// (if crossSystem.kernel.name == "linux" then {
"CARGO_TARGET_${builtins.replaceStrings ["-"] ["_"] (pkgsCross.lib.strings.toUpper crossSystem.nameFull)}_LINKER" = "${pkgsCross.stdenv.cc.targetPrefix}cc"; # linux cross stuff
// (lib.attrsets.optionalAttrs (hostSystem.kernel.name == "linux" && hostSystem.isCross) {
"CARGO_TARGET_${builtins.replaceStrings ["-"] ["_"] (pkgsCross.lib.strings.toUpper hostSystem.nameFull)}_LINKER" = "${pkgsCross.stdenv.cc.targetPrefix}cc";
HOST_CC = "${pkgsCross.stdenv.cc.nativePrefix}cc"; HOST_CC = "${pkgsCross.stdenv.cc.nativePrefix}cc";
TARGET_CC = "${pkgsCross.stdenv.cc.targetPrefix}cc"; TARGET_CC = "${pkgsCross.stdenv.cc.targetPrefix}cc";
CARGO_BUILD_TARGET = crossSystem.nameFull; CARGO_BUILD_TARGET = hostSystem.nameFull;
nativeBuildInputs = attrs.nativeBuildInputs or [] ++ [ nativeBuildInputs = attrs.nativeBuildInputs or [] ++ [
pkgsCross.stdenv.cc pkgsCross.stdenv.cc
]; ];
} else {}) })
# add wasm stuff # wasm stuff
// (if crossSystem.cpu.name == "wasm32" then { // (lib.attrsets.optionalAttrs (hostSystem.cpu.name == "wasm32") {
CARGO_BUILD_TARGET = "wasm32-unknown-unknown"; CARGO_BUILD_TARGET = "wasm32-unknown-unknown";
# checks fail on wasm # checks fail on wasm
doCheck = false; doCheck = false;
} else {}) })
# add windows stuff # add windows stuff
// (if crossSystem.kernel.name == "windows" then { // (lib.attrsets.optionalAttrs (hostSystem.kernel.name == "windows") {
strictDeps = true; strictDeps = true;
doCheck = false; doCheck = false;
CARGO_BUILD_TARGET = "${crossSystem.cpu.name}-pc-windows-gnu"; CARGO_BUILD_TARGET = "${hostSystem.cpu.name}-pc-windows-gnu";
# fixes issues related to libring # fixes issues related to libring
TARGET_CC = "${pkgs.pkgsCross.mingwW64.stdenv.cc}/bin/${pkgs.pkgsCross.mingwW64.stdenv.cc.targetPrefix}cc"; TARGET_CC = "${pkgs.pkgsCross.mingwW64.stdenv.cc}/bin/${pkgs.pkgsCross.mingwW64.stdenv.cc.targetPrefix}cc";
@@ -207,7 +225,12 @@ rec {
pkgs.pkgsCross.mingwW64.stdenv.cc pkgs.pkgsCross.mingwW64.stdenv.cc
pkgs.pkgsCross.mingwW64.windows.pthreads pkgs.pkgsCross.mingwW64.windows.pthreads
]; ];
} else {}) })
# add the attrs passed to mkMizeRustModule
// attrs
); );
@@ -215,14 +238,14 @@ rec {
buildModule = path: extraArgs: pkgs.callPackage ((import path).module or (attrs: null)) ({ buildModule = path: extraArgs: pkgs.callPackage ((import path).module or (attrs: null)) ({
inherit buildMizeForSystem mizeBuildConfig mizeBuildConfigStr; inherit buildMizeForSystem mizeBuildConfig mizeBuildConfigStr;
inherit mkSelString craneLib toolchain_version; inherit mkSelString craneLib toolchain_version;
inherit mkMizeModule mkMizeRustModule buildModule findModules crossSystem pkgsCross pkgsNative mkMizeRustShell; inherit mkMizeModule mkMizeRustModule buildModule findModules hostSystem pkgsCross pkgsNative mkMizeRustShell;
mize_version = main-default.version; mize_version = "0.0.1";
} // extraArgs ); } // extraArgs );
buildLib = path: extraArgs: pkgs.callPackage ((import path).lib or (args: {})) { buildLib = path: extraArgs: pkgs.callPackage ((import path).lib or (args: {})) {
inherit mkSelString craneLib toolchain_version; inherit mkSelString craneLib toolchain_version;
inherit mkMizeModule mkMizeRustModule buildModule findModules crossSystem pkgsCross pkgsNative mkMizeRustShell; inherit mkMizeModule mkMizeRustModule buildModule findModules hostSystem pkgsCross pkgsNative mkMizeRustShell;
mize_version = main-default.version; mize_version = "0.0.1";
}; };
@@ -238,111 +261,6 @@ rec {
config = mizeBuildConfig; config = mizeBuildConfig;
}; };
####### build mize
main-default = craneLib.buildPackage ({
src = "${self}";
cargoExtraArgs = "--bin mize --features os-target";
# CARGO_PROFILE = "dev"; does not work...
strictDeps = true;
nativeBuildInputs = [
pkgsCross.buildPackages.pkg-config
#pkgsCross.buildPackages.nasm
#pkgsCross.buildPackages.cmake
];
buildInputs = [
(if crossSystem.nameFull == "x86_64-unknown-linux-gnu" then pkgs.openssl else pkgsCross.openssl)
];
MIZE_BUILD_CONFIG = mizeBuildConfigStr;
# patch the interpreter to run on most linux-gnu distros
postBuild =
if crossSystem.cpu.name == "x86_64"
then "patchelf --set-interpreter /lib64/ld-linux-x86-64.so.2 /build/source/target/release/mize"
else if crossSystem.cpu.name == "aarch64"
then "patchelf --set-interpreter /lib64/ld-linux-aarch64.so.2 /build/source/target/${crossSystem.nameFull}/release/mize"
else ""
;
}
// (if crossSystem.name == "x86_64-linux-gnu" then builtins.trace "another x86_64-linux hackfix..." {} else {
CARGO_BUILD_TARGET = crossSystem.nameFull;
"CARGO_TARGET_${builtins.replaceStrings ["-"] ["_"] (pkgsCross.lib.strings.toUpper crossSystem.nameFull)}_LINKER" = "${pkgsCross.stdenv.cc.targetPrefix}cc";
HOST_CC = "${pkgsCross.stdenv.cc.nativePrefix}cc";
TARGET_CC = "${pkgsCross.stdenv.cc.targetPrefix}cc";
})
);
main-win = craneLib.buildPackage {
src = craneLib.cleanCargoSource ./.;
#nativeBuildInputs = [ pkgsCross.buildPackages.nasm pkgsCross.buildPackages.cmake ];
strictDeps = true;
doCheck = false;
cargoExtraArgs = "--bin mize --features os-target";
CARGO_BUILD_TARGET = "${crossSystem.cpu.name}-pc-windows-gnu";
MIZE_BUILD_CONFIG = mizeBuildConfigStr;
# fixes issues related to libring
TARGET_CC = "${pkgs.pkgsCross.mingwW64.stdenv.cc}/bin/${pkgs.pkgsCross.mingwW64.stdenv.cc.targetPrefix}cc";
#fixes issues related to openssl
OPENSSL_DIR = "${pkgs.openssl.dev}";
OPENSSL_LIB_DIR = "${pkgs.openssl.out}/lib";
OPENSSL_INCLUDE_DIR = "${pkgs.openssl.dev}/include/";
depsBuildBuild = [
pkgs.pkgsCross.mingwW64.stdenv.cc
pkgs.pkgsCross.mingwW64.windows.pthreads
];
};
# - https://github.com/ipetkov/crane/issues/362#issuecomment-1683220603
wasmArtifacts = craneLib.buildDepsOnly ({
src = self;
doCheck = false; # tests does not work in wasm
CARGO_BUILD_TARGET = "wasm32-unknown-unknown";
cargoExtraArgs = "--features wasm-target --no-default-features";
RUSTFLAGS="-C linker=wasm-ld";
buildInputs = with pkgs; [ cargo-binutils lld ];
});
main-wasm = craneLib.mkCargoDerivation {
name = "mize-npm-package";
# i can't use CARGO_BUILD_TARGET to set the target
# because then the cargo install run by wasm-pack tries to build the wasm-bindgen-cli for a wasm target...
src = self;
doInstallCargoArtifacts = false;
cargoArtifacts = wasmArtifacts;
doCheck = false;
buildPhaseCargoCommand = ''
mkdir -p $out/pkg
HOME=$(mktemp -d fake-homeXXXX) wasm-pack build --target no-modules --out-dir $out/pkg --scope=c2vi -- --features wasm-target --no-default-features
'';
postInstall = ''
rm -rf $out/target.tar.zst
cat $src/src/platform/wasm/init.js >> $out/pkg/mize.js
'';
buildInputs = with pkgsNative; [ wasm-bindgen-cli binaryen wasm-pack ];
MIZE_BUILD_CONFIG = mizeBuildConfigStr;
};
################# dev Shels ################### ################# dev Shels ###################
@@ -384,7 +302,7 @@ rec {
wasm-pack #pkg-config openssl #cargo rustc wasm-pack #pkg-config openssl #cargo rustc
cargo-generate cargo-generate
(fenix.packages.${localSystem}.combine [ (fenix.packages.${buildSystem}.combine [
fenix.packages.${system}.stable.toolchain fenix.packages.${system}.stable.toolchain
fenix.packages.${system}.targets.wasm32-unknown-unknown.stable.toolchain fenix.packages.${system}.targets.wasm32-unknown-unknown.stable.toolchain
fenix.packages.${system}.stable.toolchain fenix.packages.${system}.stable.toolchain
@@ -408,29 +326,26 @@ rec {
################# output attrset ################### ################# output attrset ###################
in rec { in rec {
inherit toolchain_version_drv pkgsCross craneLib;
inherit mize_module_path dirs_from_path dirs_in_nix_store from_env_var;
devShell = mainDevShell; devShell = mainDevShell;
main = main = modules.mize;
if crossSystem.kernel.name == "windows"
then main-win
else if crossSystem.cpu.name == "wasm32"
then main-wasm
else main-default
;
system = crossSystem; system = hostSystem;
modules = builtins.listToAttrs ( map ( mod: { name = mod.modName; value = mod; } ) modulesList );
# for debugging
modulesListDrv = module_list_drv mize_modules;
modulesFileList = mizeMdules;
modulesLibList = map (mod: buildLib mod {}) modulesFileList; modulesLibList = map (mod: buildLib mod {}) modulesFileList;
modulesLib = pkgs.lib.lists.foldr (a: b: b // a) {} modulesLibList; modulesLib = pkgs.lib.lists.foldr (a: b: b // a) {} modulesLibList;
modulesList = pkgs.lib.lists.remove null (map (mod: (buildModule mod modulesLib)) modulesFileList); modulesList = pkgs.lib.lists.remove null (map (mod: (buildModule mod modulesLib)) modulesFileList);
modules = builtins.listToAttrs ( map ( mod: { name = mod.modName; value = mod; } ) modulesList ); inherit toolchain_version_drv pkgsCross craneLib;
inherit mize_module_path dirs_from_path dirs_in_nix_store from_env_var;
}; };
@@ -447,7 +362,7 @@ rec {
mkModulesInstallPhase = modules: pkgs.lib.concatStringsSep "\n" (map mkModuleInstallPhase modules); mkModulesInstallPhase = modules: pkgs.lib.concatStringsSep "\n" (map mkModuleInstallPhase modules);
mkModuleInstallPhase = module: let mkModuleInstallPhase = module: let
hash = module.hach; hash = module.hash;
in '' in ''
echo got module: ${module.name} echo got module: ${module.name}
echo out: $out echo out: $out
@@ -472,7 +387,7 @@ rec {
mkdir -p $out/mize mkdir -p $out/mize
mkdir -p $out/mize/dist mkdir -p $out/mize/dist
'' + pkgs.lib.concatStringsSep "\n" (map mkInstallPhase (map buildMizeForSystem systems)); '' ;# + pkgs.lib.concatStringsSep "\n" (map mkInstallPhase (map buildMizeForSystem systems));
nativeBuildInputs = [ nativeBuildInputs = [
@@ -483,6 +398,17 @@ rec {
mizeFor = buildMizeForSystem system; mizeFor = buildMizeForSystem system;
in builtins.listToAttrs ( map ( mod: { name = mod.modName; value = (mod.devShell); } ) mizeFor.modulesList ); in builtins.listToAttrs ( map ( mod: { name = mod.modName; value = (mod.devShell); } ) mizeFor.modulesList );
random = systems: rec {
distInstallPhase = map mkInstallPhase (map buildMizeForSystem systems);
mizeList = map buildMizeForSystem systems;
mize-x86_64-linux = buildMizeForSystem "x86_64-linux";
mize-x86_64-linux-installPhase = mkInstallPhase mize-x86_64-linux;
modulesListDrv = module_list_drv mize_modules;
inherit modulesFileList;
};
} }

116
mize_module.nix Normal file
View File

@@ -0,0 +1,116 @@
{
module = { mkMizeRustModule, hostSystem, pkgsCross, pkgs, lib, craneLib, ... }:
mkMizeRustModule (
# general stuff
{
modName = "mize";
src = ./.;
cargoExtraArgs = "--no-default-features --lib";
}
# linux stuff
// (lib.attrsets.optionalAttrs (hostSystem.kernel.name == "linux") {
strictDeps = true;
cargoExtraArgs = "--bin mize --features os-target";
})
# x86_64-linux stuff
// (lib.attrsets.optionalAttrs (hostSystem.name == "x86_64-linux-gnu") {
nativeBuildInputs = [
pkgsCross.buildPackages.pkg-config
];
buildInputs = [
(if hostSystem.nameFull == "x86_64-unknown-linux-gnu" then pkgs.openssl else pkgsCross.openssl)
];
# patch the interpreter to run on most linux-gnu distros
# postBuild = "patchelf --set-interpreter /lib64/ld-linux-x86-64.so.2 /build/source/target/release/mize";
})
# aarch64-linux stuff
// (lib.attrsets.optionalAttrs (hostSystem.name == "aarch64-linux-gnu") {
# patch the interpreter to run on most linux-gnu distros
postBuild = "patchelf --set-interpreter /lib64/ld-linux-aarch64.so.2 /build/source/target/${hostSystem.nameFull}/release/mize";
})
#x86_64-windows stuff
// (lib.attrsets.optionalAttrs (hostSystem.name == "x86_64-windows-gnu") {
strictDeps = true;
doCheck = false;
cargoExtraArgs = "--bin mize --features os-target";
CARGO_BUILD_TARGET = "${hostSystem.cpu.name}-pc-windows-gnu";
# fixes issues related to libring
TARGET_CC = "${pkgs.pkgsCross.mingwW64.stdenv.cc}/bin/${pkgs.pkgsCross.mingwW64.stdenv.cc.targetPrefix}cc";
#fixes issues related to openssl
OPENSSL_DIR = "${pkgs.openssl.dev}";
OPENSSL_LIB_DIR = "${pkgs.openssl.out}/lib";
OPENSSL_INCLUDE_DIR = "${pkgs.openssl.dev}/include/";
depsBuildBuild = [
pkgs.pkgsCross.mingwW64.stdenv.cc
pkgs.pkgsCross.mingwW64.windows.pthreads
];
})
#browser stuff
// (lib.attrsets.optionalAttrs (hostSystem.name == "wasm32-none-unknown") {
cargoArtifacts = craneLib.buildDepsOnly ({
src = ./.;
doCheck = false; # tests does not work in wasm
CARGO_BUILD_TARGET = "wasm32-unknown-unknown";
cargoExtraArgs = "--features wasm-target --no-default-features";
RUSTFLAGS="-C linker=wasm-ld";
buildInputs = with pkgs; [ cargo-binutils lld ];
});
doInstallCargoArtifacts = false;
doCheck = false;
buildPhaseCargoCommand = ''
mkdir -p $out/pkg
HOME=$(mktemp -d fake-homeXXXX) wasm-pack build --target no-modules --out-dir $out/pkg --scope=c2vi -- --features wasm-target --no-default-features
'';
postInstall = ''
rm -rf $out/target.tar.zst
cat $src/src/platform/wasm/init.js >> $out/pkg/mize.js
'';
buildInputs = with pkgs; [ wasm-bindgen-cli binaryen wasm-pack ];
})
);
}

2
src/platform/os/mod.rs
View File

@@ -112,7 +112,7 @@ pub fn os_instance_init(instance: &mut Instance) -> MizeResult<()> {
#[cfg(target_family = "windows")] #[cfg(target_family = "windows")]
{ {
error!("CONNECTING... would connect, but that is not implemented on windows yet"); error!("CONNECTING... would connect, but that is not imon't identify as anything, to not cause anyone problems... So that everybody can be satisfied...plemented on windows yet");
} }
} else { } else {