Implement Mutex, Atom, Channel and Exhaustable Channel in stdlib/synch

spec/ysh-stdlib-sync.test.sh

@@ -0,0 +1,204 @@
+# spec/ysh-stdlib-sync
+
+## our_shell: ysh
+
+#### fifo pipe double closes
+source --builtin draft-sync.ysh
+
+fifo-fd-new (&fd)
+try {
+  fifo-fd-destroy (fd)
+}
+echo $_status
+fifo-fd-destroy (fd)
+## status: 1
+## STDOUT:
+0
+## END
+
+#### semaphore syncrhonizing async jobs
+source --builtin draft-sync.ysh
+
+sema-new (1, &s)
+fork { 
+  sleep 0.2
+  sema-down (s)
+  echo 1
+}
+fork { 
+  sleep 0.4
+  sema-down (s)
+  echo 2
+}
+fork { 
+  sleep 0.6
+  sema-down (s)
+  echo 3
+}
+sleep 0.8
+echo 4
+sema-up (s)
+sleep 0.2
+echo 5
+sema-up (s)
+sema-destroy (s)
+## STDOUT:
+1
+4
+2
+5
+3
+## END
+
+#### semaphore init with 3, async up once and multiple down
+source --builtin draft-sync.ysh
+
+sema-new (3, &s)
+fork {
+  sleep 0.2
+  sema-up (s) 
+}
+sema-down (s)
+sema-down (s)
+sema-down (s)
+sema-down (s)
+echo yes
+## STDOUT:
+yes
+## END
+
+#### channel reads and writes
+source --builtin draft-sync.ysh
+
+channel-new (&ch)
+
+for i in (0..4) {
+  fork { 
+    for j in (0..4) { 
+      echo $j | channel-in (ch)
+    }
+  }
+}
+
+var sum = 0
+for i in (0..16) {
+  var cur = $(channel-out (ch)) => int()
+  setvar sum += cur
+}
+
+echo $sum
+channel-destroy (ch)
+## STDOUT:
+24
+## END
+
+#### channel but backed by blocked pipe
+source --builtin draft-sync.ysh
+
+channel-new (&ch, __pipe_methods_blocked_netstring(4))
+
+var sent = "I-am-a-pretty-damn-long-string-that-need-to-be-blocked"
+
+fork {
+  write -n -- "$sent" | channel-in (ch)
+}
+
+var received = $(channel-out (ch))
+echo $[received === sent]
+## STDOUT:
+true
+## END
+
+#### RWLock multiple shared lock and free, one exclusive lock
+source --builtin draft-sync.ysh
+
+atom-new (&lk)
+
+fork {
+  atom-lock-shared (lk)
+  echo 1
+  sleep 0.3
+  atom-unlock (lk)
+}
+for _ in (0..3) {
+  fork {
+    sleep 0.1
+    atom-lock-shared (lk)
+    echo 2
+    sleep 0.2
+    atom-unlock (lk)
+  }
+}
+sleep 0.1
+atom-lock-exclusive (lk)
+echo 3
+atom-unlock (lk)
+atom-destroy (lk)
+## STDOUT:
+1
+2
+2
+2
+3
+## END
+
+#### Reading and writing atom
+source --builtin draft-sync.ysh
+
+atom-new (&l)
+fork {
+  atom-lock-exclusive (l)
+  write -n 'w' | atom-write-in (l)
+  atom-unlock (l)
+}
+sleep 0.1
+
+for _ in (0..3) {
+  fork {
+    atom-lock-shared (l)
+    atom-read-out (l)
+    sleep 0.2
+    atom-read-out (l)
+    atom-unlock (l)
+  }
+}
+sleep 0.1
+write -n y
+wait
+atom-destroy (l)
+write
+## STDOUT:
+wwwywww
+## END
+
+#### Produce many value and exhaust the channel, and then reuse it
+source --builtin draft-sync.ysh
+
+exh-channel-new (&ch)
+
+for i in (0..4) {
+  fork { 
+    for j in (0..4) { 
+      echo $j | exh-channel-in (ch)
+    }
+  }
+}
+
+sleep 0.5
+exh-channel-exhaust (ch, &out)
+var sum = 0
+for i in (out) {
+  setvar sum += i
+}
+echo $sum
+# Reuses the channel
+fork {
+      echo "yes!" | exh-channel-in (ch)
+}
+exh-channel-out (ch)
+echo
+exh-channel-destroy (ch)
+## STDOUT:
+24
+yes!
+## END

stdlib/draft-descriptor.ysh

@@ -0,0 +1,89 @@
+#!/usr/bin/env ysh
+# vim:foldmethod=marker
+
+module stdlib/descriptor || return 0
+
+# General utilities for file descriptors {{{
+
+# NOTE: we need a proper exception system. 
+func getFdFile(fd) {
+  var fd_file
+  try {
+    setvar fd_file = $(readlink "/proc/$BASHPID/fd/$fd")
+  }
+  if (_status === 0) {
+    return (fd_file)
+  } else {
+    {
+      echo "File descriptor $fd is not opened by process $BASHPID!"
+    } >&2
+    exit 1
+  }
+}
+
+func getFdInfo(fd) {
+  var fd_info = "/proc/$BASHPID/fdinfo/$fd"
+  if test -f $fd_info {
+    return ($(cat $fd_info))
+  } else {
+    {
+      echo "File descriptor $fd is not opened by process $BASHPID!"
+    } >&2
+    exit 1
+  }
+}
+
+func getFdFlag(fd) {
+  var fd_info = getFdInfo(fd)
+  if (fd_info ~ / 'flags:' \t <capture digit+> /) {
+    return (_match(1))
+  } else {
+    {
+      echo "Can't find flags in for file descriptor $fd of process $BASHPID, here's the content:"
+      echo $fd_info
+    } >&2
+    exit 1
+  }
+}
+
+# O_RDONLY (00), O_WRONLY (01) & O_RDWR (02) 
+func isFdRead(fd) {
+  # HACK: this take one octal number direct from the number string,
+  # since currently there's no way to convert number bits in std.
+  var fd_flag = getFdFlag(fd)
+  return (fd_flag[-1] === "0" or fd_flag[-1] === "2" )
+}
+
+func isFdWrite (fd) {
+  var fd_flag = getFdFlag(fd)
+  return (fd_flag[-1] === "1" or fd_flag[-1] === "2")
+}
+
+# More strict than the standard version
+proc fd-destroy-and-rm-file(fd) {
+  var fd_file = getFdFile(fd)
+  # NOTE: bash treat >&- and <&- the same, not sure for ysh's case
+  # REFERENCE: https://unix.stackexchange.com/questions/131801/closing-a-file-descriptor-vs
+  exec {fd}>&-
+  rm $fd_file
+}
+
+# }}}
+# FIFO File Descriptors {{{
+
+proc fifo-fd-new(; out_fd) {
+  # WARN: this section should be critical but for now it's not
+  # A solution may be retry on fail.
+  #====================
+  var fifo = $(mktemp -u)
+  mkfifo $fifo
+  #====================
+  exec {fd}<>$fifo
+  call out_fd->setValue(fd)
+}
+
+proc fifo-fd-destroy (; fd) {
+  fd-destroy-and-rm-file $fd
+}
+
+# }}}