retracesoftware-proxy 0.1.13__py3-none-any.whl → 0.1.15__py3-none-any.whl

retracesoftware/config.json

@@ -4,7 +4,6 @@
     "internal", {"comment": "Default state when retrace is disabled for a thread"},
     "external", {"comment": "When target thread is running outside the python system to be recorded"},
     "retrace", {"comment": "When target thread is running outside the retrace system"},
-    "bootstrap", {"comment": "When the target thread is running in the low-level module load machinery"},
     "gc", {"comment": "When the target thread is running inside the pyton garbage collector"}
   ],
 
@@ -159,8 +158,10 @@
   "modules": {
     "_imp": {
       "patch_extension_exec": ["exec_dynamic", "exec_builtin"],
-      "with_state": {
-        "internal": ["create_dynamic"]
+      "comment": {
+        "with_state": {
+          "internal": ["create_dynamic"]
+        }
       }
     },
     "bdb": {
@@ -173,6 +174,7 @@
         "disabled": ["Bdb.trace_dispatch"]
       }
     },
+
     "sys": {
       "with_state": {
         "disabled": ["excepthook"]
@@ -184,9 +186,21 @@
       }
     },
     
-    "importlib._bootstrap": {
+    "importlib": {
       "with_state": {
-        "bootstrap": ["_load_unlocked", "_find_spec"]
+        "disabled": ["import_module"]
+      }
+    },
+
+    "importlib._bootstrap": {
+      "comment": {
+        "with_state": {
+          "internal": [
+            "_load_unlocked",
+            "_find_spec",
+            "_lock_unlock_module",
+            "_get_module_lock"]
+        }
       }
     },
 
@@ -218,14 +232,24 @@
       ]
     },
     "types": {
+      "patch_hash": ["FunctionType"],
       "immutable_types": [
-        "TracebackType"
+        "TracebackType",
+        "ModuleType"
       ]
     },
     "builtins": {
-      "replace": {
-        "set": "retracesoftware_utils.set",
-        "frozenset": "retracesoftware_utils.frozenset"
+      "patch_hash": ["object"],
+
+      "with_state": {
+        "disabled": ["__import__"]
+      },
+
+      "comment": {
+        "replace": {
+          "set": "retracesoftware_utils.set",
+          "frozenset": "retracesoftware_utils.frozenset"
+        }
       },
       "immutable_types": [
         "BaseException",

retracesoftware/install/patcher.py

@@ -29,6 +29,8 @@ import retracesoftware.utils as utils
 
 from retracesoftware.install import edgecases
 from functools import partial
+from retracesoftware.proxy.thread import start_new_thread_wrapper
+
 # from retrace_utils.intercept import proxy
 
 # from retrace_utils.intercept.typeutils import *
@@ -121,9 +123,22 @@ def patch(func):
         if isinstance(spec, str):
             return wrapper(self, [spec], mod_dict)
         elif isinstance(spec, list):
-            return {name: func(self, mod_dict[name]) for name in spec if name in mod_dict}
+            res = {}
+            for name in spec:
+                if name in mod_dict:
+                    value = func(self, mod_dict[name])
+                    if value is not None:
+                        res[name] = value
+            return res
         elif isinstance(spec, dict):
-            return {name: func(self, mod_dict[name], value) for name, value in spec.items() if name in mod_dict}
+            # return {name: func(self, mod_dict[name], value) for name, value in spec.items() if name in mod_dict}
+            res = {}
+            for name,value in spec.items():
+                if name in mod_dict:
+                    value = func(self, mod_dict[name], value)
+                    if value is not None:
+                        res[name] = value
+            return res
         else:
             raise Exception('TODO')
 
@@ -155,6 +170,11 @@ def wrap_method_descriptors(wrapper, prefix, base):
 
     return extended
 
+class PerThread(threading.local):
+    def __init__(self):
+        self.internal = utils.counter()
+        self.externak = utils.counter()
+
 class Patcher:
 
     def __init__(self, thread_state, config, system, 
@@ -164,7 +184,7 @@ class Patcher:
                  post_commit = None):
         
         # validate(config)
-        # system.set_thread_id(0)
+        system.set_thread_id(0)
         # utils.set_thread_id(0)
         self.thread_counter = system.sync(utils.counter(1))
         # self.set_thread_number = set_thread_number
@@ -181,6 +201,13 @@ class Patcher:
         self.exclude_paths = [re.compile(s) for s in config.get('exclude_paths', [])]
         self.typepatcher = {}
 
+        per_thread = PerThread()
+        
+        self.hashfunc = self.thread_state.dispatch(
+            functional.constantly(None),
+            internal = functional.repeatedly(functional.partial(getattr, per_thread, 'internal')),
+            external = functional.repeatedly(functional.partial(getattr, per_thread, 'external')))
+
         def is_phase(name): return getattr(getattr(self, name, None), "is_phase", False)
         
         self.phases = [(name, getattr(self, name)) for name in Patcher.__dict__.keys() if is_phase(name)]
@@ -275,22 +302,29 @@ class Patcher:
 
     @patch
     def patch_start_new_thread(self, value):
-        def start_new_thread(function, *args):
-            # synchronized, replay shoudl yield correct number
-            thread_id = self.thread_counter()
+        return start_new_thread_wrapper(thread_state = self.thread_state, 
+                                        on_exit = self.system.on_thread_exit,
+                                        start_new_thread = value)
+    
+        # def start_new_thread(function, *args):
+        #     # synchronized, replay shoudl yield correct number
+        #     thread_id = self.thread_counter()
 
-            def threadrunner(*args, **kwargs):
-                nonlocal thread_id
-                self.system.set_thread_id(thread_id)
+        #     def threadrunner(*args, **kwargs):
+        #         nonlocal thread_id
+        #         self.system.set_thread_id(thread_id)
                 
-                with self.thread_state.select('internal'):
-                    # if self.tracing:
-                    #     FrameTracer.install(self.thread_state.dispatch(noop, internal = self.checkpoint))    
-                    return function(*args, **kwargs)
+        #         with self.thread_state.select('internal'):
+        #             try:
+        #                 # if self.tracing:
+        #                 #     FrameTracer.install(self.thread_state.dispatch(noop, internal = self.checkpoint))    
+        #                 return function(*args, **kwargs)
+        #             finally:
+        #                 print(f'exiting: {thread_id}')
 
-            return value(threadrunner, *args)
+        #     return value(threadrunner, *args)
 
-        return self.thread_state.dispatch(value, internal = start_new_thread)
+        # return self.thread_state.dispatch(value, internal = start_new_thread)
 
     @phase
     def wrappers(self, spec, mod_dict): 
@@ -298,24 +332,22 @@ class Patcher:
 
     @patch
     def patch_exec(self, exec):
-        def is_module_exec(source):
-            return isinstance(source, types.CodeType) and \
-                    source.co_name == '<module>' and inspect.getmodule(source)
-
-        def exec_wrapper(source, *args,**kwargs):
-            if self.thread_state.value != 'boostrap' and is_module_exec(source):
-                with self.thread_state.select('disabled'):
-                    module = inspect.getmodule(source)
-                with self.thread_state.select('internal'):
-                    result = exec(source, *args, **kwargs)
-                
-                self(module)
 
-                return result
-            else:
-                return exec(source, *args,**kwargs)
+        def exec_wrapper2(source, *args,**kwargs):
+            if isinstance(source, types.CodeType) and source.co_name == '<module>':
+                self(inspect.getmodule(source))
         
-        return exec_wrapper
+        def first(x): return x[0]
+            
+        wrapped_exec = functional.sequence(
+            functional.vector(
+                self.thread_state.wrap('internal', exec),
+                exec_wrapper2),
+            first)
+
+        return self.thread_state.dispatch(exec, internal = wrapped_exec)
+    
+    # self.thread_state.wrap(desired_state = 'disabled', function = exec_wrapper)
 
     @patch
     def sync_types(self, value):
@@ -372,6 +404,10 @@ class Patcher:
         
         return updates
 
+    @patch
+    def patch_hash(self, cls):
+        utils.patch_hash(cls = cls, hashfunc = self.hashfunc)
+
     @patch
     def patch_extension_exec(self, exec):
         
@@ -450,6 +486,8 @@ class Patcher:
 
     def patch_module_with_name(self, mod_name, module):
         with self.disable:
+            print(f'Patching: {module}')
+
             self.log('install.module', mod_name)
 
             # self.system.log(f'patching module: {mod_name}')
@@ -474,19 +512,23 @@ class Patcher:
 
     def __call__(self, module):
 
-        if self.thread_state.value == 'internal' and not hasattr(module, '__retrace__'):
-            with self.thread_state.select('bootstrap'):
-                configs = list(self.configs(module))
-
-                if len(configs) > 0:
-                    if len(configs) > 1:
-                        raise Exception(f'TODO')
-                    else:
-                        module.__retrace__ = None
-                        try:
-                            self.patch_module_with_name(configs[0], module)
-                        except Exception as error:
-                            raise Exception(f'Error patching module: {configs[0]}') from error
+        print(f'patcher called with: {module} {self.thread_state.value}')
+
+        if not hasattr(module, '__retrace__'):
+
+            print(f'patcher called with: {module} 1')
+
+            configs = list(self.configs(module))
+
+            if len(configs) > 0:
+                if len(configs) > 1:
+                    raise Exception(f'TODO')
+                else:
+                    module.__retrace__ = None
+                    try:
+                        self.patch_module_with_name(configs[0], module)
+                    except Exception as error:
+                        raise Exception(f'Error patching module: {configs[0]}') from error
 
         return module
     

retracesoftware/install/record.py

@@ -13,9 +13,15 @@ from datetime import datetime
 import json
 from pathlib import Path
 
-class ThreadSwitch:
-    def __init__(self, id):
-        self.id = id
+# class ThreadSwitch:
+#     def __init__(self, id):
+#         self.id = id
+    
+#     def __repr__(self):
+#         return f'ThreadSwitch<{self.id}>'
+
+#     def __str__(self):
+#         return f'ThreadSwitch<{self.id}>'
 
 def write_files(recording_path):
     with open(recording_path / 'env', 'w') as f:

retracesoftware/proxy/__init__.py

@@ -1,3 +1,3 @@
 from retracesoftware.proxy.record import RecordProxySystem
 from retracesoftware.proxy.replay import ReplayProxySystem
-from retracesoftware.proxy.thread import set_thread_id, per_thread_messages
+from retracesoftware.proxy.thread import per_thread_messages

retracesoftware/proxy/globalref.py

@@ -0,0 +1,31 @@
+import types
+import sys
+
+def find_module_name(mod):
+    for name,value in sys.modules.items():
+        if value is mod:
+            return name
+    
+    raise Exception(f"Cannot create GlobalRef as module {mod} not found in sys.modules")
+
+class GlobalRef:
+    __slots__ = ['parts']
+
+    def __init__(self, obj):
+        if isinstance(obj, types.ModuleType):
+            self.parts = (find_module_name(obj),)
+        else:
+            raise Exception(f"Cannot create GlobalRef from {obj}")
+
+    def __call__(self):
+        module = self.parts[0]
+
+        if len(self.parts) == 0:
+            return module
+        else:
+            obj = getattr(module, self.parts[1])
+            
+            if len(self.parts) == 1:
+                return obj
+            else:
+                raise Exception(f"TODO")

retracesoftware/proxy/proxysystem.py

@@ -100,8 +100,8 @@ class ProxySystem:
             default = tracer(name, unproxy_execute)
             return thread_state.dispatch(default, internal = internal, external = external)
 
-        self.ext_handler = self.wrap_int_to_ext(int2ext)
-        self.int_handler = self.wrap_ext_to_int(ext2int)
+        self.ext_handler = thread_state.wrap('retrace', self.wrap_int_to_ext(int2ext))
+        self.int_handler = thread_state.wrap('retrace', self.wrap_ext_to_int(ext2int))
 
         self.ext_dispatch = gateway('proxy.int.disabled.event', internal = self.ext_handler)
         self.int_dispatch = gateway('proxy.ext.disabled.event', external = self.int_handler)
@@ -126,6 +126,9 @@ class ProxySystem:
         self.thread_state.value = self.saved_thread_state
         self.fork_counter += 1
 
+    def on_thread_exit(self, thread_id):
+        pass
+
     # def create_stub(self): return False
         
     def int_proxytype(self, cls):
@@ -156,6 +159,8 @@ class ProxySystem:
         return utils.wrapped_function(handler = self.ext_handler, target = obj)
         
     def patchtype(self, cls):
+        print(f'Proxying type: {cls}')
+
         if cls in self.immutable_types or issubclass(cls, tuple):
             return cls
 

retracesoftware/proxy/proxytype.py

@@ -214,10 +214,16 @@ def dynamic_proxytype(handler, cls):
     
     for name in superdict(cls).keys():
         if name not in blacklist:
-            value = getattr(cls, name)
-            if is_descriptor(value):
-                if utils.is_method_descriptor(value):
-                    spec[name] = wrap(value)
+            try:
+                value = getattr(cls, name)
+                if is_descriptor(value):
+                    if utils.is_method_descriptor(value):
+                        spec[name] = wrap(value)
+            except Exception as error:
+                print(f'FOO! {cls} {name} {error}')
+                breakpoint()
+                raise
+    
                 # else:
                 #     spec[name] = DescriptorProxy(handler = handler, target = value)
 

retracesoftware/proxy/record.py

@@ -5,9 +5,10 @@ import retracesoftware.stream as stream
 from retracesoftware.proxy.proxytype import *
 # from retracesoftware.proxy.gateway import gateway_pair
 from retracesoftware.proxy.proxysystem import ProxySystem
-from retracesoftware.proxy.thread import write_thread_switch
+from retracesoftware.proxy.thread import write_thread_switch, ThreadSwitch, thread_id
 from retracesoftware.install.tracer import Tracer
 from retracesoftware.proxy.stubfactory import StubRef, ExtendedRef
+from retracesoftware.proxy.globalref import GlobalRef
 
 import sys
 import os
@@ -69,14 +70,11 @@ class RecordProxySystem(ProxySystem):
         super().after_fork_in_parent()
         self.thread_state.value = self.saved_thread_state
         self.writer.reopen()
-
-    def sync(self, function):
-        write_sync = functional.always(self.writer.handle('SYNC'))
-
-        return utils.observer(
-            on_call = functional.firstof(self.thread_switch_monitor, write_sync),
-            function = function)
     
+    def set_thread_id(self, id):
+        utils.set_thread_id(self.writer.handle(ThreadSwitch(id)))
+        # utils.set_thread_id(id)
+
     def __init__(self, thread_state, 
                  immutable_types, 
                  tracing_config,
@@ -89,8 +87,17 @@ class RecordProxySystem(ProxySystem):
         
         self.pid = self.getpid()
 
-        self.writer = stream.writer(path)
+        self.writer = stream.writer(path = path, thread = thread_id)
         
+        # def on_switch():
+        #     print(f"On thread switch!!!")
+        #     # print(f"On thread switch!!!: {utils.thread_id().id}")
+        #     # utils.sigtrap(utils.thread_id())
+        #     self.writer(utils.thread_id())
+        #     # utils.sigtrap(utils.thread_id())
+
+        # write = utils.observer(on_call = utils.thread_switch_monitor(on_switch), function = self.writer)
+
         # w = self.writer.handle('TRACE')
         # def trace_writer(*args):
         #     print(f'Trace: {args}')
@@ -102,12 +109,23 @@ class RecordProxySystem(ProxySystem):
 
         serialize = functional.walker(self.bindings.get_else_key)
         
-        self.thread_switch_monitor = \
-            utils.thread_switch_monitor(
-                functional.repeatedly(functional.sequence(utils.thread_id, self.writer)))
+        # def on_switch():
+        #     print("On thread switch!!!")
+        #     # utils.sigtrap(utils.thread_id())
+        #     utils.thread_id()()
+        #     # utils.sigtrap(utils.thread_id())
+
+        # self.thread_switch_monitor = utils.thread_switch_monitor(on_switch)
+
+        # self.thread_switch_monitor = utils.thread_switch_monitor(functional.repeatedly(utils.thread_id))
 
         # self.sync = lambda function: functional.firstof(self.thread_switch_monitor, functional.always(self.writer.handle('SYNC')), function)
-            
+
+        sync_handle = self.writer.handle('SYNC')
+
+        self.sync = lambda function: \
+            utils.observer(on_call = functional.lazy(sync_handle), function = function)
+
         error = self.writer.handle('ERROR')
 
         def write_error(cls, val, traceback):
@@ -115,8 +133,6 @@ class RecordProxySystem(ProxySystem):
         
         # self.set_thread_id = functional.partial(utils.set_thread_id, self.writer)
 
-        def watch(f): return functional.either(self.thread_switch_monitor, f)
-
         # w = self.writer.handle('TRACE')
         # def foo(name, *args):
         #     print(f'writing: {self.writer.messages_written} {name} {args}')
@@ -125,7 +141,7 @@ class RecordProxySystem(ProxySystem):
         # tracer = Tracer(tracing_config, writer = foo)
         tracer = Tracer(tracing_config, writer = self.writer.handle('TRACE'))
 
-        self.wrap_int_to_ext = watch
+        # self.wrap_int_to_ext = self.sync
         
         self.on_int_call = functional.mapargs(transform = serialize, function = self.writer.handle('CALL'))
         
@@ -135,6 +151,8 @@ class RecordProxySystem(ProxySystem):
 
         self.ext_apply = self.int_apply = functional.apply
 
+        self.writer.type_serializer[types.ModuleType] = GlobalRef
+
         super().__init__(thread_state = thread_state, 
                          tracer = tracer, 
                          immutable_types = immutable_types)

retracesoftware/proxy/replay.py

@@ -3,17 +3,19 @@ import retracesoftware_utils as utils
 import retracesoftware.stream as stream
 
 from retracesoftware.install.tracer import Tracer
-from retracesoftware.proxy.thread import per_thread_messages
+from retracesoftware.proxy.thread import per_thread_messages, thread_id
 from retracesoftware.proxy.proxytype import *
 # from retracesoftware.proxy.gateway import gateway_pair
 from retracesoftware.proxy.record import StubRef, Placeholder
 from retracesoftware.proxy.proxysystem import ProxySystem, RetraceError
-from retracesoftware.proxy.stubfactory import StubFactory, StubFunction
+from retracesoftware.proxy.stubfactory import StubFactory, Stub, StubFunction
+from retracesoftware.proxy.globalref import GlobalRef
 
 import os
 import weakref
 import traceback
 import pprint
+
 from itertools import count, islice
 
 # we can have a dummy method descriptor, its has a __name__ and when called, returns the next element
@@ -60,6 +62,8 @@ def on_stack_mismatch(last_matching, record, replay):
         print('Record stacktrace:')
         for line in islice(record, 0, len(record) - matching):
             print(line)
+        
+        print(f'-----------')
     else:
         matching = count_matching(reversed(record), reversed(replay))
 
@@ -74,36 +78,52 @@ def on_stack_mismatch(last_matching, record, replay):
         print('Record stacktrace:')
         for line in islice(record, 0, len(record) - matching):
             print(line)
+        
 
 
 class ReplayProxySystem(ProxySystem):
     
     @utils.striptraceback
     def next_result(self):
-        while True:
-            next = self.messages()
+        try:
+            while True:
+                next = self.messages()
+
+                if next == 'CALL':
+                    func = self.messages()
+                    args = self.messages()
+                    kwargs = self.messages()
+
+                    try:
+                        func(*args, **kwargs)
+                    except:
+                        pass
+
+                elif next == 'RESULT':
+                    return self.messages()
+                
+                elif next == 'ERROR':
+                    # breakpoint()
+                    err_type = self.messages()
+                    err_value = self.messages()
+                    utils.raise_exception(err_type, err_value)
+                else:
+                    assert type(next) is not str
+                    return next
+        except TimeoutError:
+            print(f'timeout for reader, active thread: {self.reader.active_thread}, next_control: {self.reader.next_control}')
 
-            if next == 'CALL':
-                func = self.messages()
-                args = self.messages()
-                kwargs = self.messages()
+            for thread,stack in self.reader.stacktraces.items():
+                print(f'thread: {thread}')
 
-                try:
-                    func(*args, **kwargs)
-                except:
-                    pass
+                formatted_frames = [
+                    (frame.filename, frame.lineno, frame.function, frame.code_context[0].strip() if frame.code_context else None)
+                    for frame in stack
+                ]
+                formatted_trace = traceback.format_list(formatted_frames)
+                print("Traceback (most recent call last):\n" + "".join(formatted_trace))
 
-            elif next == 'RESULT':
-                return self.messages()
-            
-            elif next == 'ERROR':
-                # breakpoint()
-                err_type = self.messages()
-                err_value = self.messages()
-                utils.raise_exception(err_type, err_value)
-            else:
-                assert type(next) is not str
-                return next
+            utils.sigtrap(None)
 
     def bind(self, obj):
         read = self.messages()
@@ -137,7 +157,6 @@ class ReplayProxySystem(ProxySystem):
     def basetype(self, cls):
         return self.stub_factory.create_stubtype(StubRef(cls))
 
-
     def readnext(self):
         with self.thread_state.select('disabled'):
             try:
@@ -153,12 +172,16 @@ class ReplayProxySystem(ProxySystem):
     def read_required(self, required):
         obj = self.readnext()
         if obj != required:
+            print('---------------------------------')
+            print('last matching stack')
+            print('---------------------------------')
             if self.last_matching_stack:
                 for line in self.last_matching_stack:
                     print(line)
 
             print('---------------------------------')
             print(f'Replay: {required}')
+            print('---------------------------------')
             for line in utils.stacktrace():
                 print(line)
             print('---------------------------------')
@@ -196,8 +219,10 @@ class ReplayProxySystem(ProxySystem):
                 for arg in args:
                     self.read_required(arg)
 
-    def sync(self, function):
-        return utils.observer(on_call = functional.always(self.read_sync), function = function)
+    def on_thread_exit(self, thread_id):
+        print(f'on_thread_exit!!!!')
+        self.reader.wake_pending()
+
 
     def __init__(self, 
                  thread_state,
@@ -207,28 +232,50 @@ class ReplayProxySystem(ProxySystem):
                  fork_path = []):
         
         # self.messages_read = 0
-        self.reader = stream.reader(path)
 
+        self.reader = stream.reader(path, 
+                                    thread = thread_id,
+                                    timeout_seconds = 5)
+    
         self.bindings = utils.id_dict()
-        self.set_thread_id = utils.set_thread_id
+        # self.set_thread_id = utils.set_thread_id
         self.fork_path = fork_path
         deserialize = functional.walker(self.bindings.get_else_key)
 
         # def count(res):
         #     self.messages_read += 1
         #     return res
+
+        read_res = functional.vector(functional.lazy(getattr, self.reader, 'messages_read'), self.reader)
+
+        def foo():
+            try:
+                messages_read, res = read_res()
+                if issubclass(type(res), Stub):
+                    print(f'res: {utils.thread_id()} {messages_read} stub: {type(res)}')
+                else:
+                    print(f'res: {utils.thread_id()} {messages_read} {res}')
+
+                return res
+            except Exception as error:
+                print(f'Error reading next result: {error}')
+                raise(error)
         
-        self.messages = functional.sequence(per_thread_messages(self.reader), 
-                                            deserialize)                                        
+        # self.messages = functional.sequence(per_thread_messages(foo), deserialize)
+
+        self.messages = functional.sequence(self.reader, deserialize)
 
         self.stub_factory = StubFactory(thread_state = thread_state, next_result = self.next_result)
 
         self.last_matching_stack = None
 
         self.reader.type_deserializer[StubRef] = self.stub_factory
+        self.reader.type_deserializer[GlobalRef] = lambda ref: ref()
                 
-        self.read_sync = functional.always(lambda: self.read_required('SYNC'))
-    
+        read_sync = functional.lazy(self.read_required, 'SYNC')
+
+        self.sync = lambda function: utils.observer(on_call = read_sync, function = function)
+
         super().__init__(thread_state = thread_state, 
                          tracer = Tracer(tracing_config, writer = self.trace_writer),
                          immutable_types = immutable_types)

retracesoftware/proxy/thread.py

@@ -1,6 +1,9 @@
 import retracesoftware.functional as functional
 import retracesoftware_utils as utils
 
+import os
+import _thread
+
 # def thread_aware_writer(writer):
 #     on_thread_switch = functional.sequence(utils.thread_id(), writer.handle('THREAD_SWITCH'))
 #     return utils.threadawareproxy(on_thread_switch = on_thread_switch, target = writer)
@@ -11,23 +14,35 @@ class ThreadSwitch:
     def __init__(self, id):
         self.id = id
 
-def set_thread_id(writer, id):
-    utils.set_thread_id(writer.handle(ThreadSwitch(id)))
+    def __repr__(self):
+        return f'ThreadSwitch<{self.id}>'
+
+    def __str__(self):
+        return f'ThreadSwitch<{self.id}>'
+
+# def set_thread_id(writer, id):
+#     utils.sigtrap(id)
+#     utils.set_thread_id(writer.handle(ThreadSwitch(id)))
 
 def write_thread_switch(writer):
     on_thread_switch = functional.repeatedly(functional.sequence(utils.thread_id, writer))
 
     return lambda f: utils.thread_aware_proxy(target = f, on_thread_switch = on_thread_switch, sticky = False)
 
-def prefix_with_thread_id(f, current):
+def prefix_with_thread_id(f, thread_id):
+    current = None
+
     def next():
         nonlocal current, f
+        if current is None: current = thread_id()
+
         obj = f()
 
         while issubclass(type(obj), ThreadSwitch):
             current = obj.id
             obj = f()
 
+        # print(f'prefix_with_thread_id: {(current, obj)}')
         return (current, obj)
 
     return next
@@ -36,7 +51,15 @@ def per_thread_messages(messages):
     thread_id = utils.thread_id
     # thread_id = lambda: 'FOOOOO!!!'
 
-    demux = utils.demux(source = prefix_with_thread_id(messages, thread_id()), key_function = lambda obj: obj[0])
+    def on_timeout(demux, key):
+        print(f'ON TIMEOUT!!!! {key} pending: {demux.pending} {demux.pending_keys}')
+        utils.sigtrap(demux)
+        os._exit(1)
+
+    demux = utils.demux(source = prefix_with_thread_id(messages, thread_id),
+                        key_function = lambda obj: obj[0],
+                        timeout_seconds = 60,
+                        on_timeout = on_timeout)
 
     # def next():
     #     thread,message = demux(thread_id())
@@ -44,3 +67,40 @@ def per_thread_messages(messages):
     
     # return next
     return functional.repeatedly(lambda: demux(thread_id())[1])
+
+
+# _thread.start_new_thread(function, args[, kwargs])
+counters = _thread._local()
+counters.id = ()
+counters.counter = 0
+
+def with_thread_id(thread_id, on_exit, function):
+    def on_call(*args, **kwargs):
+        counters.id = thread_id
+        counters.counter = 0
+
+    def on_result(res):
+        on_exit(thread_id)
+    
+    def on_error(*args):
+        on_exit(thread_id)
+
+    return utils.observer(on_call = on_call, on_result = on_result, on_error = on_error, function = function)
+
+thread_id = functional.lazy(getattr, counters, 'id')
+
+def start_new_thread_wrapper(thread_state, on_exit, start_new_thread):
+
+    def wrapper(function, *args):
+        
+        next_id = counters.id + (counters.counter,)
+        counters.counter += 1
+
+        wrapped_function = with_thread_id(thread_id = next_id,
+                                          on_exit = on_exit, 
+                                          function = thread_state.wrap('internal', function))
+
+        return start_new_thread(wrapped_function, *args)
+
+    return thread_state.dispatch(start_new_thread, internal = wrapper)
+

{retracesoftware_proxy-0.1.13.dist-info → retracesoftware_proxy-0.1.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: retracesoftware_proxy
-Version: 0.1.13
+Version: 0.1.15
 License: Apache-2.0
 Requires-Dist: retracesoftware_utils
 Requires-Dist: retracesoftware_functional

{retracesoftware_proxy-0.1.13.dist-info → retracesoftware_proxy-0.1.15.dist-info}/RECORD

@@ -1,28 +1,29 @@
 retracesoftware/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-retracesoftware/config.json,sha256=WfqWtMeimFWl9aEs0V34Nshb77TmXBeTkwT6alWpN2Q,8779
+retracesoftware/config.json,sha256=yMAD8410r8VEnBToXNmtfaBz6MClBVEiKsq6vKgSI0c,9121
 retracesoftware/config.yaml,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 retracesoftware/install/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 retracesoftware/install/config.py,sha256=EzE5ifQF2lo--hu2njI4T0FJ-zlnWDJV6i7x0DMkVTw,1364
 retracesoftware/install/edgecases.py,sha256=NR3lyvad9sRsyeDv_Ya8V4xMgPsMPOi9rMcnFOJGOEA,6330
 retracesoftware/install/globals.py,sha256=F8XvIoZQQ10gSRalk30dvdKllxlwxkaggYY6FogLDxY,510
 retracesoftware/install/install.py,sha256=HCD_ji8XCr96b5fNzNdL_8qcEp0Jf05Em7T6GA6u8HU,4969
-retracesoftware/install/patcher.py,sha256=IUkQx5kr4AnniKZ2gWnnx2is1j_y_eb7nz2UKyHyqSA,18894
+retracesoftware/install/patcher.py,sha256=_J8YTDd0QNLgURRyrUFikNsImgMOBhCv8Nmps5rjkZI,20241
 retracesoftware/install/predicate.py,sha256=tX7NQc0rGkyyHYO3mduYHcJHbw1wczT53m_Dpkzo6do,2679
-retracesoftware/install/record.py,sha256=tseF_jV4k4HLPTgBPJdjcahl4EQqagoiisMAdGNC52Q,3257
+retracesoftware/install/record.py,sha256=R2GOIA_WAggrNmVwZJh9r1xp-GVu43iKq-ykQ1VKEHE,3408
 retracesoftware/install/references.py,sha256=A-G651IDOfuo00MkbAdpbIQh_15ChvJ7uAVTSmE6zd4,1721
 retracesoftware/install/replay.py,sha256=VUiHvQK3mgAJEGmtE2TFs9kXzxdWtsjibEcGkhZVCVE,1830
 retracesoftware/install/tracer.py,sha256=cHEjiVxIp2iVTJEWndwSbMuiXVyGJQxJYZSGrfpSbCw,5723
 retracesoftware/install/typeutils.py,sha256=_a1PuwdCsYjG1Nkd77V-flqYtwbD4RkJVKn6Z-xABL4,1813
-retracesoftware/proxy/__init__.py,sha256=ZlDZIuUmKFsE9Tvfd2EKGabTepqv8nrbr5pQhCM3IKc,193
+retracesoftware/proxy/__init__.py,sha256=ntIyqKhBRkKEkcW_oOPodikh-mxYl8OXRnSaj-9-Xwc,178
 retracesoftware/proxy/gateway.py,sha256=xESohWXkiNm4ZutU0RgWUwxjxcBWRQ4rQyxIGQXv_F4,1590
+retracesoftware/proxy/globalref.py,sha256=yXtJsOeBHN9xoEgJWA3MJco-jD2SQUef_fDatA4A6rg,803
 retracesoftware/proxy/proxyfactory.py,sha256=qhOqDfMJnLDNkQs26JqDB431MwjjRhGQi8xupJ45asg,12272
-retracesoftware/proxy/proxysystem.py,sha256=ZX6eNT8go-YDbLWD2pq5j_V8DZAHteu-iNfkMO8jLWg,7567
-retracesoftware/proxy/proxytype.py,sha256=H6SJKX0izor1yLOK_QxRlfKLcJC08eMuIYJ1amnoZvQ,12812
-retracesoftware/proxy/record.py,sha256=vtNsoTHP5gsBVJ6dTGHR7QXHGbKm0eONfGcXOb9fhFk,4696
-retracesoftware/proxy/replay.py,sha256=Ckkl7v-n-4KWEJXENOsMjmtNLguYudVgLrguVLLCMEA,7742
+retracesoftware/proxy/proxysystem.py,sha256=ttzHcNH4O2GrlTjy3R386HTwRY7Z5QKWbMt6BOf7Jto,7722
+retracesoftware/proxy/proxytype.py,sha256=hP-1vJmWBa9KgZFB3CnZy0UbC4u8Wr2e76lGI0JM2SA,12992
+retracesoftware/proxy/record.py,sha256=47vhAYIUrR2bWo-rQ9xU_Xyg3kNrA5Lqq4-8Cxg4-zg,5463
+retracesoftware/proxy/replay.py,sha256=RWfmTrbeLFCSvV26ow1iwitf1wWt6XfypMcKIxYXZEg,9669
 retracesoftware/proxy/stubfactory.py,sha256=37UX1r8HCAbASTwPdz8QKCrg72NQmM5PsiCho7N2nzg,5129
-retracesoftware/proxy/thread.py,sha256=-SvnyVbANkmX2lLRpOvFtkpdpAoF6DhnnYdOOs7Q8vo,1379
-retracesoftware_proxy-0.1.13.dist-info/METADATA,sha256=yQJQrwJgTMPNl8u68MMD7QycdnOOrIW04JersxwXHXk,203
-retracesoftware_proxy-0.1.13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-retracesoftware_proxy-0.1.13.dist-info/top_level.txt,sha256=hYHsR6txLidmqvjBMITpIHvmJJbmoCAgr76-IpZPRz8,16
-retracesoftware_proxy-0.1.13.dist-info/RECORD,,
+retracesoftware/proxy/thread.py,sha256=T1ME6DHB8O0xVnX3Rt1lMl7oCJ2Y0aoFT91D76yNICk,3073
+retracesoftware_proxy-0.1.15.dist-info/METADATA,sha256=5EIkVm31Txgu2-FN94NLguxj4YtbZ7pU_VaZLisxhCE,203
+retracesoftware_proxy-0.1.15.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+retracesoftware_proxy-0.1.15.dist-info/top_level.txt,sha256=hYHsR6txLidmqvjBMITpIHvmJJbmoCAgr76-IpZPRz8,16
+retracesoftware_proxy-0.1.15.dist-info/RECORD,,