rename some instances of "thr" to "process"

Author: catern

python/rsyscall/scripts/symsh.py

@@ -87,11 +87,11 @@ async def _mount(self, process: Process, path: Path) -> None:
         # We'll keep devfuse open *only* in the dedicated server process's private fd table, so that
         # other processes accessing the filesystem don't deadlock when we abort the FUSE server loop -
         # instead their syscalls will be aborted with ENOTCONN.
-        self.thr = await process.fork()
-        self.devfuse = self.thr.task.inherit_fd(devfuse)
+        self.process = await process.fork()
+        self.devfuse = self.process.task.inherit_fd(devfuse)
         await devfuse.close()
         # Respond to FUSE init message to sanity-check things are set up right.
-        self.buf = await self.thr.malloc(FuseInList, FUSE_MIN_READ_BUFFER)
+        self.buf = await self.process.malloc(FuseInList, FUSE_MIN_READ_BUFFER)
         [init] = await self.read()
         if not isinstance(init, FuseInitOp):
             raise Exception("oops, got non-init as first message", init)
@@ -115,7 +115,7 @@ async def read(self) -> FuseInList:
 
     async def write(self, out: FuseOut) -> None:
         logger.debug("writing out FUSE response: %s", out)
-        ptr = await self.thr.ptr(out)
+        ptr = await self.process.ptr(out)
         written, unwritten = await self.devfuse.write(ptr)
         if unwritten.size() != 0:
             raise Exception("/dev/fuse is not supposed to ever do partial writes, but I got one somehow on", ptr)
@@ -125,11 +125,11 @@ async def __aenter__(self) -> FuseFS:
 
     async def cleanup(self) -> None:
         # umount to kill the fuse loop; it's a bit lazy to save the parent process to do this, but we
-        # can't do it in self.thr because that process spends all its time blocked in read.
+        # can't do it in self.process because that process spends all its time blocked in read.
         await self.parent_process.task.umount(await self.parent_process.ptr(self.path))
         # and exit the process - but it might already be dead, so we might fail to exit it, just ignore that.
         try:
-            await self.thr.exit(0)
+            await self.process.exit(0)
         except SyscallError:
             pass
 

python/rsyscall/stdlib/mktemp.py

@@ -11,27 +11,27 @@ def random_string(k: int=8) -> str:
     "Return a random string - useful for making files that don't conflict with others."
     return ''.join(random.choices(string.ascii_letters + string.digits, k=k))
 
-async def update_symlink(thr: Process, path: WrittenPointer[Path],
+async def update_symlink(process: Process, path: WrittenPointer[Path],
                          target: t.Union[str, os.PathLike]) -> WrittenPointer[Path]:
     "Atomically update this path to contain a symlink pointing at this target."
     tmpname = path.value.name + ".updating." + random_string(k=8)
-    tmppath = await thr.ram.ptr(path.value.parent/tmpname)
-    await thr.task.symlink(await thr.ram.ptr(target), tmppath)
-    await thr.task.rename(tmppath, path)
+    tmppath = await process.ram.ptr(path.value.parent/tmpname)
+    await process.task.symlink(await process.ram.ptr(target), tmppath)
+    await process.task.rename(tmppath, path)
     return path
 
-async def mkdtemp(thr: Process, prefix: str="mkdtemp") -> 'TemporaryDirectory':
-    "Make a temporary directory in thr.environ.tmpdir."
-    parent = thr.environ.tmpdir
+async def mkdtemp(process: Process, prefix: str="mkdtemp") -> 'TemporaryDirectory':
+    "Make a temporary directory in process.environ.tmpdir."
+    parent = process.environ.tmpdir
     name = prefix+"."+random_string(k=8)
-    await thr.task.mkdir(await thr.ram.ptr(parent/name), 0o700)
-    return TemporaryDirectory(thr, parent, name)
+    await process.task.mkdir(await process.ram.ptr(parent/name), 0o700)
+    return TemporaryDirectory(process, parent, name)
 
 class TemporaryDirectory(Path):
     "A temporary directory we've created and are responsible for cleaning up."
-    def __init__(self, thr: Process, parent: Path, name: str) -> None:
+    def __init__(self, process: Process, parent: Path, name: str) -> None:
         "Don't directly instantiate, use rsyscall.mktemp.mkdtemp to create this class."
-        self.thr = thr
+        self.process = process
         super().__init__(parent, name)
 
     async def cleanup(self) -> None:
@@ -43,9 +43,9 @@ async def cleanup(self) -> None:
 
         """
         # TODO would be nice if not sharing the fs information gave us a cap to chdir
-        cleanup = await self.thr.fork()
+        cleanup = await self.process.fork()
         await cleanup.task.chdir(await cleanup.ram.ptr(self.parent))
-        child = await cleanup.exec(self.thr.environ.sh.args(
+        child = await cleanup.exec(self.process.environ.sh.args(
             '-c', f"chmod -R +w -- {self.name} && rm -rf -- {self.name}"))
         await child.check()
 

python/rsyscall/tests/test_benchmark.py

@@ -15,14 +15,14 @@ class TestBenchmark(TrioTestCase):
     async def test_bench(self):
         "Run a simple clone and exec case inside cProfile (without asserting the results)"
 
-        await self.thr.environ.as_arglist(self.thr.ram)
-        cmd = (await self.thr.environ.which("echo")).args("-n")
+        await self.process.environ.as_arglist(self.process.ram)
+        cmd = (await self.process.environ.which("echo")).args("-n")
         pr = cProfile.Profile()
         warm_up_runs = 1
         real_runs = 1
-        await rsys_run(self.thr, cmd, warm_up_runs)
+        await rsys_run(self.process, cmd, warm_up_runs)
         pr.enable()
-        await rsys_run(self.thr, cmd, real_runs)
+        await rsys_run(self.process, cmd, real_runs)
         pr.disable()
         # pr.print_stats(sort='cumtime')
         # ps = pstats.Stats(pr).strip_dirs().sort_stats('cumulative')

python/rsyscall/tests/test_cat.py

@@ -6,16 +6,16 @@
 
 class TestCat(TrioTestCase):
     async def asyncSetUp(self) -> None:
-        self.cat = await self.thr.environ.which("cat")
-        self.pipe_in = await (await self.thr.task.pipe(await self.thr.ram.malloc(Pipe))).read()
-        self.pipe_out = await (await self.thr.task.pipe(await self.thr.ram.malloc(Pipe))).read()
-        process = await self.thr.fork()
+        self.cat = await self.process.environ.which("cat")
+        self.pipe_in = await (await self.process.task.pipe(await self.process.ram.malloc(Pipe))).read()
+        self.pipe_out = await (await self.process.task.pipe(await self.process.ram.malloc(Pipe))).read()
+        process = await self.process.fork()
         await process.task.inherit_fd(self.pipe_in.read).dup2(process.stdin)
         await process.task.inherit_fd(self.pipe_out.write).dup2(process.stdout)
         self.child = await process.exec(self.cat)
 
     async def test_cat_pipe(self) -> None:
-        in_data = await self.thr.ram.ptr(b"hello")
+        in_data = await self.process.ram.ptr(b"hello")
         written, _ = await self.pipe_in.write.write(in_data)
         valid, _ = await self.pipe_out.read.read(written)
         self.assertEqual(in_data.value, await valid.read())
@@ -24,9 +24,9 @@ async def test_cat_pipe(self) -> None:
         await self.child.check()
 
     async def test_cat_async(self) -> None:
-        stdin = await self.thr.make_afd(self.pipe_in.write, set_nonblock=True)
-        stdout = await self.thr.make_afd(self.pipe_out.read, set_nonblock=True)
-        in_data = await self.thr.ram.ptr(b"hello")
+        stdin = await self.process.make_afd(self.pipe_in.write, set_nonblock=True)
+        stdout = await self.process.make_afd(self.pipe_out.read, set_nonblock=True)
+        in_data = await self.process.ram.ptr(b"hello")
         written, _ = await stdin.write(in_data)
         valid, _ = await stdout.read(written)
         self.assertEqual(in_data.value, await valid.read())

python/rsyscall/tests/test_chroot.py

@@ -8,14 +8,14 @@
 
 class TestChroot(TrioTestCase):
     async def asyncSetUp(self) -> None:
-        self.tmpdir = await mkdtemp(self.thr)
-        self.thr = await self.thr.clone(CLONE.NEWUSER|CLONE.NEWNS)
+        self.tmpdir = await mkdtemp(self.process)
+        self.process = await self.process.clone(CLONE.NEWUSER|CLONE.NEWNS)
 
     async def asyncTearDown(self) -> None:
         await self.tmpdir.cleanup()
 
     async def test_basic(self) -> None:
-        await self.thr.mkdir(self.tmpdir/"proc")
-        await self.thr.mount("/proc", self.tmpdir/"proc", "", MS.BIND, "")
-        await self.thr.task.chroot(await self.thr.ptr(self.tmpdir))
-        await self.thr.task.open(await self.thr.ptr("/proc/self"), O.RDONLY)
+        await self.process.mkdir(self.tmpdir/"proc")
+        await self.process.mount("/proc", self.tmpdir/"proc", "", MS.BIND, "")
+        await self.process.task.chroot(await self.process.ptr(self.tmpdir))
+        await self.process.task.open(await self.process.ptr("/proc/self"), O.RDONLY)

python/rsyscall/tests/test_clone.py

@@ -11,7 +11,7 @@
 
 class TestClone(TrioTestCase):
     async def asyncSetUp(self) -> None:
-        self.child = await self.thr.clone(CLONE.FILES)
+        self.child = await self.process.clone(CLONE.FILES)
 
     async def test_exit(self) -> None:
         await self.child.exit(0)
@@ -35,7 +35,7 @@ async def test_two_children_exec(self) -> None:
         block forever.
 
         """
-        thr2 = await self.thr.fork()
+        thr2 = await self.process.fork()
         cmd = self.child.environ.sh.args('-c', 'true')
         child1 = await self.child.exec(cmd)
         child2 = await thr2.exec(cmd)
@@ -90,7 +90,7 @@ async def test_signal_queue(self) -> None:
 
 class TestCloneUnshareFiles(TrioTestCase):
     async def asyncSetUp(self) -> None:
-        self.child = await self.thr.fork()
+        self.child = await self.process.fork()
 
     async def asyncTearDown(self) -> None:
         await self.child.exit(0)

python/rsyscall/tests/test_epoller.py

@@ -32,39 +32,39 @@ def get_activity_fd(self) -> t.Optional[FileDescriptor]:
 
 class TestEpoller(TrioTestCase):
     async def test_local(self) -> None:
-        await do_async_things(self, self.thr.epoller, self.thr)
+        await do_async_things(self, self.process.epoller, self.process)
 
     async def test_multi(self) -> None:
-        await do_async_things(self, self.thr.epoller, self.thr, 0)
+        await do_async_things(self, self.process.epoller, self.process, 0)
         async with trio.open_nursery() as nursery:
             for i in range(1, 6):
-                nursery.start_soon(do_async_things, self, self.thr.epoller, self.thr, i)
+                nursery.start_soon(do_async_things, self, self.process.epoller, self.process, i)
 
     async def test_process_multi(self) -> None:
-        process = await self.thr.fork()
+        process = await self.process.fork()
         await do_async_things(self, process.epoller, process, 0)
         async with trio.open_nursery() as nursery:
             for i in range(1, 6):
                 nursery.start_soon(do_async_things, self, process.epoller, process, i)
 
     async def test_process_root_epoller(self) -> None:
-        process = await self.thr.fork()
+        process = await self.process.fork()
         epoller = await Epoller.make_root(process.ram, process.task)
         await do_async_things(self, epoller, process)
 
     async def test_afd_with_handle(self):
-        pipe = await self.thr.pipe()
-        afd = await self.thr.make_afd(pipe.write, set_nonblock=True)
+        pipe = await self.process.pipe()
+        afd = await self.process.make_afd(pipe.write, set_nonblock=True)
         new_afd = afd.with_handle(pipe.write)
         await new_afd.write_all_bytes(b'foo')
 
     async def test_delayed_eagain(self):
-        pipe = await self.thr.pipe()
-        process = await self.thr.fork()
+        pipe = await self.process.pipe()
+        process = await self.process.fork()
         async_pipe_rfd = await process.make_afd(process.inherit_fd(pipe.read), set_nonblock=True)
         # write in parent, read in child
         input_data = b'hello'
-        buf_to_write: Pointer[bytes] = await self.thr.ptr(input_data)
+        buf_to_write: Pointer[bytes] = await self.process.ptr(input_data)
         buf_to_write, _ = await pipe.write.write(buf_to_write)
         self.assertEqual(await async_pipe_rfd.read_some_bytes(), input_data)
         buf = await process.malloc(bytes, 4096)
@@ -89,9 +89,9 @@ async def race_eagain():
 
     async def test_wrong_op_on_pipe(self):
         "Reading or writing to the wrong side of a pipe fails immediately with an error"
-        pipe = await self.thr.pipe()
-        async_pipe_wfd = await self.thr.make_afd(pipe.write, set_nonblock=True)
-        async_pipe_rfd = await self.thr.make_afd(pipe.read, set_nonblock=True)
+        pipe = await self.process.pipe()
+        async_pipe_wfd = await self.process.make_afd(pipe.write, set_nonblock=True)
+        async_pipe_rfd = await self.process.make_afd(pipe.read, set_nonblock=True)
         # we actually are defined to get EBADF in this case, which is
         # a bit of a worrying error, but whatever
         with self.assertRaises(OSError) as cm:

python/rsyscall/tests/test_eventfd.py

@@ -4,13 +4,13 @@
 
 class TestEventfd(TrioTestCase):
     async def asyncSetUp(self) -> None:
-        self.fd = await self.thr.task.eventfd(0)
+        self.fd = await self.process.task.eventfd(0)
 
     async def asyncTearDown(self) -> None:
         await self.fd.close()
 
     async def test(self) -> None:
         inval = Int64(10)
-        written, _ = await self.fd.write(await self.thr.ram.ptr(inval))
+        written, _ = await self.fd.write(await self.process.ram.ptr(inval))
         read, _ = await self.fd.read(written)
         self.assertEqual(inval, await read.read())

python/rsyscall/tests/test_fd.py

@@ -7,14 +7,14 @@ class TestFS(TrioTestCase):
     async def test_fd_gc(self) -> None:
         "Verify that file descriptors actually get GC'd."
         gc.collect()
-        await self.thr.task.run_fd_table_gc()
-        devnull = await self.thr.ptr("/dev/null")
-        first = int(await self.thr.task.open(devnull, O.RDONLY))
+        await self.process.task.run_fd_table_gc()
+        devnull = await self.process.ptr("/dev/null")
+        first = int(await self.process.task.open(devnull, O.RDONLY))
         for _ in range(5):
-            child = await self.thr.clone(CLONE.FILES)
+            child = await self.process.clone(CLONE.FILES)
             for _ in range(50):
                 await child.task.open(devnull, O.RDONLY)
         gc.collect()
-        await self.thr.task.run_fd_table_gc()
-        last = int(await self.thr.task.open(devnull, O.RDONLY))
+        await self.process.task.run_fd_table_gc()
+        last = int(await self.process.task.open(devnull, O.RDONLY))
         self.assertEqual(first, last)