From 37a433c5d073e939bb0f30b5183477ab12881e7d Mon Sep 17 00:00:00 2001 From: Nick Cao Date: Mon, 27 Jan 2025 09:33:28 -0500 Subject: [PATCH 01/10] Init per driver logger instance in Driver base class --- packages/jumpstarter/jumpstarter/driver/base.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/packages/jumpstarter/jumpstarter/driver/base.py b/packages/jumpstarter/jumpstarter/driver/base.py index e002ba760..6934bf89d 100644 --- a/packages/jumpstarter/jumpstarter/driver/base.py +++ b/packages/jumpstarter/jumpstarter/driver/base.py @@ -4,6 +4,7 @@ from __future__ import annotations +import logging from abc import ABCMeta, abstractmethod from contextlib import asynccontextmanager from dataclasses import field @@ -55,8 +56,13 @@ class Driver( resources: dict[UUID, Any] = field(default_factory=dict, init=False) """Dict of client side resources""" + log_level: str = "INFO" + logger: logging.Logger = field(init=False) + def __post_init__(self): super().__post_init__() + self.logger = logging.getLogger(self.__class__.__name__) + self.logger.setLevel(self.log_level) def close(self): for child in self.children.values(): From 53f12f880c9d060f36f8a771f45133cd8c96c707 Mon Sep 17 00:00:00 2001 From: Nick Cao Date: Mon, 27 Jan 2025 09:34:08 -0500 Subject: [PATCH 02/10] Use self.logger in jumpstarter-driver-network --- .../jumpstarter_driver_network/driver.py | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-) diff --git a/packages/jumpstarter-driver-network/jumpstarter_driver_network/driver.py b/packages/jumpstarter-driver-network/jumpstarter_driver_network/driver.py index 8b7e64ce5..2296df78c 100644 --- a/packages/jumpstarter-driver-network/jumpstarter_driver_network/driver.py +++ b/packages/jumpstarter-driver-network/jumpstarter_driver_network/driver.py @@ -1,4 +1,3 @@ -import logging from abc import ABCMeta, abstractmethod from contextlib import asynccontextmanager from dataclasses import dataclass @@ -13,8 +12,6 @@ from jumpstarter.driver import Driver, exportstream -logger = logging.getLogger(__name__) - class NetworkInterface(metaclass=ABCMeta): @classmethod @@ -34,7 +31,7 @@ class TcpNetwork(NetworkInterface, Driver): @exportstream @asynccontextmanager async def connect(self): - logger.debug("Connecting TCP host=%s port=%d", self.host, self.port) + self.logger.debug("Connecting TCP host=%s port=%d", self.host, self.port) async with await connect_tcp(remote_host=self.host, remote_port=self.port) as stream: yield stream @@ -47,7 +44,7 @@ class UdpNetwork(NetworkInterface, Driver): @exportstream @asynccontextmanager async def connect(self): - logger.debug("Connecting UDP host=%s port=%d", self.host, self.port) + self.logger.debug("Connecting UDP host=%s port=%d", self.host, self.port) async with await create_connected_udp_socket(remote_host=self.host, remote_port=self.port) as stream: yield stream @@ -59,7 +56,7 @@ class UnixNetwork(NetworkInterface, Driver): @exportstream @asynccontextmanager async def connect(self): - logger.debug("Connecting UDS path=%s", self.path) + self.logger.debug("Connecting UDS path=%s", self.path) async with await connect_unix(path=self.path) as stream: yield stream @@ -69,6 +66,6 @@ class EchoNetwork(NetworkInterface, Driver): @asynccontextmanager async def connect(self): tx, rx = create_memory_object_stream[bytes](32) - logger.debug("Connecting Echo") + self.logger.debug("Connecting Echo") async with StapledObjectStream(tx, rx) as stream: yield stream From 02231c5f43251955c35141203ac184a92244bcfa Mon Sep 17 00:00:00 2001 From: Nick Cao Date: Mon, 27 Jan 2025 09:35:54 -0500 Subject: [PATCH 03/10] Drop unused logging in jumpstarter-driver-ustreamer --- .../jumpstarter_driver_ustreamer/client.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/packages/jumpstarter-driver-ustreamer/jumpstarter_driver_ustreamer/client.py b/packages/jumpstarter-driver-ustreamer/jumpstarter_driver_ustreamer/client.py index 9fb006647..2be00db0a 100644 --- a/packages/jumpstarter-driver-ustreamer/jumpstarter_driver_ustreamer/client.py +++ b/packages/jumpstarter-driver-ustreamer/jumpstarter_driver_ustreamer/client.py @@ -1,5 +1,4 @@ import io -import logging from base64 import b64decode from PIL import Image @@ -7,8 +6,6 @@ from .common import UStreamerState from jumpstarter.client import DriverClient -log = logging.getLogger("ustreamer") - class UStreamerClient(DriverClient): """UStreamer client class From 5ecf6edb9446833627a6d8e0b5add34fbf8206f9 Mon Sep 17 00:00:00 2001 From: Nick Cao Date: Mon, 27 Jan 2025 09:36:26 -0500 Subject: [PATCH 04/10] Use self.logger in jumpstarter-driver-http --- .../jumpstarter_driver_http/driver.py | 62 +++++++++---------- 1 file changed, 30 insertions(+), 32 deletions(-) diff --git a/packages/jumpstarter-driver-http/jumpstarter_driver_http/driver.py b/packages/jumpstarter-driver-http/jumpstarter_driver_http/driver.py index 5b7774aa7..588b8b3fb 100644 --- a/packages/jumpstarter-driver-http/jumpstarter_driver_http/driver.py +++ b/packages/jumpstarter-driver-http/jumpstarter_driver_http/driver.py @@ -1,4 +1,3 @@ -import logging import os from dataclasses import dataclass, field from pathlib import Path @@ -10,8 +9,6 @@ from jumpstarter.driver import Driver, export -logger = logging.getLogger(__name__) - class HttpServerError(Exception): """Base exception for HTTP server errors""" @@ -21,26 +18,12 @@ class FileWriteError(HttpServerError): """Exception raised when file writing fails""" -def get_default_ip(): - try: - import socket - - s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) - s.connect(("8.8.8.8", 80)) - ip = s.getsockname()[0] - s.close() - return ip - except Exception: - logger.warning("Could not determine default IP address, falling back to 0.0.0.0") - return "0.0.0.0" - - @dataclass(kw_only=True) class HttpServer(Driver): """HTTP Server driver for Jumpstarter""" root_dir: str = "/var/www" - host: str = field(default_factory=get_default_ip) + host: str = field(default=None) port: int = 8080 app: web.Application = field(init=False, default_factory=web.Application) runner: Optional[web.AppRunner] = field(init=False, default=None) @@ -53,6 +36,21 @@ def __post_init__(self): web.get("/{filename}", self.get_file), ] ) + if self.host is None: + self.host = self.get_default_ip() + + def get_default_ip(self): + try: + import socket + + s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) + s.connect(("8.8.8.8", 80)) + ip = s.getsockname()[0] + s.close() + return ip + except Exception: + self.logger.warning("Could not determine default IP address, falling back to 0.0.0.0") + return "0.0.0.0" @classmethod def client(cls) -> str: @@ -86,11 +84,11 @@ async def put_file(self, filename: str, src_stream) -> str: async for chunk in src: await dst.send(chunk) - logger.info(f"File '{filename}' written to '{file_path}'") + self.logger.info(f"File '{filename}' written to '{file_path}'") return f"{self.get_url()}/{filename}" except Exception as e: - logger.error(f"Failed to upload file '{filename}': {e}") + self.logger.error(f"Failed to upload file '{filename}': {e}") raise FileWriteError(f"Failed to upload file '{filename}': {e}") from e @export @@ -112,10 +110,10 @@ async def delete_file(self, filename: str) -> str: raise HttpServerError(f"File '{filename}' does not exist.") try: file_path.unlink() - logger.info(f"File '{filename}' has been deleted.") + self.logger.info(f"File '{filename}' has been deleted.") return filename except Exception as e: - logger.error(f"Failed to delete file '{filename}': {e}") + self.logger.error(f"Failed to delete file '{filename}': {e}") raise HttpServerError(f"Failed to delete file '{filename}': {e}") from e async def get_file(self, request) -> web.FileResponse: @@ -134,9 +132,9 @@ async def get_file(self, request) -> web.FileResponse: filename = request.match_info["filename"] file_path = os.path.join(self.root_dir, filename) if not os.path.isfile(file_path): - logger.warning(f"File not found: {file_path}") + self.logger.warning(f"File not found: {file_path}") raise web.HTTPNotFound(text=f"File '{filename}' not found.") - logger.info(f"Serving file: {file_path}") + self.logger.info(f"Serving file: {file_path}") return web.FileResponse(file_path) @export @@ -155,7 +153,7 @@ def list_files(self) -> list[str]: files = [f for f in files if os.path.isfile(os.path.join(self.root_dir, f))] return files except Exception as e: - logger.error(f"Failed to list files: {e}") + self.logger.error(f"Failed to list files: {e}") raise HttpServerError(f"Failed to list files: {e}") from e @export @@ -167,7 +165,7 @@ async def start(self): HttpServerError: If the server fails to start. """ if self.runner is not None: - logger.warning("HTTP server is already running.") + self.logger.warning("HTTP server is already running.") return self.runner = web.AppRunner(self.app) @@ -176,7 +174,7 @@ async def start(self): site = web.TCPSite(self.runner, self.host, self.port) await site.start() - logger.info(f"HTTP server started at http://{self.host}:{self.port}") + self.logger.info(f"HTTP server started at http://{self.host}:{self.port}") @export async def stop(self): @@ -187,11 +185,11 @@ async def stop(self): HttpServerError: If the server fails to stop. """ if self.runner is None: - logger.warning("HTTP server is not running.") + self.logger.warning("HTTP server is not running.") return await self.runner.cleanup() - logger.info("HTTP server stopped.") + self.logger.info("HTTP server stopped.") self.runner = None @export @@ -230,7 +228,7 @@ def close(self): if anyio.get_current_task(): anyio.from_thread.run(self._async_cleanup) except Exception as e: - logger.warning(f"HTTP server cleanup failed synchronously: {e}") + self.logger.warning(f"HTTP server cleanup failed synchronously: {e}") self.runner = None super().close() @@ -239,6 +237,6 @@ async def _async_cleanup(self): if self.runner: await self.runner.shutdown() await self.runner.cleanup() - logger.info("HTTP server cleanup completed asynchronously.") + self.logger.info("HTTP server cleanup completed asynchronously.") except Exception as e: - logger.error(f"HTTP server cleanup failed asynchronously: {e}") + self.logger.error(f"HTTP server cleanup failed asynchronously: {e}") From 1f47caf7d0701521d55f2de3fe0ff45f0da2a1b9 Mon Sep 17 00:00:00 2001 From: Nick Cao Date: Mon, 27 Jan 2025 09:39:58 -0500 Subject: [PATCH 05/10] Use self.logger in jumpstarter-driver-pyserial --- .../jumpstarter_driver_pyserial/driver.py | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/packages/jumpstarter-driver-pyserial/jumpstarter_driver_pyserial/driver.py b/packages/jumpstarter-driver-pyserial/jumpstarter_driver_pyserial/driver.py index 67505d142..3de0a3b5d 100644 --- a/packages/jumpstarter-driver-pyserial/jumpstarter_driver_pyserial/driver.py +++ b/packages/jumpstarter-driver-pyserial/jumpstarter_driver_pyserial/driver.py @@ -1,4 +1,3 @@ -import logging from contextlib import asynccontextmanager from dataclasses import dataclass, field @@ -8,8 +7,6 @@ from jumpstarter.driver import Driver, exportstream -log = logging.getLogger(__name__) - @dataclass(kw_only=True) class AsyncSerial(ObjectStream): @@ -46,8 +43,8 @@ def client(cls) -> str: @exportstream @asynccontextmanager async def connect(self): - log.info("Connecting to %s, baudrate: %d", self.url, self.baudrate) + self.logger.info("Connecting to %s, baudrate: %d", self.url, self.baudrate) device = await run_sync(serial_for_url, self.url, self.baudrate) async with AsyncSerial(device=device) as stream: yield stream - log.info("Disconnected from %s", self.url) + self.logger.info("Disconnected from %s", self.url) From 8e138ec6a1fb7a06b962c8c0f32eead3537deada Mon Sep 17 00:00:00 2001 From: Nick Cao Date: Mon, 27 Jan 2025 09:40:36 -0500 Subject: [PATCH 06/10] Use self.logger in jumpstarter driver template --- __templates__/driver/jumpstarter_driver/driver.py.tmpl | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/__templates__/driver/jumpstarter_driver/driver.py.tmpl b/__templates__/driver/jumpstarter_driver/driver.py.tmpl index e4af766f4..3e11ab6ef 100644 --- a/__templates__/driver/jumpstarter_driver/driver.py.tmpl +++ b/__templates__/driver/jumpstarter_driver/driver.py.tmpl @@ -1,10 +1,7 @@ -import logging from dataclasses import dataclass from jumpstarter.driver import Driver, export -logger = logging.getLogger(__name__) - @dataclass(kw_only=True) class ${DRIVER_CLASS}(Driver): """${DRIVE_NAME} driver for Jumpstarter""" @@ -22,10 +19,10 @@ class ${DRIVER_CLASS}(Driver): @export def method1(self): - logger.info("Method1 called") + self.logger.info("Method1 called") return "method1 response" @export def method2(self): - logger.info("Method2 called") + self.logger.info("Method2 called") return "method2 response" From 802cda8c1161e6dc3b9a0408d6d1a4e59ba22c4c Mon Sep 17 00:00:00 2001 From: Nick Cao Date: Mon, 27 Jan 2025 09:41:29 -0500 Subject: [PATCH 07/10] Use self.logger in jumpstarter-driver-ustreamer --- .../jumpstarter_driver_ustreamer/driver.py | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/packages/jumpstarter-driver-ustreamer/jumpstarter_driver_ustreamer/driver.py b/packages/jumpstarter-driver-ustreamer/jumpstarter_driver_ustreamer/driver.py index 4d578746b..a4de35717 100644 --- a/packages/jumpstarter-driver-ustreamer/jumpstarter_driver_ustreamer/driver.py +++ b/packages/jumpstarter-driver-ustreamer/jumpstarter_driver_ustreamer/driver.py @@ -1,4 +1,3 @@ -import logging import sys from base64 import b64encode from contextlib import asynccontextmanager @@ -14,8 +13,6 @@ from .common import UStreamerState from jumpstarter.driver import Driver, export, exportstream -log = logging.getLogger(__name__) - def find_ustreamer(): executable = which("ustreamer") @@ -62,7 +59,7 @@ async def state(self): async with ClientSession(connector=UnixConnector(path=self.socketp)) as session: async with session.get("http://localhost/state") as r: json = await r.json() - log.debug(f"state: {json}") + self.logger.debug(f"state: {json}") return UStreamerState.model_validate(json) @export @@ -71,12 +68,12 @@ async def snapshot(self): async with session.get("http://localhost/snapshot") as r: data = await r.read() length = len(data) - log.debug(f"snapshot: {length} bytes") + self.logger.debug(f"snapshot: {length} bytes") return b64encode(data).decode("ascii") @exportstream @asynccontextmanager async def connect(self): - log.debug("streaming video") + self.logger.debug("streaming video") async with await connect_unix(self.socketp) as stream: yield stream From c6aa582056d49eb2c657b63df8465d039cdd45a8 Mon Sep 17 00:00:00 2001 From: Nick Cao Date: Mon, 27 Jan 2025 09:42:56 -0500 Subject: [PATCH 08/10] Use self.logger in jumpstarter-driver-dutlink --- .../jumpstarter_driver_dutlink/driver.py | 24 +++++++++---------- 1 file changed, 11 insertions(+), 13 deletions(-) diff --git a/packages/jumpstarter-driver-dutlink/jumpstarter_driver_dutlink/driver.py b/packages/jumpstarter-driver-dutlink/jumpstarter_driver_dutlink/driver.py index fc910f970..ddbb6514a 100644 --- a/packages/jumpstarter-driver-dutlink/jumpstarter_driver_dutlink/driver.py +++ b/packages/jumpstarter-driver-dutlink/jumpstarter_driver_dutlink/driver.py @@ -1,6 +1,5 @@ from __future__ import annotations -import logging import os import time from collections.abc import AsyncGenerator @@ -19,8 +18,6 @@ from jumpstarter.driver import Driver, export -log = logging.getLogger(__name__) - @dataclass(kw_only=True) class DutlinkConfig: @@ -35,7 +32,7 @@ def __post_init__(self): for dev in usb.core.find(idVendor=0x2B23, idProduct=0x1012, find_all=True): serial = usb.util.get_string(dev, dev.iSerialNumber) if serial == self.serial or self.serial is None: - log.debug(f"found dutlink board with serial {serial}") + self.logger.debug(f"found dutlink board with serial {serial}") self.serial = serial self.dev = dev @@ -78,7 +75,7 @@ def control(self, direction, ty, actions, action, value): if direction == usb.ENDPOINT_IN: str_value = bytes(res).decode("utf-8") - log.debug( + self.logger.debug( "ctrl_transfer result: %s", ) return str_value @@ -101,7 +98,7 @@ class DutlinkPower(DutlinkConfig, PowerInterface, Driver): last_action: str | None = field(default=None) def control(self, action): - log.debug(f"power control: {action}") + self.logger.debug(f"power control: {action}") if self.last_action == action: return @@ -160,7 +157,7 @@ class DutlinkStorageMux(DutlinkConfig, StorageMuxInterface, Driver): storage_device: str def control(self, action): - log.debug(f"storage control: {action}") + self.logger.debug(f"storage control: {action}") return super().control( usb.ENDPOINT_OUT, 0x02, @@ -190,9 +187,9 @@ def off(self): async def wait_for_storage_device(self): with fail_after(20): while True: - log.debug(f"waiting for storage device {self.storage_device}") + self.logger.debug(f"waiting for storage device {self.storage_device}") if os.path.exists(self.storage_device): - log.debug(f"storage device {self.storage_device} is ready") + self.logger.debug(f"storage device {self.storage_device} is ready") # https://stackoverflow.com/a/2774125 fd = os.open(self.storage_device, os.O_WRONLY) try: @@ -213,7 +210,7 @@ async def write(self, src: str): async for chunk in res: await stream.send(chunk) if total_bytes > next_print: - log.debug(f"{self.storage_device} written {total_bytes / (1024 * 1024)} MB") + self.logger.debug(f"{self.storage_device} written {total_bytes / (1024 * 1024)} MB") next_print += 50 * 1024 * 1024 total_bytes += len(chunk) @@ -255,15 +252,16 @@ def __post_init__(self): super().__post_init__() self.children["power"] = DutlinkPower(serial=self.serial, timeout_s=self.timeout_s) - self.children["storage"] = DutlinkStorageMux(serial=self.serial, storage_device=self.storage_device, - timeout_s=self.timeout_s) + self.children["storage"] = DutlinkStorageMux( + serial=self.serial, storage_device=self.storage_device, timeout_s=self.timeout_s + ) # if an alternate serial port has been requested, use it if self.alternate_console is not None: try: self.children["console"] = PySerial(url=self.alternate_console, baudrate=self.baudrate) except SerialException: - log.info( + self.logger.info( f"failed to open alternate console {self.alternate_console} but trying to power on the target once" ) self.children["power"].on() From 22df4b75df06f416c488e4fb52d79f1647dbdfc3 Mon Sep 17 00:00:00 2001 From: Nick Cao Date: Mon, 27 Jan 2025 09:47:48 -0500 Subject: [PATCH 09/10] Use self.logger in jumpstarter-driver-tftp --- .../jumpstarter_driver_tftp/driver.py | 52 +++++++++---------- 1 file changed, 25 insertions(+), 27 deletions(-) diff --git a/packages/jumpstarter-driver-tftp/jumpstarter_driver_tftp/driver.py b/packages/jumpstarter-driver-tftp/jumpstarter_driver_tftp/driver.py index 0d6e30301..f30d3a997 100644 --- a/packages/jumpstarter-driver-tftp/jumpstarter_driver_tftp/driver.py +++ b/packages/jumpstarter-driver-tftp/jumpstarter_driver_tftp/driver.py @@ -1,5 +1,4 @@ import asyncio -import logging import os import socket import threading @@ -13,19 +12,6 @@ from jumpstarter.driver import Driver, export -logger = logging.getLogger(__name__) - - -def get_default_ip(): - """Get the IP address of the default route interface""" - try: - with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s: - s.connect(("8.8.8.8", 80)) - return s.getsockname()[0] - except Exception: - logger.warning("Could not determine default IP address, falling back to 0.0.0.0") - return "0.0.0.0" - class TftpError(Exception): """Base exception for TFTP server errors""" @@ -50,7 +36,7 @@ class Tftp(Driver): """TFTP Server driver for Jumpstarter""" root_dir: str = "/var/lib/tftpboot" - host: str = field(default_factory=get_default_ip) + host: str = field(default=None) port: int = 69 server: Optional["TftpServer"] = field(init=False, default=None) server_thread: Optional[threading.Thread] = field(init=False, default=None) @@ -61,6 +47,18 @@ class Tftp(Driver): def __post_init__(self): super().__post_init__() os.makedirs(self.root_dir, exist_ok=True) + if self.host is None: + self.host = self.get_default_ip() + + def get_default_ip(self): + """Get the IP address of the default route interface""" + try: + with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s: + s.connect(("8.8.8.8", 80)) + return s.getsockname()[0] + except Exception: + self.logger.warning("Could not determine default IP address, falling back to 0.0.0.0") + return "0.0.0.0" @classmethod def client(cls) -> str: @@ -77,36 +75,36 @@ def _start_server(self): # Run the server until shutdown is requested self._loop.run_until_complete(self._run_server()) except Exception as e: - logger.error(f"Error running TFTP server: {e}") + self.logger.error(f"Error running TFTP server: {e}") finally: try: self._loop.run_until_complete(self._loop.shutdown_asyncgens()) self._loop.close() except Exception as e: - logger.error(f"Error during event loop cleanup: {e}") + self.logger.error(f"Error during event loop cleanup: {e}") self._loop = None - logger.info("TFTP server thread completed") + self.logger.info("TFTP server thread completed") async def _run_server(self): try: server_task = asyncio.create_task(self.server.start()) await asyncio.gather(server_task, self._wait_for_shutdown()) except asyncio.CancelledError: - logger.info("Server task cancelled") + self.logger.info("Server task cancelled") raise async def _wait_for_shutdown(self): while not self._shutdown_event.is_set(): await asyncio.sleep(0.1) - logger.info("Shutdown event detected") + self.logger.info("Shutdown event detected") if self.server is not None: await self.server.shutdown() @export def start(self): if self.server_thread is not None and self.server_thread.is_alive(): - logger.warning("TFTP server is already running") + self.logger.warning("TFTP server is already running") return # Clear any previous shutdown state @@ -118,26 +116,26 @@ def start(self): self.server_thread.start() if not self._loop_ready.wait(timeout=5.0): - logger.error("Timeout waiting for event loop to be ready") + self.logger.error("Timeout waiting for event loop to be ready") self.server_thread = None raise TftpError("Failed to start TFTP server - event loop initialization timeout") - logger.info(f"TFTP server started on {self.host}:{self.port}") + self.logger.info(f"TFTP server started on {self.host}:{self.port}") @export def stop(self): if self.server_thread is None or not self.server_thread.is_alive(): - logger.warning("stop called - TFTP server is not running") + self.logger.warning("stop called - TFTP server is not running") return - logger.info("Initiating TFTP server shutdown") + self.logger.info("Initiating TFTP server shutdown") self._shutdown_event.set() self.server_thread.join(timeout=10) if self.server_thread.is_alive(): - logger.error("Failed to stop TFTP server thread within timeout") + self.logger.error("Failed to stop TFTP server thread within timeout") else: - logger.info("TFTP server stopped successfully") + self.logger.info("TFTP server stopped successfully") self.server_thread = None @export From de882b2cc340d9e95a23c4e371283c0419701db6 Mon Sep 17 00:00:00 2001 From: Nick Cao Date: Mon, 27 Jan 2025 09:59:15 -0500 Subject: [PATCH 10/10] Apply review suggestions --- .../jumpstarter_driver_dutlink/driver.py | 4 +--- .../jumpstarter_driver_http/driver.py | 8 +++----- 2 files changed, 4 insertions(+), 8 deletions(-) diff --git a/packages/jumpstarter-driver-dutlink/jumpstarter_driver_dutlink/driver.py b/packages/jumpstarter-driver-dutlink/jumpstarter_driver_dutlink/driver.py index ddbb6514a..552e0ca59 100644 --- a/packages/jumpstarter-driver-dutlink/jumpstarter_driver_dutlink/driver.py +++ b/packages/jumpstarter-driver-dutlink/jumpstarter_driver_dutlink/driver.py @@ -75,9 +75,7 @@ def control(self, direction, ty, actions, action, value): if direction == usb.ENDPOINT_IN: str_value = bytes(res).decode("utf-8") - self.logger.debug( - "ctrl_transfer result: %s", - ) + self.logger.debug("ctrl_transfer result: %s", str_value) return str_value diff --git a/packages/jumpstarter-driver-http/jumpstarter_driver_http/driver.py b/packages/jumpstarter-driver-http/jumpstarter_driver_http/driver.py index 588b8b3fb..0b41f2594 100644 --- a/packages/jumpstarter-driver-http/jumpstarter_driver_http/driver.py +++ b/packages/jumpstarter-driver-http/jumpstarter_driver_http/driver.py @@ -43,11 +43,9 @@ def get_default_ip(self): try: import socket - s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) - s.connect(("8.8.8.8", 80)) - ip = s.getsockname()[0] - s.close() - return ip + with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s: + s.connect(("8.8.8.8", 80)) + return s.getsockname()[0] except Exception: self.logger.warning("Could not determine default IP address, falling back to 0.0.0.0") return "0.0.0.0"