Implementing Nix binary retrieval

Author: Thesola10

src/builder.ab

@@ -2,9 +2,9 @@
 // Licensed under GNU GPLv2
 // Functions to build Nix and its dependencies from source
 
+import { set_title }                     from "./term.ab"
 import { check_deps, bail }              from "./common.ab"
 import { pull_source_file, pull_binary } from "./resources.ab"
-import { set_title }                     from "./term.ab"
 
 fun build_openssl()
 {

src/main.ab

@@ -17,7 +17,6 @@ let args = [Text]
 import { env_var_get }              from "std/env"
 
 import { bail, untar, check_deps }  from "./common.ab"
-import { get_repo_root }            from "./platform.ab"
 import { catch_args }               from "./cli.ab"
 import { launch_nix }               from "./nix.ab"
 

src/nix.ab

@@ -2,24 +2,63 @@
 // Licensed under GNU GPLv2
 // Final-step Nix invocation methods
 
-import { build_nix } from "./builder.ab"
-import { pull_binary } from "./resources.ab"
-import { enter_alt_buffer, set_title, teardown } from "./term.ab"
+import { file_exists, dir_exists, dir_create } from "std/fs"
 
-fun is_ignore_system(): Bool
+import { enter_alt_buffer, set_title, teardown }  from "./term.ab"
+import { bail }                                   from "./common.ab"
+import { get_osname, get_cache_root, get_system } from "./platform.ab"
+import { pull_binary }                            from "./resources.ab"
+import { build_nix }                              from "./builder.ab"
+
+/// Determine whether Nix is installed system-wide. Nixie can launch the
+/// system-wide Nix when it is available, using the script's bundled options.
+///
+/// This is the predicate for that behavior.
+fun is_nix_installed(): Bool
 {
-    return env_var_test("nosystem")
+    // --nixie-ignore-system flag set
+    if env_var_test("nosystem"): return false
+
+    // Simple enough heuristic. In the future, might also check for the `nix`
+    // command, but that would create a ternary situation where Nixie's static
+    // Nix would need to use the system store.
+    if dir_exists("/nix/store"): return true
+
+    return false
 }
 
+/// Attempt to retrieve the static Nix binary by all known methods.
+///
+/// This function will first try to extract or download a static executable
+/// for the current system, and if it fails, a local build from source will be
+/// attempted.
+///
+/// **NOTE**: On macOS, this function is also responsible for downloading
+/// `libfakedir.dylib`.
 fun get_nix()
 {
+    let cache_root = get_cache_root()
+    let osname = get_osname()
+    let system = get_system()
+
+    let nix_path = "{cache_root}/nix-static"
+    let fakedir_path = "{cache_root}/nix-lib/libfakedir.dylib"
+
     enter_alt_buffer()
     set_title("Building Nix...")
 
     // Cleanly exit alt-buffer if hit with ^C
     trust $trap "{nameof teardown}; exit 1" SIGKILL SIGTERM SIGINT SIGABRT$
 
-    //TODO: ✨MAGIC✨
+    if osname == "Darwin" and not file_exists(fakedir_path) {
+        dir_create("{cache_root}/nix-lib")
+        trust pull_binary("libfakedir.dylib", fakedir_path)
+    }
+
+    if not file_exists(nix_path) {
+        trust pull_binary("nix.{system}", nix_path)
+    }
+
     echo "Pretend we're doing something here..."
     trust $sleep 1$
 
@@ -28,7 +67,12 @@ fun get_nix()
     fail 1
 }
 
-fun launch_darwin_workaround()
+/// Launch Nix with the proper environment variables for fakedir and OpenSSL.
+///
+/// This is required because macOS has no namespacing facility, and Nix will
+/// not attempt to use the system-wide CA bundle by default. This function
+/// addresses both issues.
+fun launch_darwin_workaround(name: Text, args: [Text]): Null
 {
 
 }

src/platform.ab

@@ -3,35 +3,47 @@
 // Environment-specific data retrieval utilities
 
 import { env_var_get, echo_warning } from "std/env"
-import { split, join } from "std/text"
-import { array_pop } from "std/array"
+import { split, join }               from "std/text"
+import { array_pop }                 from "std/array"
 
 import { get_self } from "./common.ab"
 
-pub fun get_osname(): Text {
+/// Return the current operating system, as reported by `uname -s`.
+pub fun get_osname(): Text
+{
     return trust $uname -s$
 }
 
-pub fun get_machine(): Text {
-    return trust $uanme -m$
+/// Return the current machine architecture, as reported by `uname -s`.
+pub fun get_machine(): Text
+{
+    return trust $uname -m$
 }
 
-pub fun get_system(): Text {
+/// Return the combined system-string, in the format `osname.machine`.
+///
+/// See [`get_osname()`](#get_osname) and [`get_machine()`](#get_machine) above.
+pub fun get_system(): Text
+{
     let osname = get_osname()
     let machine = get_machine()
 
     return "{osname}.{machine}"
 }
 
-pub fun get_dll_ext(): Text {
+/// Return the extension for dynamic libraries on the current system.
+pub fun get_dll_ext(): Text
+{
     let osname = get_osname()
     if {
         osname == "Darwin": return "dylib"
         else:               return "so"
     }
 }
 
-pub fun get_nix_root(): Text {
+/// Return the path to the user-mode root for the Nix store.
+pub fun get_nix_root(): Text
+{
     let userhome = trust env_var_get("HOME")
     let osname = get_osname()
     if {
@@ -40,7 +52,9 @@ pub fun get_nix_root(): Text {
     }
 }
 
-pub fun get_cache_root(): Text {
+/// Return the path to the user's cache directory on the current system.
+pub fun get_cache_root(): Text
+{
     let userhome = trust env_var_get("HOME")
     let osname = get_osname()
     if {
@@ -49,12 +63,16 @@ pub fun get_cache_root(): Text {
     }
 }
 
+/// Return the path to the root of the Git repository the script is located in.
+///
+/// Falls back to returning the script's parent directory if not in a repository,
+/// or if `git` is unavailable.
 pub fun get_repo_root(): Text
 {
     let self_a = split(get_self(), "/")
     array_pop(self_a)
 
-    let self_dir = "/{join(self_a, "/")}"
+    let self_dir = "/" + join(self_a, "/")
 
     return $git -C {self_dir} rev-parse --show-toplevel$ failed {
         echo_warning("Failed to find current Git repository, using script parent directory.")

src/resources.ab

@@ -3,36 +3,51 @@
 // Resource retrieval from tarball or Cachix
 
 import { file_download } from "std/http"
+import { env_var_get } from "std/env"
 
 import { untar } from "./common.ab"
 
 fun cachix_url(derivation: Text, member: Text): Text
 {
+    let SOURCE_CACHE = trust env_var_get("SOURCE_CACHE")
+
     return "https://{SOURCE_CACHE}/serve/{derivation}/{member}"
 }
 
 pub fun pull_source_file(member: Text, dest: Text): Null?
 {
-    let where = untar("sources/{member}") failed {
+    let SOURCE_DERIVATION = trust env_var_get("SOURCE_DERIVATION")
+
+    let where = trust untar("sources/{member}")
+    if status != 0 {
         let tmpf = trust $mktemp -t nixie_src_XXXXXXXX.tgz$
         let tmpd = trust $mktemp -t -d nixie_{member}_XXXXXXXX$
 
-        file_download(cachix_url(SOURCE_DERIVATION, "{member}.tar.gz"), tmpf)?
+        if not file_download(cachix_url(SOURCE_DERIVATION, "{member}.tar.gz"), tmpf) {
+            fail 1
+        }
+
         trust $rm -f {tmpf}$
-        return tmpd
+        where = tmpd
     }
 
-    mv where dest
+    trust mv where dest
 }
 
 pub fun pull_binary(member: Text, dest: Text): Null?
 {
-    let where = untar(member) failed {
+    let NIX_BINS_DERIVATION = trust env_var_get("NIX_BINS_DERIVATION")
+
+    let where = trust untar(member)
+    if status != 0 {
         let tmpf = trust $mktemp -t nixie_{member}_XXXXXXXX$
 
-        file_download(cachix_url(BINARIES_DERIVATION, member), tmpf)?
-        return tmpf
+        if not file_download(cachix_url(NIX_BINS_DERIVATION, member), tmpf) {
+            fail 1
+        }
+
+        where = tmpf
     }
 
-    mv where dest
+    trust mv where dest
 }