gram:build

> ./config/nushell/disc.nu

Lenses
(coming soon!)

let discs = [
  { address: /dev/nvme0n1p8, name: rec-clone, scheme: luks2 }
  { address: /dev/nvme0n1p9, name: cap, scheme: luks2 }
]

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

# 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*); }

def "disc size" [] {
  df | lines | split column --regex ' +' | headers |
    insert scale:g/used { ($in.used | into int) / 1024 / 1024 } |
    insert scale:g/size { ($in.1K-blocks | into int) / 1024 / 1024 } |
    select Mounted scale:g/used scale:g/size | rename node used size
}

# 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 ] {
  let luks2 = $labels | each {|l| $discs | where name == $l and scheme == luks2 } |
    flatten | filter {|d| not (disc ls | any { $in.bind == (disc place $d.name) }) }

  let norm  = $labels | each {|l| $discs | where name == $l and scheme != luks2 } |
    flatten | filter {|d| not (disc ls | any { $in.bind == (disc place $d.name) }) }

  $luks2 | each {|d| disc open $d.address $d.name | tee {print} }
  $norm | each {|d| mkdir (disc place $d.name); sudo mount $d.address (disc place $d.name); }

  $labels | filter {|l| not (disc ls | any { $in.name == $l } ) } |
    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 space" [] {
  let discs = df | lines | split column -r " +"
  $discs |
   rename ...(($discs.0 | transpose).column1) |
   drop nth 0 |
   rename label size used open p addr |
   select addr used open
}

# 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 ([ ~/disc $name ] | path join)
}

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

  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 $mediary "->" $place] | str join " " | print
  sudo mount $mediary $place
  # print $place; lsblk | print
}

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> = []
  --dangerous (-d): list<string> = []
  --run (-r)
  ...remaining: string # here you can use normal zpool options, like -f and -o.
] {
  let assigns = { '': $dangerous, raidz2: $raidz2, raidz1: $raidz1, spares: $spares, mirror: $mirror }
  let command = [ 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 { sudo nu -e ($command + "; exit")}
  $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")}
  $command
}

def "disc load" [...labels: string] {
  if ($labels | is-empty) { sudo zfs mount -a -l -v
  } else { $labels | each { sudo zfs mount -l -v $in }
} }

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