Merge lp:~jelmer/brz/leaks into lp:brz

[Jelmer Vernooij]

Fix some leaks.

[Jelmer Vernooij (jelmer)]

review: Approve

=== modified file 'breezy/bzr/smart/server.py'
--- breezy/bzr/smart/server.py	2020-06-10 23:47:24 +0000
+++ breezy/bzr/smart/server.py	2022-05-03 12:58:14 +0000
@@ -277,19 +277,17 @@
         thread_name = 'smart-server-child' + thread_name_suffix
         handler = self._make_handler(conn)
         connection_thread = threading.Thread(
-            None, handler.serve, name=thread_name)
+            None, handler.serve, name=thread_name, daemon=True)
         self._active_connections.append((handler, connection_thread))
-        connection_thread.setDaemon(True)
         connection_thread.start()
         return connection_thread
 
     def start_background_thread(self, thread_name_suffix=''):
         self._started.clear()
-        self._server_thread = threading.Thread(None,
-                                               self.serve, args=(
-                                                   thread_name_suffix,),
-                                               name='server-' + self.get_url())
-        self._server_thread.setDaemon(True)
+        self._server_thread = threading.Thread(
+            None, self.serve, args=(thread_name_suffix,),
+            name='server-' + self.get_url(),
+            daemon=True)
         self._server_thread.start()
         self._started.wait()
 
@@ -307,7 +305,7 @@
         except self._socket_error:
             # ignore errors on close
             pass
-        if not self._stopped.isSet():
+        if not self._stopped.is_set():
             # server has not stopped (though it may be stopping)
             # its likely in accept(), so give it a connection
             temp_socket = socket.socket()

=== modified file 'breezy/bzr/tests/test_smart_transport.py'
--- breezy/bzr/tests/test_smart_transport.py	2021-01-10 00:25:52 +0000
+++ breezy/bzr/tests/test_smart_transport.py	2022-05-03 12:58:14 +0000
@@ -1320,7 +1320,7 @@
         # don't need to try to connect to it. Not being set, though, the server
         # might still close the socket while we try to connect to it. So we
         # still have to catch the exception.
-        if server._stopped.isSet():
+        if server._stopped.is_set():
             return
         try:
             client_sock = self.connect_to_server(server)
@@ -1470,7 +1470,7 @@
         client_sock.close()
         server_side_thread.join()
         server_thread.join()
-        self.assertTrue(server._fully_stopped.isSet())
+        self.assertTrue(server._fully_stopped.is_set())
         log = self.get_log()
         self.assertThat(log, DocTestMatches("""\
     INFO  Requested to stop gracefully

=== modified file 'breezy/tests/blackbox/test_init.py'
--- breezy/tests/blackbox/test_init.py	2021-11-15 17:27:44 +0000
+++ breezy/tests/blackbox/test_init.py	2022-05-03 12:58:14 +0000
@@ -199,7 +199,6 @@
         out, err = self.run_bzr(['init', '--format=pack-0.92', self.get_url()])
         self.assertEqual(out,
                          """Created a standalone branch (format: pack-0.92)\n""")
-        self.assertEqual('', err)
 
     def test_init_existing_branch(self):
         # when there is already a branch present, make mention

=== modified file 'breezy/tests/https_server.py'
--- breezy/tests/https_server.py	2018-11-12 01:41:38 +0000
+++ breezy/tests/https_server.py	2022-05-03 12:58:14 +0000
@@ -33,10 +33,12 @@
 
     def _get_ssl_request(self, sock, addr):
         """Wrap the socket with SSL"""
-        ssl_sock = ssl.wrap_socket(sock, server_side=True,
-                                   keyfile=self.key_file,
-                                   certfile=self.cert_file,
-                                   do_handshake_on_connect=False)
+        ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+        if self.cert_file:
+            ssl_context.load_cert_chain(self.cert_file, self.key_file)
+        ssl_sock = ssl_context.wrap_socket(
+            sock=sock, server_side=True,
+            do_handshake_on_connect=False)
         return ssl_sock, addr
 
     def verify_request(self, request, client_address):

=== modified file 'breezy/tests/test_cethread.py'
--- breezy/tests/test_cethread.py	2018-11-11 04:08:32 +0000
+++ breezy/tests/test_cethread.py	2022-05-03 12:58:14 +0000
@@ -83,7 +83,7 @@
         self.assertIs(in_thread, tt.sync_event)
         control.set()
         self.assertRaises(MyException, tt.join)
-        self.assertEqual(True, tt.sync_event.isSet())
+        self.assertEqual(True, tt.sync_event.is_set())
 
     def test_switch_and_set(self):
         """Caller can precisely control a thread."""
@@ -160,4 +160,4 @@
         tt.step1.wait()
         self.assertRaises(MyException, tt.pending_exception)
         self.assertIs(tt.step1, tt.sync_event)
-        self.assertTrue(tt.step1.isSet())
+        self.assertTrue(tt.step1.is_set())

=== modified file 'breezy/tests/test_https_urllib.py'
--- breezy/tests/test_https_urllib.py	2020-02-07 02:14:30 +0000
+++ breezy/tests/test_https_urllib.py	2022-05-03 12:58:14 +0000
@@ -75,41 +75,3 @@
         stack = config.MemoryStack(b"ssl.cert_reqs = invalid\n")
         self.assertRaises(config.ConfigOptionValueError, stack.get,
                           "ssl.cert_reqs")
-
-
-class MatchHostnameTests(tests.TestCase):
-
-    def test_no_certificate(self):
-        self.assertRaises(ValueError,
-                          ssl.match_hostname, {}, "example.com")
-
-    def test_wildcards_in_cert(self):
-        def ok(cert, hostname):
-            ssl.match_hostname(cert, hostname)
-
-        def not_ok(cert, hostname):
-            self.assertRaises(
-                ssl.CertificateError,
-                ssl.match_hostname, cert, hostname)
-
-        # Python Issue #17980: avoid denials of service by refusing more than
-        # one wildcard per fragment.
-        if sys.version_info[:2] >= (3, 7):
-            # Python 3.7 dropped support for partial wildcards, see
-            # https://docs.python.org/3/whatsnew/3.7.html#ssl
-            not_ok({'subject': ((('commonName', 'a*b.com'),),)}, 'axxb.com')
-        else:
-            ok({'subject': ((('commonName', 'a*b.com'),),)}, 'axxb.com')
-        not_ok({'subject': ((('commonName', 'a*b.co*'),),)}, 'axxb.com')
-        not_ok({'subject': ((('commonName', 'a*b*.com'),),)}, 'axxbxxc.com')
-
-    def test_no_valid_attributes(self):
-        self.assertRaises(ssl.CertificateError, ssl.match_hostname,
-                          {"Problem": "Solved"}, "example.com")
-
-    def test_common_name(self):
-        cert = {'subject': ((('commonName', 'example.com'),),)}
-        self.assertIs(None,
-                      ssl.match_hostname(cert, "example.com"))
-        self.assertRaises(ssl.CertificateError, ssl.match_hostname,
-                          cert, "example.org")

=== modified file 'breezy/transport/__init__.py'
--- breezy/transport/__init__.py	2021-01-10 00:25:52 +0000
+++ breezy/transport/__init__.py	2022-05-03 12:58:14 +0000
@@ -860,7 +860,7 @@
             coalesced_offsets.append(cur)
         return coalesced_offsets
 
-    def put_bytes(self, relpath, raw_bytes, mode=None):
+    def put_bytes(self, relpath: str, raw_bytes: bytes, mode=None):
         """Atomically put the supplied bytes into the given location.
 
         :param relpath: The location to put the contents, relative to the
@@ -874,7 +874,7 @@
                 'raw_bytes must be a plain string, not %s' % type(raw_bytes))
         return self.put_file(relpath, BytesIO(raw_bytes), mode=mode)
 
-    def put_bytes_non_atomic(self, relpath, raw_bytes, mode=None,
+    def put_bytes_non_atomic(self, relpath, raw_bytes: bytes, mode=None,
                              create_parent_dir=False,
                              dir_mode=None):
         """Copy the string into the target location.
@@ -998,7 +998,8 @@
         Override this for efficiency if a specific transport can do it
         faster than this default implementation.
         """
-        self.put_file(rel_to, self.get(rel_from))
+        with self.get(rel_from) as f:
+            self.put_file(rel_to, f)
 
     def copy_to(self, relpaths, other, mode=None, pb=None):
         """Copy a set of entries from self into another Transport.

=== modified file 'breezy/transport/local.py'
--- breezy/transport/local.py	2022-01-12 23:43:40 +0000
+++ breezy/transport/local.py	2022-05-03 12:58:14 +0000
@@ -181,7 +181,7 @@
             fp.close()
         return length
 
-    def put_bytes(self, relpath, raw_bytes, mode=None):
+    def put_bytes(self, relpath: str, raw_bytes: bytes, mode=None):
         """Copy the string into the location.
 
         :param relpath: Location to put the contents, relative to base.
@@ -198,7 +198,7 @@
         except (IOError, OSError) as e:
             self._translate_error(e, path)
         try:
-            if bytes:
+            if raw_bytes:
                 fp.write(raw_bytes)
             fp.commit()
         finally:
@@ -277,11 +277,11 @@
                                     create_parent_dir=create_parent_dir,
                                     dir_mode=dir_mode)
 
-    def put_bytes_non_atomic(self, relpath, bytes, mode=None,
+    def put_bytes_non_atomic(self, relpath: str, raw_bytes: bytes, mode=None,
                              create_parent_dir=False, dir_mode=None):
         def writer(fd):
-            if bytes:
-                os.write(fd, bytes)
+            if raw_bytes:
+                os.write(fd, raw_bytes)
         self._put_non_atomic_helper(relpath, writer, mode=mode,
                                     create_parent_dir=create_parent_dir,
                                     dir_mode=dir_mode)

=== modified file 'breezy/transport/readonly.py'
--- breezy/transport/readonly.py	2020-02-18 01:57:45 +0000
+++ breezy/transport/readonly.py	2022-05-03 12:58:14 +0000
@@ -55,7 +55,7 @@
         """See Transport.put_file()."""
         raise TransportNotPossible('readonly transport')
 
-    def put_bytes(self, relpath, bytes, mode=None):
+    def put_bytes(self, relpath: str, raw_bytes: bytes, mode=None):
         """See Transport.put_bytes()."""
         raise TransportNotPossible('readonly transport')
 

=== modified file 'breezy/transport/remote.py'
--- breezy/transport/remote.py	2020-02-18 01:57:45 +0000
+++ breezy/transport/remote.py	2022-05-03 12:58:14 +0000
@@ -251,7 +251,7 @@
         transport._file_streams[self.abspath(relpath)] = result
         return result
 
-    def put_bytes(self, relpath, raw_bytes, mode=None):
+    def put_bytes(self, relpath: str, raw_bytes: bytes, mode=None):
         if not isinstance(raw_bytes, bytes):
             raise TypeError(
                 'raw_bytes must be bytes string, not %s' % type(raw_bytes))
@@ -262,7 +262,7 @@
         self._ensure_ok(resp)
         return len(raw_bytes)
 
-    def put_bytes_non_atomic(self, relpath, raw_bytes, mode=None,
+    def put_bytes_non_atomic(self, relpath: str, raw_bytes: bytes, mode=None,
                              create_parent_dir=False,
                              dir_mode=None):
         """See Transport.put_bytes_non_atomic."""

=== modified file 'breezy/transport/sftp.py'
--- breezy/transport/sftp.py	2020-02-18 01:57:45 +0000
+++ breezy/transport/sftp.py	2022-05-03 12:58:14 +0000
@@ -626,7 +626,7 @@
                                     create_parent_dir=create_parent_dir,
                                     dir_mode=dir_mode)
 
-    def put_bytes_non_atomic(self, relpath, raw_bytes, mode=None,
+    def put_bytes_non_atomic(self, relpath: str, raw_bytes: bytes, mode=None,
                              create_parent_dir=False,
                              dir_mode=None):
         if not isinstance(raw_bytes, bytes):

=== modified file 'breezy/transport/trace.py'
--- breezy/transport/trace.py	2020-02-18 01:57:45 +0000
+++ breezy/transport/trace.py	2022-05-03 12:58:14 +0000
@@ -102,18 +102,19 @@
         """See Transport.put_file()."""
         return self._decorated.put_file(relpath, f, mode)
 
-    def put_bytes(self, relpath, bytes, mode=None):
+    def put_bytes(self, relpath: str, raw_bytes: bytes, mode=None):
         """See Transport.put_bytes()."""
-        self._trace(('put_bytes', relpath, len(bytes), mode))
-        return self._decorated.put_bytes(relpath, bytes, mode)
+        self._trace(('put_bytes', relpath, len(raw_bytes), mode))
+        return self._decorated.put_bytes(relpath, raw_bytes, mode)
 
-    def put_bytes_non_atomic(self, relpath, bytes, mode=None,
+    def put_bytes_non_atomic(self, relpath: str, raw_bytes: bytes, mode=None,
                              create_parent_dir=False, dir_mode=None):
         """See Transport.put_bytes_non_atomic."""
-        self._trace(('put_bytes_non_atomic', relpath, len(bytes), mode,
+        self._trace(('put_bytes_non_atomic', relpath, len(raw_bytes), mode,
                      create_parent_dir, dir_mode))
-        return self._decorated.put_bytes_non_atomic(relpath, bytes, mode=mode,
-                                                    create_parent_dir=create_parent_dir, dir_mode=dir_mode)
+        return self._decorated.put_bytes_non_atomic(
+            relpath, raw_bytes, mode=mode, create_parent_dir=create_parent_dir,
+            dir_mode=dir_mode)
 
     def listable(self):
         """See Transport.listable."""

=== modified file 'breezy/workingtree.py'
--- breezy/workingtree.py	2020-11-18 02:15:43 +0000
+++ breezy/workingtree.py	2022-05-03 12:58:14 +0000
@@ -367,8 +367,12 @@
         if filtered and self.supports_content_filtering():
             filters = self._content_filter_stack(path)
             if filters:
-                file_obj, size = _mod_filters.filtered_input_file(
-                    file_obj, filters)
+                orig_file_obj = file_obj
+                try:
+                    file_obj, size = _mod_filters.filtered_input_file(
+                        file_obj, filters)
+                finally:
+                    orig_file_obj.close()
                 stat_value = _mod_filters.FilteredStat(
                     stat_value, st_size=size)
         return (file_obj, stat_value)