gram: build

> ./config/nushell/disc.nu

Lenses
(coming soon!)

source ./nix.nu
source ./grammar.nu

# replace `disc` -> `card`; more generic on modern memory.

def --env d [ --bind (-b), ...names: string ] {
  if $bind { disc bind ...$names };
  let nodes = $names | each { |name| disc ls | where name =~ $name } | flatten
  cd $nodes.0.bind
  $nodes
}

def --env "d b" [] {
  d -b (((glob /dev/sd*) ++ (glob /dev/nvme0n*)) | path basename | choose)
}

def "disc chamber" [] { nsh gparted sudo -E gparted }

# def disc [] { nix-shell -p diskonaut --command diskonaut; }

def "disc block" [] {
  nix-shell -p xorg.xhost --command 'xhost +'
  nix-shell -p gparted --command 'sudo gparted'; }

def "disc ls" []  {
  findmnt --list | lines | split column -r " +" | reject 0 |
  rename bind source scheme mode | reject mode |
  insert name { $in.bind | path basename }
}
# { (ls /dev/sd*) ++ (ls /dev/nvme*); }

# launch discs memory card imager.
def "disc image" [] {
  nix-shell -p xorg.xhost --command 'xhost +'
  nix-shell -p rpi-imager --command 'sudo rpi-imager'; }


def "disc place" [label: string] { $"($env.HOME)/disc/(basename $label)" }
def "disc bind" [ ...labels: string ] {
  $labels | where not {|l| $l in (disc ls).name } |
    each { mkdir (disc place $in); sudo mount $"/dev/(basename $in)" (disc place $in) }

  $labels | each {|l| disc ls | where bind == (disc place $l) } | flatten
}

def "disc chec" [label?: string] { findmnt | lines }

def "disc size" [label?: string] {
  df | lines | split column --regex ' +' | headers |
    rename --column { Mounted: bind, Filesystem: label, Used: used, 1K-blocks: size, Available: open } |
    update cells -c [used open size] { 1024 * ($in | into int) | into filesize } |
    select bind label used open size |
    replace ($label | is-not-empty) { $in | choose-by bind $label }
}
alias "disc space" = disc size

# Prepare LUKS-encrypcion scheme on a disc.
def "disc prepare" [
  disc: string,
  name: string,
] {
  let source = [ /dev $disc ] | path join
  let label  = $"vg-($name)"

  nsh cryptsetup sudo cryptsetup luksFormat $source
  nsh cryptsetup sudo cryptsetup open $source $name
  sudo pvcreate ([/dev/mapper $name]|path join)
  sudo vgcreate $label ([/dev/mapper $name]|path join)
  sudo lvcreate -l 100%FREE -n $name $label
  sudo mkfs.ext4 -L $name ([/dev $label $name]|path join)
  nsh cryptsetup sudo cryptsetup luksDump $source

  disc open $disc $name
}

def "disc open" [
  disc: string,
  label: string,
] {
  let source  = [ /dev $disc                 ] | path join | path expand
  let mediary = [ /dev $"vg-($label)" $label ] | path join | path expand
  let mapped  = [ /dev/mapper $label         ] | path join | path expand
  let place   = [ ~/disc $label              ] | path join | path expand

  if not ($mediary | path exists) {
    nsh cryptsetup sudo cryptsetup open $source $label | print
    print "6 second loading period"; sleep 6sec
  }

  if not ($place | path exists) { mkdir $place }
  [ opening $mapped "->" $place] | str join " " | print
  sudo mount $mapped $place
}

def serial [] {
  print "Here are your discs:"; ls ~/disc | print
  print "recognizable plugged-in media:"; lsblk | print; print ''
  print "recognizable serial channels:"; lsusb | print; print ''
}

def "disc scan" [
  --dura (-d): duration = 8sec
] { loop { clear
  disc space | print
  sleep $dura
} }

## miscellaneous recipes:

# nsh cryptsetup sudo cryptsetup luksOpen $source
# sleep 2sec

# nsh cryptsetup sudo cryptsetup luksFormat /dev/sdb2
# nsh cryptsetup sudo cryptsetup luksOpen /dev/sdb1

# ls
# ls /dev/vg-rec/
# ls /dev/vg-rec/rec/
# mkdir ~/disc/rec
# sudo mount /dev/vg-rec/rec rec

def "disc slice" [label: string, slices: int] {
  let node = [ / dev $label ] | path join
  nsh parted sudo parted $node mklabel gpt
  1..$slices | each {
    let begin = ($in - 1) * (100 / $slices) | into int
    let end = ($in) * (100 / $slices) | into int
    nsh parted sudo parted $node mkpart zfs $"($begin)%" $"($end)%"
  }
  nsh parted sudo parted $node print
}

def "disc glob" [...labels: string] {
  $labels | each { (glob $"/dev/($in)") } | flatten
}

def "disc pool" --wrapped [label: string,
  --raidz2 (-2): list<string> = []
  --raidz1 (-1): list<string> = []
  --mirror (-m): list<string> = []
  --spares (-s): list<string> = []
  --run (-r)
  ...remaining: string # here you can use normal zpool options, like -f and -o.
] {
  let assigns = { raidz2: $raidz2, raidz1: $raidz1, spares: $spares, mirror: $mirror }
  let command = [ sudo zpool create ...$remaining $label
    ($assigns | transpose class labels | each {
      if not ($in.labels | is-empty) {
        [ $in.class ...(disc glob ...$in.labels) ]
      } }) ] | flatten | flatten | str join ' '
  if $run { nsh zfs $command; nsh zfs $"sudo zpool set failmode=continue ($label)" }
  $command
}

def "disc map" --wrapped [label: string, bind: path,
  --compress (-c): string,
  --secure (-s),
  --run (-r)
  ...remaining: string # here you can use normal zpool options, like -f and -o.
] {
  let ops = $remaining ++ (
    if not ($compress | is-empty) { [
      -o $"compression=($compress)"
    ]} else { [] }
    ) ++ (if $secure { [
      -o encryption=on
      -o keylocation=prompt
      -o keyformat=passphrase
    ]} else { [] }) |
    str join " "
  let command = [
    $"zfs create ($ops) ($label)"
    $"zfs set mountpoint=($bind) ($label)"
  ] | str join '; '
  if $run { sudo nu -e ($command + "; exit"); sudo chown (whoami) $bind; }
  $command
}

def "disc query" [--bound (-b), --unbound (-u)] {
  let labels = (zfs list | from ssv | where NAME =~ '/').NAME
  let sizes = disc size | where label in $labels
  if $bound { $sizes
  } else if $unbound { $labels | where not { $in in $sizes.label }
  } else { $labels }
}

def "disc load" [...labels: string] {
  if ($labels | all { $in in (disc query -b).label }) { return }
  try { sudo zpool import -a }
  if ($labels | is-empty) { sudo zfs mount -a -l -v
  } else {
    sudo zfs mount -l -v ...($labels | where { not ($in in (disc query -b).label) })
} }

def "disc unload" [...labels: string] {
  if ($labels | is-empty) { sudo zfs unmount -a -u
  } else { $labels | each { sudo zfs unmount -u $in }
} }