gram: haiku

> ./module/elixir.nix

{ channel, domain, codebase, name, user, dependencies ? [], app ? name, ... }:
{ pkgs, ... }:
let
  home = "/var/gram";
  place = "${home}/run/${name}";
  elixir = pkgs.beam29Packages.elixir_1_20;

  command = call: ''
    cd ${place}/run;
    load-env (
      open /var/gram/${name}.call
      | str trim
      | lines
      | split column '=' --number 2
      | transpose -i -r --as-record
    );
    ${place}/run/_build/($env.MIX_ENV)/rel/${app}/bin/${app} ${call}
  '';

  nu = name: body: pkgs.writeScriptBin name ''
    #!${pkgs.nushell}/bin/nu
    ${body}
  '';

  measures = {
    load = ''
      while ((ip --brief a
        | from ssv --noheaders
        | rename name engaged addrs
        | where name =~ eth
        | get 0.engaged
        | str trim) !~ 'UP') { sleep 1sec }

      ((glob /root/share/gram/*) ++ (glob /root/unshare/gram/*))
      | each { git config --global --add safe.directory $in }
      git config --global --add safe.directory ${codebase}/.git

      mix local.hex --force
      yes | mix archive.install github hexpm/hex branch latest
      ip --brief a

      mkdir /var/run/${name}
      mkdir /var/gram
      try { rm /var/gram/${name}.call }
      cp ${codebase}/.call /var/gram/${name}.call

      $"
      DATABASE_URL=postgres://postgres@127.0.0.1:5432/${name}
      CHANNEL=4000
      NO_VHOST=0
      DOMAIN=${domain}
      PHX_SERVER=y
      SUPER_USER=c4lliope
      SECRET_KEY_BASE=(openssl rand -hex 64)
      SUPER_PASS=(openssl rand -hex 64)
      " | str trim | save -a /var/gram/${name}.call
    '';

    clone = ''
      mkdir ${place}
      let launch = $"${place}/(sh -c 'date -Is' | str trim)"
      ${pkgs.git}/bin/git clone ${codebase} $launch
      # ${pkgs.rsync}/bin/rsync -av --exclude=deps --exclude=assets/node_modules --exclude=_build --exclude=.opencode --exclude=.lexical --exclude=.git ${codebase}/ $launch

      if ("/var/share/gram/${name}/share" | path exists) {
        ${pkgs.rsync}/bin/rsync -a /var/share/gram/${name}/share $"($launch)/"
      } else { [$launch share ] | path join | mkdir $in }

      # let node = (ls ($launch | into glob)).name.0
      # tree -dafix --noreport $node | lines | each {|n| try { chmod 777 $n } }
      # try { ${pkgs.rsync}/bin/rsync -a ${place}/run/_build $launch }

      try { rm ${place}/run }; ln -s $launch ${place}/run
    '';

    prepare = ''
      cd ${place}/run;
      load-env (
        open /var/gram/${name}.call
        | str trim
        | lines
        | split column '=' --number 2
        | transpose -i -r --as-record
      );
      mkdir ${place}/deps
      mkdir ${place}/node_modules
      try { cp ${home}/gram/${name}.call ${place}/run/.call }
      chmod 765 ${place}/run/assets/
      ln -s ${place}/deps ${place}/run/deps
      ln -s ${place}/node_modules ${place}/run/assets/node_modules
      if ("${place}/run/static/assets/" | path exists) {
        chmod -R 765 ${place}/run/static/assets/ }

      load-env (
        open /var/gram/${name}.call
        | str trim
        | lines
        | split column '=' --number 2
        | transpose -i -r --as-record
      );

      ${elixir}/bin/mix deps.get
      ${elixir}/bin/mix prepare
      # ${pkgs.tree}/bin/tree -afix --noreport ${place}/run/priv/static | lines | where { ($in | path type) == file } | each { chmod 664 $in }
    '';

    run = with measures; ''
      ${load}
      ${clone}
      ${prepare}
      ${cycle}
    '';

    cycle = with measures; ''
      cd ${place}/run;
      load-env (
        open /var/gram/${name}.call
        | str trim
        | lines
        | split column '=' --number 2
        | transpose -i -r --as-record
      );
      ${elixir}/bin/mix release --overwrite
      ${close}
      ${name}-do daemon
    '';

    close = "try { ${close_channel channel} }";

    do = ''
    def main --wrapped [ ...call: string ] {
      ${command "...($call)"}
    }'';
  };

  close_channel = channel: ''
  let process = (
      netstat -tunlp | tail -n+3 | lines |
      split column -r ' +' |
      where column7 =~ $"/("beam")" |
      where column4 =~ ":${toString channel}" |
      get column7 | split row "/" | get 0 | into int
    ); kill $process
  '';

in {
  networking.firewall.allowedTCPPorts = [ 80 443 channel 5173 ];
  environment.systemPackages = with pkgs; with measures; [
    (nu "${name}-clone" clone)
    (nu "${name}-close" close)
    (nu "${name}-cycle" cycle)
    (nu "${name}-load" load)
    (nu "${name}-prepare" prepare)

    (nu "${name}-run" run)
    (nu "${name}-do" do)
  ] ++ dependencies;
}