Add restrictions.

ericsnowcurrently · ericsnowcurrently · commit b05327e527a7 · 2024-04-08T20:23:48.000-06:00
diff --git a/Lib/test/support/interpreters/__init__.py b/Lib/test/support/interpreters/__init__.py
@@ -106,6 +106,10 @@ class Interpreter:
     "id" - the unique process-global ID number for the interpreter
     "owned" - indicates whether or not the interpreter was created
               by interpreters.create()
+
+    If interp.owned is false then any method that modifies the
+    interpreter will fail, i.e. .close(), .prepare_main(), .exec(),
+    and .call()
     """
 
     def __new__(cls, id, /, _owned=None):
@@ -165,23 +169,27 @@ def owned(self):
 
     def is_running(self):
         """Return whether or not the identified interpreter is running."""
-        return _interpreters.is_running(self._id)
+        # require_owned is okay since this doesn't modify the interpreter.
+        return _interpreters.is_running(self._id, require_owned=False)
+
+    # Everything past here is available only to interpreters created by
+    # interpreters.create().
 
     def close(self):
         """Finalize and destroy the interpreter.
 
         Attempting to destroy the current interpreter results
         in an InterpreterError.
         """
-        return _interpreters.destroy(self._id)
+        return _interpreters.destroy(self._id, require_owned=True)
 
     def prepare_main(self, ns=None, /, **kwargs):
         """Bind the given values into the interpreter's __main__.
 
         The values must be shareable.
         """
         ns = dict(ns, **kwargs) if ns is not None else kwargs
-        _interpreters.set___main___attrs(self._id, ns)
+        _interpreters.set___main___attrs(self._id, ns, require_owned=True)
 
     def exec(self, code, /):
         """Run the given source code in the interpreter.
@@ -201,7 +209,7 @@ def exec(self, code, /):
         that time, the previous interpreter is allowed to run
         in other threads.
         """
-        excinfo = _interpreters.exec(self._id, code)
+        excinfo = _interpreters.exec(self._id, code, require_owned=True)
         if excinfo is not None:
             raise ExecutionFailed(excinfo)
 
@@ -221,7 +229,7 @@ def call(self, callable, /):
         # XXX Support args and kwargs.
         # XXX Support arbitrary callables.
         # XXX Support returning the return value (e.g. via pickle).
-        excinfo = _interpreters.call(self._id, callable)
+        excinfo = _interpreters.call(self._id, callable, require_owned=True)
         if excinfo is not None:
             raise ExecutionFailed(excinfo)
 
diff --git a/Lib/test/test_interpreters/test_api.py b/Lib/test/test_interpreters/test_api.py
@@ -597,7 +597,7 @@ def test_created_with_capi(self):
         def check_results(err, text):
             self.assertIsNot(err, None)
             self.assertEqual(err.type.__name__, 'InterpreterError')
-            self.assertIn('current', err.msg)
+            self.assertIn('unrecognized', err.msg)
             self.assertEqual(text, '')
 
         with self.subTest('running __main__ (from self)'):
@@ -612,30 +612,31 @@ def check_results(err, text):
         with self.subTest('running __main__ (from other)'):
             with self.interpreter_obj_from_capi() as (interp, interpid):
                 with self.running_from_capi(interpid, main=True):
-                    with self.assertRaisesRegex(InterpreterError, 'running'):
+                    with self.assertRaisesRegex(InterpreterError, 'unrecognized'):
                         interp.close()
                     # Make sure it wssn't closed.
                     self.assertTrue(
-                        interp.is_running())
+                        self.interp_exists(interpid))
 
-        # The rest must be skipped until we deal with running threads when
-        # interp.close() is called.
-        return
+        # The rest would be skipped until we deal with running threads when
+        # interp.close() is called.  However, the "owned" restrictions
+        # trigger first.
 
         with self.subTest('running, but not __main__ (from other)'):
             with self.interpreter_obj_from_capi() as (interp, interpid):
                 with self.running_from_capi(interpid, main=False):
-                    with self.assertRaisesRegex(InterpreterError, 'not managed'):
+                    with self.assertRaisesRegex(InterpreterError, 'unrecognized'):
                         interp.close()
                     # Make sure it wssn't closed.
-                    self.assertFalse(interp.is_running())
+                    self.assertTrue(
+                        self.interp_exists(interpid))
 
         with self.subTest('not running (from other)'):
-            with self.interpreter_obj_from_capi() as (interp, _):
-                with self.assertRaisesRegex(InterpreterError, 'not managed'):
+            with self.interpreter_obj_from_capi() as (interp, interpid):
+                with self.assertRaisesRegex(InterpreterError, 'unrecognized'):
                     interp.close()
-                # Make sure it wssn't closed.
-                self.assertFalse(interp.is_running())
+                self.assertTrue(
+                    self.interp_exists(interpid))
 
 
 class TestInterpreterPrepareMain(TestBase):
@@ -702,14 +703,13 @@ def test_running(self):
                 interp.prepare_main({'spam': False})
         interp.exec('assert spam is True')
 
-    @requires__testinternalcapi
     def test_created_with_capi(self):
-        with self.interpreter_from_capi() as interpid:
-            interp = interpreters.Interpreter(interpid)
-            interp.prepare_main({'spam': True})
-            rc = _testinternalcapi.exec_interpreter(interpid,
-                                                    'assert spam is True')
-            assert rc == 0, rc
+        with self.interpreter_obj_from_capi() as (interp, interpid):
+            with self.assertRaisesRegex(InterpreterError, 'unrecognized'):
+                interp.prepare_main({'spam': True})
+            err, text = self.run_from_capi(interpid, 'assert spam is True')
+            self.assertIsNot(err, None)
+            self.assertEqual(err.type.__name__, 'NameError')
 
 
 class TestInterpreterExec(TestBase):
@@ -864,7 +864,7 @@ def task():
 
     def test_created_with_capi(self):
         with self.interpreter_obj_from_capi() as (interp, _):
-            with self.assertRaisesRegex(ExecutionFailed, 'it worked'):
+            with self.assertRaisesRegex(InterpreterError, 'unrecognized'):
                 interp.exec('raise Exception("it worked!")')
 
     # test_xxsubinterpreters covers the remaining
@@ -1143,14 +1143,6 @@ class LowLevelTests(TestBase):
     # encountered by the high-level module, thus they
     # mostly shouldn't matter as much.
 
-    def interp_exists(self, interpid):
-        try:
-            _interpreters.is_owned(interpid)
-        except InterpreterNotFoundError:
-            return False
-        else:
-            return True
-
     def test_new_config(self):
         # This test overlaps with
         # test.test_capi.test_misc.InterpreterConfigTests.
@@ -1443,7 +1435,11 @@ def test_destroy(self):
 
         with self.subTest('from C-API'):
             interpid = _testinternalcapi.create_interpreter()
-            _interpreters.destroy(interpid)
+            with self.assertRaisesRegex(InterpreterError, 'unrecognized'):
+                _interpreters.destroy(interpid)
+            self.assertTrue(
+                self.interp_exists(interpid))
+            _interpreters.destroy(interpid, require_owned=False)
             self.assertFalse(
                 self.interp_exists(interpid))
 
@@ -1455,14 +1451,7 @@ def test_get_config(self):
             expected = _interpreters.new_config('legacy')
             expected.gil = 'own'
             interpid, *_ = _interpreters.get_main()
-            config = _interpreters.get_config(interpid)
-            self.assert_ns_equal(config, expected)
-
-        with self.subTest('main'):
-            expected = _interpreters.new_config('legacy')
-            expected.gil = 'own'
-            interpid, *_ = _interpreters.get_main()
-            config = _interpreters.get_config(interpid)
+            config = _interpreters.get_config(interpid, require_owned=False)
             self.assert_ns_equal(config, expected)
 
         with self.subTest('isolated'):
@@ -1480,42 +1469,46 @@ def test_get_config(self):
         with self.subTest('from C-API'):
             orig = _interpreters.new_config('isolated')
             with self.interpreter_from_capi(orig) as interpid:
-                config = _interpreters.get_config(interpid)
+                with self.assertRaisesRegex(InterpreterError, 'unrecognized'):
+                    _interpreters.get_config(interpid)
+                config = _interpreters.get_config(interpid, require_owned=False)
             self.assert_ns_equal(config, orig)
 
     def test_is_running(self):
-        with self.subTest('main'):
-            interpid, *_ = _interpreters.get_main()
-            running = _interpreters.is_running(interpid)
-            self.assertTrue(running)
+        def check(interpid, expected):
+            with self.assertRaisesRegex(InterpreterError, 'unrecognized'):
+                _interpreters.is_running(interpid)
+            running = _interpreters.is_running(interpid, require_owned=False)
+            self.assertIs(running, expected)
 
         with self.subTest('from _interpreters (running)'):
             interpid = _interpreters.create()
             with self.running(interpid):
                 running = _interpreters.is_running(interpid)
-            self.assertTrue(running)
+                self.assertTrue(running)
 
         with self.subTest('from _interpreters (not running)'):
             interpid = _interpreters.create()
             running = _interpreters.is_running(interpid)
             self.assertFalse(running)
 
+        with self.subTest('main'):
+            interpid, *_ = _interpreters.get_main()
+            check(interpid, True)
+
         with self.subTest('from C-API (running __main__)'):
             with self.interpreter_from_capi() as interpid:
                 with self.running_from_capi(interpid, main=True):
-                    running = _interpreters.is_running(interpid)
-            self.assertTrue(running)
+                    check(interpid, True)
 
         with self.subTest('from C-API (running, but not __main__)'):
             with self.interpreter_from_capi() as interpid:
                 with self.running_from_capi(interpid, main=False):
-                    running = _interpreters.is_running(interpid)
-            self.assertFalse(running)
+                    check(interpid, False)
 
         with self.subTest('from C-API (not running)'):
             with self.interpreter_from_capi() as interpid:
-                running = _interpreters.is_running(interpid)
-                self.assertFalse(running)
+                check(interpid, False)
 
     def test_exec(self):
         with self.subTest('run script'):
@@ -1551,7 +1544,13 @@ def test_exec(self):
 
         with self.subTest('from C-API'):
             with self.interpreter_from_capi() as interpid:
-                exc = _interpreters.exec(interpid, 'raise Exception("it worked!")')
+                with self.assertRaisesRegex(InterpreterError, 'unrecognized'):
+                    _interpreters.exec(interpid, 'raise Exception("it worked!")')
+                exc = _interpreters.exec(
+                    interpid,
+                    'raise Exception("it worked!")',
+                    require_owned=False,
+                )
             self.assertIsNot(exc, None)
             self.assertEqual(exc.msg, 'it worked!')
 
@@ -1576,6 +1575,7 @@ def test_call(self):
                 errdisplay=exc.errdisplay,
             ))
 
+    @requires__testinternalcapi
     def test_set___main___attrs(self):
         with self.subTest('from _interpreters'):
             interpid = _interpreters.create()
@@ -1597,9 +1597,18 @@ def test_set___main___attrs(self):
 
         with self.subTest('from C-API'):
             with self.interpreter_from_capi() as interpid:
-                _interpreters.set___main___attrs(interpid, {'spam': True})
-                exc = _interpreters.exec(interpid, 'assert spam is True')
-            self.assertIsNone(exc)
+                with self.assertRaisesRegex(InterpreterError, 'unrecognized'):
+                    _interpreters.set___main___attrs(interpid, {'spam': True})
+                _interpreters.set___main___attrs(
+                    interpid,
+                    {'spam': True},
+                    require_owned=False,
+                )
+                rc = _testinternalcapi.exec_interpreter(
+                    interpid,
+                    'assert spam is True',
+                )
+            self.assertEqual(rc, 0)
 
 
 if __name__ == '__main__':
diff --git a/Lib/test/test_interpreters/utils.py b/Lib/test/test_interpreters/utils.py
@@ -495,6 +495,14 @@ def run_and_capture(self, interp, script):
         else:
             return text
 
+    def interp_exists(self, interpid):
+        try:
+            _interpreters.is_owned(interpid)
+        except _interpreters.InterpreterNotFoundError:
+            return False
+        else:
+            return True
+
     @requires__testinternalcapi
     @contextlib.contextmanager
     def interpreter_from_capi(self, config='legacy'):
diff --git a/Modules/_xxsubinterpretersmodule.c b/Modules/_xxsubinterpretersmodule.c
