reorg

poc/py/main.py

@@ -0,0 +1,119 @@
+from sys import stdin, stdout
+import signal
+from os import getpid, kill
+import time
+
+def main(stream):
+   bucket = None
+   N = 3
+   R = 2
+   T = 2
+   triggered = CBAppend("/tmp/cbappend.triggered.txt")
+   triggered = CBAppend("/tmp/cbappend.both.txt")
+   released = CBAppend("/tmp/cbappend.both.txt")
+   cb = CBFork(triggered, released)
+   bucket = Bucket(N, R, T, cb.cb())
+
+   while readline():
+      print("bucket.push():", bucket.push())
+      stdout.flush()
+
+def readline():
+   try:
+      line = input()
+      return True
+   except EOFError:
+      return False
+
+class Bucket:
+   def __init__(self, N, R, T, CB):
+      self.q = 0.0
+      self.N = N
+      self.R = R
+      self.T = T
+      self.CB = CB
+      self.__last_pop = 0
+      self.__last_state = False
+
+   def push(self):
+      result = self.__push_c(1)
+      self.__cb()
+      return result
+
+   def pop(self):
+      result = self.__pop()
+      self.__cb()
+      return result
+
+   def __cb(self):
+      new_state = self.q > self.T
+      if new_state == self.__last_state:
+         return
+      self.__last_state = new_state
+      self.CB(new_state)
+
+   def state(self):
+      return self.__last_state
+
+   def __push_c(self, c):
+      self.__pop()
+      if self.q+c > self.N:
+         return False
+      self.q += c
+      return True
+
+   def __pop(self):
+      now = self.__now()
+      remove_up_to = (now - self.__last_pop) / self.R
+      if remove_up_to > self.q:
+         remove_up_to = self.q
+      self.q -= remove_up_to
+      self.__last_pop = now
+
+   def __now(self):
+      return time.time()
+
+class CBSignals():
+   def __init__(self, pid, signal_triggered, signal_released):
+      self.__pid = pid
+      self.__signal_triggered = signal_triggered
+      self.__signal_released = signal_released
+
+   def cb(self):
+      def cb(state):
+         print(f"state is now {state}")
+         kill(
+            self.__pid,
+            self.__signal_triggered if state else self.__signal_released,
+         )
+      handler = lambda s, f: print("SIGNAL:", s)
+      signal.signal(self.__signal_triggered, handler)
+      signal.signal(self.__signal_released, handler)
+      return cb
+
+class CBAppend():
+   def __init__(self, path):
+      self.__path = path
+
+   def cb(self):
+      def cb(state):
+         with open(self.__path, "a") as f:
+            f.write(f"{state}\n")
+      return cb
+
+class CBFork():
+   def __init__(self, triggered, released):
+      self.__triggered = triggered
+      self.__released = released
+
+   def cb(self):
+      cb_triggered = self.__triggered.cb()
+      cb_released = self.__released.cb()
+      def cb(state):
+         if state:
+            return cb_triggered(state)
+         return cb_released(state)
+      return cb
+
+if __name__ == "__main__":
+   main(stdin)

poc/py/test.sh

@@ -0,0 +1,13 @@
+#! /bin/bash
+
+(
+   for j in `seq 1 10`; do 
+      for i in `seq 1 10`; do 
+         echo $i
+         true || printf "$j/$i   " >&2
+         if ((i%j==0)); then 
+            sleep $j
+         fi
+      done
+   done
+) | python3 ./main.py