Closes #14421: use with statement to properly close socket in bandwidth test.

Tools/ccbench/ccbench.py

@@ -435,70 +435,70 @@ def run_bandwidth_client(**kwargs):
 def run_bandwidth_test(func, args, nthreads):
     # Create a listening socket to receive the packets. We use UDP which should
     # be painlessly cross-platform.
-    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as sock:
-    sock.bind(("127.0.0.1", 0))
+        sock.bind(("127.0.0.1", 0))
-    addr = sock.getsockname()
+        addr = sock.getsockname()
 
-    duration = BANDWIDTH_DURATION
+        duration = BANDWIDTH_DURATION
-    packet_size = BANDWIDTH_PACKET_SIZE
+        packet_size = BANDWIDTH_PACKET_SIZE
-
-    results = []
-    threads = []
-    end_event = []
-    start_cond = threading.Condition()
-    started = False
-    if nthreads > 0:
-        # Warm up
-        func(*args)
 
         results = []
-        loop = TimedLoop(func, args)
+        threads = []
-        ready = []
+        end_event = []
-        ready_cond = threading.Condition()
+        start_cond = threading.Condition()
+        started = False
+        if nthreads > 0:
+            # Warm up
+            func(*args)
 
-        def run():
+            results = []
+            loop = TimedLoop(func, args)
+            ready = []
+            ready_cond = threading.Condition()
+
+            def run():
+                with ready_cond:
+                    ready.append(None)
+                    ready_cond.notify()
+                with start_cond:
+                    while not started:
+                        start_cond.wait()
+                loop(start_time, duration * 1.5, end_event, do_yield=False)
+
+            for i in range(nthreads):
+                threads.append(threading.Thread(target=run))
+            for t in threads:
+                t.setDaemon(True)
+                t.start()
+            # Wait for threads to be ready
             with ready_cond:
-                ready.append(None)
+                while len(ready) < nthreads:
-                ready_cond.notify()
+                    ready_cond.wait()
-            with start_cond:
-                while not started:
-                    start_cond.wait()
-            loop(start_time, duration * 1.5, end_event, do_yield=False)
 
-        for i in range(nthreads):
+        # Run the client and wait for the first packet to arrive before
-            threads.append(threading.Thread(target=run))
+        # unblocking the background threads.
-        for t in threads:
+        process = run_bandwidth_client(addr=addr,
-            t.setDaemon(True)
+                                       packet_size=packet_size,
-            t.start()
+                                       duration=duration)
-        # Wait for threads to be ready
+        _time = time.time
-        with ready_cond:
+        # This will also wait for the parent to be ready
-            while len(ready) < nthreads:
-                ready_cond.wait()
-
-    # Run the client and wait for the first packet to arrive before
-    # unblocking the background threads.
-    process = run_bandwidth_client(addr=addr,
-                                   packet_size=packet_size,
-                                   duration=duration)
-    _time = time.time
-    # This will also wait for the parent to be ready
-    s = _recv(sock, packet_size)
-    remote_addr = eval(s.partition('#')[0])
-
-    with start_cond:
-        start_time = _time()
-        started = True
-        start_cond.notify(nthreads)
-
-    n = 0
-    first_time = None
-    while not end_event and BW_END not in s:
-        _sendto(sock, s, remote_addr)
         s = _recv(sock, packet_size)
-        if first_time is None:
+        remote_addr = eval(s.partition('#')[0])
-            first_time = _time()
+
-        n += 1
+        with start_cond:
-    end_time = _time()
+            start_time = _time()
+            started = True
+            start_cond.notify(nthreads)
+
+        n = 0
+        first_time = None
+        while not end_event and BW_END not in s:
+            _sendto(sock, s, remote_addr)
+            s = _recv(sock, packet_size)
+            if first_time is None:
+                first_time = _time()
+            n += 1
+        end_time = _time()
 
     end_event.append(None)
     for t in threads: