4 files changed, 580 insertions, 0 deletions

diff --git a/nim/file.nim b/nim/file.nim
new file mode 100644
index 0000000..83c2560
--- /dev/null
+++ b/nim/file.nim
@@ -0,0 +1,35 @@
+# tickwatch
+# Author: Euxane TRAN-GIRARD
+# Licence: EUPL-1.2
+
+import std/paths
+import std/strutils
+
+
+type
+  FileValueMonitor = ref object
+    path: Path
+
+  FileChangeMonitor = ref object
+    path: Path
+    lastValue: int
+
+proc readValue(path: Path): int =
+  readFile(path.string).strip.parseInt
+
+proc initFileValueMonitor*(path: Path): FileValueMonitor =
+  FileValueMonitor(path: path)
+
+proc readValue*(mon: FileValueMonitor): int =
+  mon.path.readValue()
+
+proc initFileChangeMonitor*(path: Path): FileChangeMonitor =
+  FileChangeMonitor(
+    path: path,
+    lastValue: path.readValue(),
+  )
+
+proc readValue*(mon: FileChangeMonitor): int =
+  let newValue = mon.path.readValue()
+  result = abs(mon.lastValue - newValue)
+  mon.lastValue = newValue
diff --git a/nim/logger.nim b/nim/logger.nim
new file mode 100644
index 0000000..48aedf2
--- /dev/null
+++ b/nim/logger.nim
@@ -0,0 +1,92 @@
+# tickwatch
+# Author: Euxane TRAN-GIRARD
+# Licence: EUPL-1.2
+
+import std/sugar
+import std/math
+import std/unicode
+import std/times
+import std/os
+
+
+const
+  TIMESTAMP_FORMAT = "yyyy-MM-dd HH:mmZZZ "
+  SKIPPED_SYMBOL = "."
+  UNKNOWN_SYMBOL = "!"
+  NUMERIC_SYMBOLS* = "123456789".toRunes
+  UNICODE_SYMBOLS* = "_▁▂▃▄▅▆▇█".toRunes
+
+
+type Scale* = proc(val: float): float {.noSideEffect.}
+
+proc indicator(symbols: seq[Rune], min, max, val: float, scale: Scale): Rune =
+  let division = scale(max - min) / float(symbols.len)
+  let bucket = int(scale(val - min) / division)
+  symbols[bucket.clamp(0, symbols.len - 1)]
+
+proc indicator*(symbols: seq[Rune], min, max, val: int, scale: Scale): Rune =
+  symbols.indicator(min.float, max.float, val.float, scale)
+
+func millisecond(t: DateTime): int =
+  t.nanosecond div (1_000_000)
+
+func msUntilNextSec(t: DateTime): int =
+  1000 - t.millisecond + 1
+
+proc puts(f: File, s: string) =
+  f.write s
+  f.flushFile
+
+proc puts(f: File, r: Rune) =
+  f.puts r.toUTF8
+
+func formatTimestampDateTime*(dt: DateTime): string =
+  dt.format(TIMESTAMP_FORMAT)
+
+func formatTimestampUnix*(dt: DateTime): string =
+  ($dt.toTime.toUnix) & " "
+
+func formatTimestampNone*(dt: DateTime): string =
+  ""
+
+proc loop*(
+  probe: (timeout: Duration) -> int,
+  getSymbol: (int) -> Rune,
+  timestampHeader: (DateTime) -> string,
+) =
+  while true:
+    stdout.puts timestampHeader(now())
+
+    for tick in 0..<60:
+      let t = now()
+      if tick < t.second:
+        stdout.puts SKIPPED_SYMBOL
+        continue
+
+      let timeout = initDuration(milliseconds = t.msUntilNextSec)
+      try:
+        let val = probe(timeout)
+        stdout.puts getSymbol(val)
+      except CatchableError:
+        stdout.puts UNKNOWN_SYMBOL
+
+      let tAfter = now()
+      if tAfter < t + timeout:
+        sleep(tAfter.msUntilNextSec)
+
+    stdout.puts "\n"
+
+proc flushAndQuit*() {.noconv.} =
+  stdout.puts "\n"
+  quit(0)
+
+
+when defined(test):
+  import std/unittest
+  import std/sequtils
+
+  suite "logger":
+    test "indicator value":
+      proc id(val: float): float = val
+      let indics = (0..30).mapIt(NUMERIC_SYMBOLS.indicator(5, 20, it, id))
+      check indics.deduplicate(isSorted = true) == NUMERIC_SYMBOLS
diff --git a/nim/main.nim b/nim/main.nim
new file mode 100644
index 0000000..0ea96f4
--- /dev/null
+++ b/nim/main.nim
@@ -0,0 +1,133 @@
+# tickwatch
+# Author: Euxane TRAN-GIRARD
+# Licence: EUPL-1.2
+
+import std/sugar
+import std/math
+import std/times
+import std/net
+import std/posix
+import std/paths
+import std/strutils
+import std/sequtils
+import std/parseopt
+
+import file
+import ping
+import logger
+
+
+const
+  NAME = "tickwatch"
+  VERSION = staticExec("""
+    command -v git >/dev/null && git describe --tags --always || echo $VERSION
+  """).strip()
+  HELP_TEXT =
+    staticRead("../readme.md")
+      .split("```helptext", 1)[1]
+      .split("```", 1)[0]
+      .strip()
+
+proc registerTerminationHandlers() =
+  proc terminationHandler(sig: cint) {.noconv.} = flushAndQuit()
+  var action = SigAction(sa_handler: terminationHandler)
+  for signal in [SIGTERM, SIGHUP, SIGQUIT, SIGINT]:
+    discard sigaction(signal, action)
+
+func getArg(
+  args: seq[tuple[kind: CmdLineKind, key, val: string]],
+  index: int,
+  label: string
+): string =
+  try: args[index].key
+  except: raise newException(ValueError, "Missing " & label & " argument")
+
+proc main() =
+  var
+    scale: Scale = log2
+    symbols = UNICODE_SYMBOLS
+    timestampHeader = formatTimestampDateTime
+    (min, max) = (0, 1000)
+
+  for optKind, key, val in getopt():
+    if optKind notin {cmdLongOption, cmdShortOption}:
+      continue
+
+    case key:
+
+    of "help", "h":
+      echo HELP_TEXT
+      quit(0)
+
+    of "version", "v":
+      echo NAME & " " & VERSION
+      quit(0)
+
+    of "scale":
+      case val:
+      of "logarithmic", "log", "log2": scale = log2
+      of "log10": scale = log10
+      of "ln": scale = ln
+      of "linear", "lin": scale = (val: float) => val
+      else: raise newException(ValueError, "Unrecognised scale choice")
+
+    of "symbols":
+      case val:
+      of "unicode", "utf8", "utf-8": symbols = UNICODE_SYMBOLS
+      of "numeric", "ascii": symbols = NUMERIC_SYMBOLS
+      else: raise newException(ValueError, "Unrecognised symbols choice")
+
+    of "timestamp":
+      case val:
+      of "datetime", "date-time": timestampHeader = formatTimestampDateTime
+      of "unix", "epoch": timestampHeader = formatTimestampUnix
+      of "none", "false": timestampHeader = formatTimestampNone
+      else: raise newException(ValueError, "Unrecognised timestamp choice")
+
+    of "range":
+      let parts = val.split(':', 1)
+      if parts.len != 2: raise newException(ValueError, "Invalid range")
+      (min, max) = (parseInt(parts[0]), parseInt(parts[1]))
+
+    else:
+      raise newException(ValueError, "Unrecognised option")
+
+  let
+    args = getopt().toSeq.filterIt(it.kind == cmdArgument)
+    monitor = args.getArg(0, "monitor")
+    target = args.getArg(1, "target")
+
+  if args.len > 2:
+    raise newException(ValueError, "Invalid number of arguments")
+
+  let probe = case monitor:
+    of "ping":
+      let targetIp = resolve(target)
+      let mon = initPingMonitor(targetIp, procIdent())
+      (timeout: Duration) => mon.ping(timeout).inMilliseconds.int
+
+    of "value":
+      let mon = initFileValueMonitor(Path target)
+      (timeout: Duration) => mon.readValue()
+
+    of "change":
+      let mon = initFileChangeMonitor(Path target)
+      (timeout: Duration) => mon.readValue()
+
+    else:
+      raise newException(ValueError, "Unrecognised monitor argument")
+
+  loop(
+    probe,
+    (val: int) => symbols.indicator(min, max, val, scale),
+    timestampHeader,
+  )
+
+
+when not defined(test):
+  try:
+    registerTerminationHandlers()
+    main()
+  except CatchableError as err:
+    stderr.writeLine err.msg