pdxjohnny/run_fedora_qmeu_vm_usb.py

## run_fedora_qmeu_vm_usb.py
import subprocess
import re
from dataclasses import dataclass
from pathlib import Path
import glob
import argparse

@dataclass
class USBInterface:
    """
    A dataclass to represent a USB Interface.

    Attributes:
        bInterfaceClass (int): The interface class of the USB device.
    """
    bInterfaceClass: int

    @staticmethod
    def from_lsusb_output(lsusb_output: str):
        """
        Parses the lsusb -v output to extract the bInterfaceClass value.

        Args:
            lsusb_output (str): The detailed output from lsusb -v.

        Returns:
            USBInterface: An instance of USBInterface with bInterfaceClass set.
        """
        bInterfaceClass = None
        for line in lsusb_output.splitlines():
            if 'bInterfaceClass' in line:
                match = re.search(r'bInterfaceClass\s+(\d+)', line)
                if match:
                    bInterfaceClass = int(match.group(1))
                    break
        return USBInterface(bInterfaceClass=bInterfaceClass)

def find_mass_storage_device():
    """
    Finds a USB device with the bInterfaceClass set to Mass Storage.

    Returns:
        tuple: A tuple containing the bus and device numbers of the found USB device.
    """
    lsusb_output = subprocess.run(['lsusb'], capture_output=True, text=True).stdout
    for line in lsusb_output.splitlines():
        bus, device = line.split()[1], line.split()[3][:-1]
        lsusb_v_output = subprocess.run(['lsusb', '-v', '-s', f'{bus}:{device}'], capture_output=True, text=True).stdout
        usb_interface = USBInterface.from_lsusb_output(lsusb_v_output)
        if usb_interface.bInterfaceClass == 8:  # Mass Storage
            return bus, device
    return None, None

def start_qemu_with_usb(bus, device, iso_image, qemu_path='qemu-system-x86_64'):
    """
    Starts the QEMU virtual machine with the specified ISO image and USB device.

    Args:
        bus (str): The bus number of the USB device.
        device (str): The device number of the USB device.
        iso_image (str): The path to the ISO image to boot from.
        qemu_path (str): The path to the QEMU binary.
    """
    if not bus or not device:
        print("No Mass Storage USB device found.")
        return

    usb_device_path = f'/dev/bus/usb/{bus}/{device}'
    print(f"Mass Storage USB device found at {usb_device_path}")

    qemu_command = [
        qemu_path,
        '-m', '4096',
        '-smp', '2',
        '-cdrom', iso_image,
        '-boot', 'd',
        '-enable-kvm',
        '-usb',
        '-device', f'usb-host,hostbus={bus},hostaddr={device}',
        '-vga', 'virtio',
        '-display', 'sdl',
        '-cpu', 'host'
    ]

    subprocess.run(qemu_command)

def find_iso_image(directory: Path, pattern: str):
    """
    Searches for an ISO file in the specified directory using the provided pattern.

    Args:
        directory (Path): The directory to search in.
        pattern (str): The glob pattern to use for searching.

    Returns:
        Path: The path to the found ISO file, or None if no file was found.
    """
    files = list(directory.glob(pattern))
    if not files:
        print(f"No ISO files found in {directory} with pattern {pattern}.")
        return None
    return files[0]

def parse_arguments():
    """
    Parses command-line arguments.

    Returns:
        argparse.Namespace: The parsed arguments.
    """
    parser = argparse.ArgumentParser(description='Run QEMU with a Fedora Workstation live ISO image and pass through a USB mass storage device.')
    parser.add_argument('--iso', type=str, help='Path to the Fedora Workstation live ISO image.')
    parser.add_argument('--bus', type=str, help='USB bus number.')
    parser.add_argument('--device', type=str, help='USB device number.')
    return parser.parse_args()

if __name__ == '__main__':
    args = parse_arguments()

    # Path to the Downloads directory
    downloads_path = Path.home() / 'Downloads'

    # Find the Fedora Workstation live ISO image
    if args.iso:
        iso_image = Path(args.iso)
    else:
        iso_image = find_iso_image(downloads_path, 'Fedora-Workstation-Live-*.iso')

    if iso_image is None:
        exit(1)

    # Find the mass storage USB device
    if args.bus and args.device:
        bus, device = args.bus, args.device
    else:
        bus, device = find_mass_storage_device()

    # Start the QEMU VM with the found USB device
    start_qemu_with_usb(bus, device, str(iso_image))
	import subprocess
	import re
	from dataclasses import dataclass
	from pathlib import Path
	import glob
	import argparse

	@dataclass
	class USBInterface:
	"""
	A dataclass to represent a USB Interface.

	Attributes:
	bInterfaceClass (int): The interface class of the USB device.
	"""
	bInterfaceClass: int

	@staticmethod
	def from_lsusb_output(lsusb_output: str):
	"""
	Parses the lsusb -v output to extract the bInterfaceClass value.

	Args:
	lsusb_output (str): The detailed output from lsusb -v.

	Returns:
	USBInterface: An instance of USBInterface with bInterfaceClass set.
	"""
	bInterfaceClass = None
	for line in lsusb_output.splitlines():
	if 'bInterfaceClass' in line:
	match = re.search(r'bInterfaceClass\s+(\d+)', line)
	if match:
	bInterfaceClass = int(match.group(1))
	break
	return USBInterface(bInterfaceClass=bInterfaceClass)

	def find_mass_storage_device():
	"""
	Finds a USB device with the bInterfaceClass set to Mass Storage.

	Returns:
	tuple: A tuple containing the bus and device numbers of the found USB device.
	"""
	lsusb_output = subprocess.run(['lsusb'], capture_output=True, text=True).stdout
	for line in lsusb_output.splitlines():
	bus, device = line.split()[1], line.split()[3][:-1]
	lsusb_v_output = subprocess.run(['lsusb', '-v', '-s', f'{bus}:{device}'], capture_output=True, text=True).stdout
	usb_interface = USBInterface.from_lsusb_output(lsusb_v_output)
	if usb_interface.bInterfaceClass == 8: # Mass Storage
	return bus, device
	return None, None

	def start_qemu_with_usb(bus, device, iso_image, qemu_path='qemu-system-x86_64'):
	"""
	Starts the QEMU virtual machine with the specified ISO image and USB device.

	Args:
	bus (str): The bus number of the USB device.
	device (str): The device number of the USB device.
	iso_image (str): The path to the ISO image to boot from.
	qemu_path (str): The path to the QEMU binary.
	"""
	if not bus or not device:
	print("No Mass Storage USB device found.")
	return

	usb_device_path = f'/dev/bus/usb/{bus}/{device}'
	print(f"Mass Storage USB device found at {usb_device_path}")

	qemu_command = [
	qemu_path,
	'-m', '4096',
	'-smp', '2',
	'-cdrom', iso_image,
	'-boot', 'd',
	'-enable-kvm',
	'-usb',
	'-device', f'usb-host,hostbus={bus},hostaddr={device}',
	'-vga', 'virtio',
	'-display', 'sdl',
	'-cpu', 'host'
	]

	subprocess.run(qemu_command)

	def find_iso_image(directory: Path, pattern: str):
	"""
	Searches for an ISO file in the specified directory using the provided pattern.

	Args:
	directory (Path): The directory to search in.
	pattern (str): The glob pattern to use for searching.

	Returns:
	Path: The path to the found ISO file, or None if no file was found.
	"""
	files = list(directory.glob(pattern))
	if not files:
	print(f"No ISO files found in {directory} with pattern {pattern}.")
	return None
	return files[0]

	def parse_arguments():
	"""
	Parses command-line arguments.

	Returns:
	argparse.Namespace: The parsed arguments.
	"""
	parser = argparse.ArgumentParser(description='Run QEMU with a Fedora Workstation live ISO image and pass through a USB mass storage device.')
	parser.add_argument('--iso', type=str, help='Path to the Fedora Workstation live ISO image.')
	parser.add_argument('--bus', type=str, help='USB bus number.')
	parser.add_argument('--device', type=str, help='USB device number.')
	return parser.parse_args()

	if __name__ == '__main__':
	args = parse_arguments()

	# Path to the Downloads directory
	downloads_path = Path.home() / 'Downloads'

	# Find the Fedora Workstation live ISO image
	if args.iso:
	iso_image = Path(args.iso)
	else:
	iso_image = find_iso_image(downloads_path, 'Fedora-Workstation-Live-*.iso')

	if iso_image is None:
	exit(1)

	# Find the mass storage USB device
	if args.bus and args.device:
	bus, device = args.bus, args.device
	else:
	bus, device = find_mass_storage_device()

	# Start the QEMU VM with the found USB device
	start_qemu_with_usb(bus, device, str(iso_image))