NgTech-LTD/gns3-server
2
0
Fork 0
mirror of https://github.com/GNS3/gns3-server.git synced 2026-10-08 19:46:21 +03:00
Code Issues Packages Projects Releases Wiki Activity

refactor: use f-strings in remaining compute modules

Browse Source
This commit is contained in:
Mark Paronyan 2026-09-30 20:58:11 +03:00
parent bbebf20825
commit 552c0ca3e0
No known key found for this signature in database
GPG Key ID: 8DC7338A87FE22F8
10 changed files with 97 additions and 353 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

80
gns3server/compute/base_node.py
View File

@ -166,11 +166,7 @@ class BaseNode:
if self._wrap_aux:
self._internal_aux_port = self._manager.port_manager.get_free_tcp_port(self._project)
log.debug(
"{module}: {name} [{id}] initialized. Console port {console}".format(
module=self.manager.module_name, name=self.name, id=self.id, console=self._console
)
)
log.debug(f"{self.manager.module_name}: {self.name} [{self.id}] initialized. Console port {self._console}")
def __del__(self):
@ -255,11 +251,7 @@ class BaseNode:
:param new_name: name
"""
log.info(
"{module}: {name} [{id}] renamed to {new_name}".format(
module=self.manager.module_name, name=self.name, id=self.id, new_name=new_name
)
)
log.info(f"{self.manager.module_name}: {self.name} [{self.id}] renamed to {new_name}")
self._name = new_name
@property
@ -332,7 +324,7 @@ class BaseNode:
Creates the node.
"""
log.debug("{module}: {name} [{id}] created".format(module=self.manager.module_name, name=self.name, id=self.id))
log.debug(f"{self.manager.module_name}: {self.name} [{self.id}] created")
async def delete(self):
"""
@ -410,9 +402,7 @@ class BaseNode:
if self._closed:
return False
log.debug(
"{module}: '{name}' [{id}]: is closing".format(module=self.manager.module_name, name=self.name, id=self.id)
)
log.debug(f"{self.manager.module_name}: '{self.name}' [{self.id}]: is closing")
if self._console:
self._manager.port_manager.release_tcp_port(self._console, self._project)
@ -823,11 +813,7 @@ class BaseNode:
else:
self._aux = self._manager.port_manager.reserve_tcp_port(aux, self._project)
log.info(
"{module}: '{name}' [{id}]: auxiliary console port set to {port}".format(
module=self.manager.module_name, name=self.name, id=self.id, port=aux
)
)
log.info(f"{self.manager.module_name}: '{self.name}' [{self.id}]: auxiliary console port set to {aux}")
@property
def console(self):
@ -868,11 +854,7 @@ class BaseNode:
else:
self._console = self._manager.port_manager.reserve_tcp_port(console, self._project)
log.info(
"{module}: '{name}' [{id}]: console port set to {port}".format(
module=self.manager.module_name, name=self.name, id=self.id, port=console
)
)
log.info(f"{self.manager.module_name}: '{self.name}' [{self.id}]: console port set to {console}")
@property
def console_type(self):
@ -909,13 +891,7 @@ class BaseNode:
self._console_type = console_type
log.info(
"{module}: '{name}' [{id}]: console type set to {console_type} (console port is {console})".format(
module=self.manager.module_name,
name=self.name,
id=self.id,
console_type=console_type,
console=self.console,
)
f"{self.manager.module_name}: '{self.name}' [{self.id}]: console type set to {console_type} (console port is {self.console})"
)
@property
@ -951,9 +927,7 @@ class BaseNode:
self._aux_type = aux_type
log.info(
"{module}: '{name}' [{id}]: console type set to {aux_type} (auxiliary console port is {aux})".format(
module=self.manager.module_name, name=self.name, id=self.id, aux_type=aux_type, aux=self.aux
)
f"{self.manager.module_name}: '{self.name}' [{self.id}]: console type set to {aux_type} (auxiliary console port is {self.aux})"
)
@property
@ -1107,23 +1081,15 @@ class BaseNode:
raise NodeError("Destination NIO is not UDP")
await self._ubridge_send(
"bridge add_nio_udp {name} {lport} {rhost} {rport}".format(
name=bridge_name, lport=source_nio.lport, rhost=source_nio.rhost, rport=source_nio.rport
)
f"bridge add_nio_udp {bridge_name} {source_nio.lport} {source_nio.rhost} {source_nio.rport}"
)
await self._ubridge_send(
"bridge add_nio_udp {name} {lport} {rhost} {rport}".format(
name=bridge_name, lport=destination_nio.lport, rhost=destination_nio.rhost, rport=destination_nio.rport
)
f"bridge add_nio_udp {bridge_name} {destination_nio.lport} {destination_nio.rhost} {destination_nio.rport}"
)
if destination_nio.capturing:
await self._ubridge_send(
'bridge start_capture {name} "{pcap_file}"'.format(
name=bridge_name, pcap_file=destination_nio.pcap_output_file
)
)
await self._ubridge_send(f'bridge start_capture {bridge_name} "{destination_nio.pcap_output_file}"')
await self._ubridge_send(f"bridge start {bridge_name}")
await self._ubridge_apply_filters(bridge_name, destination_nio.filters)
@ -1237,7 +1203,7 @@ class BaseNode:
# so allow up to 48 here.
if not _MARKER_NAME_RE.match(name) or len(name) > 48:
raise UbridgeError(f"Invalid marker name: {name!r}")
cmd = 'bridge add_packet_filter {bridge} {name} mark "{bpf}"'.format(bridge=bridge_name, name=name, bpf=bpf)
cmd = f'bridge add_packet_filter {bridge_name} {name} mark "{bpf}"'
if tag is not None:
cmd += f" tag {tag}"
# Per-link attribution (contract §3.2): when one ubridge bridge serves
@ -1250,7 +1216,7 @@ class BaseNode:
linktype = self._marker_linktype(data_link_type)
if linktype is not None:
cmd += f" linktype {linktype}"
cmd += ' pcap "{path}"'.format(path=pcap_path)
cmd += f' pcap "{pcap_path}"'
# Let BPF compile errors propagate — the marker is the user's intent, so a
# bad expression must surface instead of being silently dropped.
await self._ubridge_send(cmd)
@ -1483,22 +1449,16 @@ class BaseNode:
if sys.platform.startswith("linux") and block_host_traffic is False:
# on Linux we use RAW sockets by default excepting if host traffic must be blocked
await self._ubridge_send(
'bridge add_nio_linux_raw {name} "{interface}"'.format(name=bridge_name, interface=ethernet_interface)
)
await self._ubridge_send(f'bridge add_nio_linux_raw {bridge_name} "{ethernet_interface}"')
else:
# on other platforms we just rely on the pcap library
await self._ubridge_send(
'bridge add_nio_ethernet {name} "{interface}"'.format(name=bridge_name, interface=ethernet_interface)
)
await self._ubridge_send(f'bridge add_nio_ethernet {bridge_name} "{ethernet_interface}"')
source_mac = None
for interface in interfaces():
if interface["name"] == ethernet_interface:
source_mac = interface["mac_address"]
if source_mac:
await self._ubridge_send(
'bridge set_pcap_filter {name} "not ether src {mac}"'.format(name=bridge_name, mac=source_mac)
)
await self._ubridge_send(f'bridge set_pcap_filter {bridge_name} "not ether src {source_mac}"')
log.info(f"PCAP filter applied on '{ethernet_interface}' for source MAC {source_mac}")
def _create_local_udp_tunnel(self):
@ -1516,9 +1476,7 @@ class BaseNode:
source_nio = self.manager.create_nio(source_nio_settings)
destination_nio = self.manager.create_nio(destination_nio_settings)
log.info(
"{module}: '{name}' [{id}]:local UDP tunnel created between port {port1} and {port2}".format(
module=self.manager.module_name, name=self.name, id=self.id, port1=lport, port2=rport
)
f"{self.manager.module_name}: '{self.name}' [{self.id}]:local UDP tunnel created between port {lport} and {rport}"
)
return source_nio, destination_nio
@ -1542,9 +1500,7 @@ class BaseNode:
available_ram = int(psutil.virtual_memory().available / (1024 * 1024))
percentage_left = 100 - psutil.virtual_memory().percent
if requested_ram > available_ram:
message = '"{}" requires {}MB of RAM to run but there is only {}MB - {}% of RAM left on "{}"'.format(
self.name, requested_ram, available_ram, percentage_left, platform.node()
)
message = f'"{self.name}" requires {requested_ram}MB of RAM to run but there is only {available_ram}MB - {percentage_left}% of RAM left on "{platform.node()}"'
self.project.emit("log.warning", {"message": message})
def _get_custom_adapter_settings(self, adapter_number):

58
gns3server/compute/builtin/nodes/cloud.py
View File

@ -298,19 +298,13 @@ class Cloud(BaseNode):
break
if not port_info:
raise NodeError(
"Port {port_number} doesn't exist on cloud '{name}'".format(name=self.name, port_number=port_number)
)
raise NodeError(f"Port {port_number} doesn't exist on cloud '{self.name}'")
bridge_name = f"{self._id}-{port_number}"
await self._ubridge_send(f"bridge create {bridge_name}")
if not isinstance(nio, NIOUDP):
raise NodeError("Source NIO is not UDP")
await self._ubridge_send(
"bridge add_nio_udp {name} {lport} {rhost} {rport}".format(
name=bridge_name, lport=nio.lport, rhost=nio.rhost, rport=nio.rport
)
)
await self._ubridge_send(f"bridge add_nio_udp {bridge_name} {nio.lport} {nio.rhost} {nio.rport}")
await self._ubridge_apply_filters(bridge_name, nio.filters)
await self._ubridge_apply_markers(bridge_name, nio)
@ -347,9 +341,7 @@ class Cloud(BaseNode):
)
if nio.capturing:
await self._ubridge_send(
'bridge start_capture {name} "{pcap_file}"'.format(name=bridge_name, pcap_file=nio.pcap_output_file)
)
await self._ubridge_send(f'bridge start_capture {bridge_name} "{nio.pcap_output_file}"')
await self._ubridge_send(f"bridge start {bridge_name}")
@ -370,14 +362,10 @@ class Cloud(BaseNode):
break
i += 1
await self._ubridge_send(
'bridge add_nio_tap "{name}" "{interface}"'.format(name=bridge_name, interface=tap)
)
await self._ubridge_send('brctl addif "{interface}" "{tap}"'.format(tap=tap, interface=interface))
await self._ubridge_send(f'bridge add_nio_tap "{bridge_name}" "{tap}"')
await self._ubridge_send(f'brctl addif "{interface}" "{tap}"')
else:
await self._ubridge_send(
'bridge add_nio_linux_raw {name} "{interface}"'.format(name=bridge_name, interface=interface)
)
await self._ubridge_send(f'bridge add_nio_linux_raw {bridge_name} "{interface}"')
async def _add_osx_ethernet(self, port_info, bridge_name):
"""
@ -423,17 +411,13 @@ class Cloud(BaseNode):
if port_number in self._nios:
raise NodeError(f"Port {port_number} isn't free")
log.debug(
'Cloud "{name}" [{id}]: NIO {nio} bound to port {port}'.format(
name=self._name, id=self._id, nio=nio, port=port_number
)
)
log.debug(f'Cloud "{self._name}" [{self._id}]: NIO {nio} bound to port {port_number}')
try:
await self.start()
await self._add_ubridge_connection(nio, port_number)
self._nios[port_number] = nio
except (NodeError, UbridgeError) as e:
log.error('Cannot add NIO on cloud "{name}": {error}'.format(name=self._name, error=e))
log.error(f'Cannot add NIO on cloud "{self._name}": {e}')
await self._stop_ubridge()
self.status = "stopped"
self._nios[port_number] = nio
@ -479,11 +463,7 @@ class Cloud(BaseNode):
if isinstance(nio, NIOUDP):
self.manager.port_manager.release_udp_port(nio.lport, self._project)
log.debug(
'Cloud "{name}" [{id}]: NIO {nio} removed from port {port}'.format(
name=self._name, id=self._id, nio=nio, port=port_number
)
)
log.debug(f'Cloud "{self._name}" [{self._id}]: NIO {nio} removed from port {port_number}')
del self._nios[port_number]
if self._ubridge_hypervisor and self._ubridge_hypervisor.is_running():
@ -501,9 +481,7 @@ class Cloud(BaseNode):
"""
if not [port["port_number"] for port in self._ports_mapping if port_number == port["port_number"]]:
raise NodeError(
"Port {port_number} doesn't exist on cloud '{name}'".format(name=self.name, port_number=port_number)
)
raise NodeError(f"Port {port_number} doesn't exist on cloud '{self.name}'")
if port_number not in self._nios:
raise NodeError(f"Port {port_number} is not connected")
@ -526,14 +504,8 @@ class Cloud(BaseNode):
raise NodeError(f"Packet capture is already activated on port {port_number}")
nio.start_packet_capture(output_file)
bridge_name = f"{self._id}-{port_number}"
await self._ubridge_send(
'bridge start_capture {name} "{output_file}"'.format(name=bridge_name, output_file=output_file)
)
log.debug(
"Cloud '{name}' [{id}]: starting packet capture on port {port_number}".format(
name=self.name, id=self.id, port_number=port_number
)
)
await self._ubridge_send(f'bridge start_capture {bridge_name} "{output_file}"')
log.debug(f"Cloud '{self.name}' [{self.id}]: starting packet capture on port {port_number}")
async def stop_capture(self, port_number):
"""
@ -549,8 +521,4 @@ class Cloud(BaseNode):
bridge_name = f"{self._id}-{port_number}"
await self._ubridge_send(f"bridge stop_capture {bridge_name}")
log.debug(
"Cloud'{name}' [{id}]: stopping packet capture on port {port_number}".format(
name=self.name, id=self.id, port_number=port_number
)
)
log.debug(f"Cloud'{self.name}' [{self.id}]: stopping packet capture on port {port_number}")

38
gns3server/compute/builtin/nodes/ethernet_switch.py
View File

@ -310,17 +310,13 @@ class EthernetSwitch(BaseNode):
if not isinstance(nio, NIOUDP):
raise NodeError("Ethernet switch ports only support UDP NIOs")
log.debug(
'Ethernet switch "{name}" [{id}]: NIO {nio} bound to port {port}'.format(
name=self._name, id=self._id, nio=nio, port=port_number
)
)
log.debug(f'Ethernet switch "{self._name}" [{self._id}]: NIO {nio} bound to port {port_number}')
try:
await self.start()
await self._add_ubridge_connection(nio, port_number)
self._nios[port_number] = nio
except (NodeError, UbridgeError) as e:
log.error('Cannot add NIO on Ethernet switch "{name}": {error}'.format(name=self._name, error=e))
log.error(f'Cannot add NIO on Ethernet switch "{self._name}": {e}')
await self._stop_ubridge()
self.status = "stopped"
self._nios[port_number] = nio
@ -347,19 +343,11 @@ class EthernetSwitch(BaseNode):
# VLAN membership for this port's access/trunk/qinq mode
await self._apply_port_vlan(port_settings, tap)
# GNS3 link endpoint
await self._ubridge_send(
"bridge add_nio_udp {name} {lport} {rhost} {rport}".format(
name=ubridge_bridge, lport=nio.lport, rhost=nio.rhost, rport=nio.rport
)
)
await self._ubridge_send(f"bridge add_nio_udp {ubridge_bridge} {nio.lport} {nio.rhost} {nio.rport}")
await self._ubridge_apply_filters(ubridge_bridge, nio.filters)
await self._ubridge_apply_markers(ubridge_bridge, nio)
if nio.capturing:
await self._ubridge_send(
'bridge start_capture {name} "{output_file}"'.format(
name=ubridge_bridge, output_file=nio.pcap_output_file
)
)
await self._ubridge_send(f'bridge start_capture {ubridge_bridge} "{nio.pcap_output_file}"')
await self._ubridge_send(f"bridge start {ubridge_bridge}")
self._tap_by_port[port_number] = tap
@ -397,11 +385,7 @@ class EthernetSwitch(BaseNode):
if isinstance(nio, NIOUDP):
self.manager.port_manager.release_udp_port(nio.lport, self._project)
log.debug(
'Ethernet switch "{name}" [{id}]: NIO {nio} removed from port {port}'.format(
name=self._name, id=self._id, nio=nio, port=port_number
)
)
log.debug(f'Ethernet switch "{self._name}" [{self._id}]: NIO {nio} removed from port {port_number}')
del self._nios[port_number]
if self._ubridge_hypervisor and self._ubridge_hypervisor.is_running():
await self._delete_ubridge_connection(port_number)
@ -512,11 +496,7 @@ class EthernetSwitch(BaseNode):
if self._ubridge_hypervisor and self._ubridge_hypervisor.is_running():
ubridge_bridge = self._ubridge_bridge_name(port_number)
await self._ubridge_send(f'bridge start_capture {ubridge_bridge} "{output_file}"')
log.debug(
'Ethernet switch "{name}" [{id}]: starting packet capture on port {port}'.format(
name=self.name, id=self.id, port=port_number
)
)
log.debug(f'Ethernet switch "{self.name}" [{self.id}]: starting packet capture on port {port_number}')
async def stop_capture(self, port_number):
"""
@ -532,8 +512,4 @@ class EthernetSwitch(BaseNode):
if self._ubridge_hypervisor and self._ubridge_hypervisor.is_running():
ubridge_bridge = self._ubridge_bridge_name(port_number)
await self._ubridge_send(f"bridge stop_capture {ubridge_bridge}")
log.debug(
'Ethernet switch "{name}" [{id}]: stopping packet capture on port {port}'.format(
name=self.name, id=self.id, port=port_number
)
)
log.debug(f'Ethernet switch "{self.name}" [{self.id}]: stopping packet capture on port {port_number}')

8
gns3server/compute/builtin/nodes/nat.py
View File

@ -44,8 +44,8 @@ class Nat(Cloud):
nat_interface = "virbr0"
if allowed_interfaces and nat_interface not in allowed_interfaces:
raise NodeError(
"NAT interface {} is not allowed be used on this server. "
"Please check the server configuration file.".format(nat_interface)
f"NAT interface {nat_interface} is not allowed be used on this server. "
"Please check the server configuration file."
)
if nat_interface not in [interface["name"] for interface in gns3server.utils.interfaces.interfaces()]:
raise NodeError(f"NAT interface {nat_interface} is missing, please install libvirt")
@ -56,8 +56,8 @@ class Nat(Cloud):
nat_interface = "vmnet8"
if allowed_interfaces and nat_interface not in allowed_interfaces:
raise NodeError(
"NAT interface {} is not allowed be used on this server. "
"Please check the server configuration file.".format(nat_interface)
f"NAT interface {nat_interface} is not allowed be used on this server. "
"Please check the server configuration file."
)
interfaces = list(
filter(

4
gns3server/compute/project_manager.py
View File

@ -91,9 +91,7 @@ class ProjectManager:
return
# send a warning if used disk space is >= 90%
if used_disk_space >= 90:
message = 'Only {:.2f}% or less of free disk space detected in "{}" on "{}"'.format(
100 - used_disk_space, project.path, platform.node()
)
message = f'Only {100 - used_disk_space:.2f}% or less of free disk space detected in "{project.path}" on "{platform.node()}"'
log.warning(message)
project.emit("log.warning", {"message": message})

16
gns3server/compute/ubridge/ubridge_hypervisor.py
View File

@ -188,9 +188,7 @@ class UBridgeHypervisor:
await self._writer.drain()
except OSError as e:
raise UbridgeError(
"Lost communication with {endpoint} when sending command '{command}': {error}, uBridge process running: {run}".format(
endpoint=self.endpoint, command=command, error=e, run=self.is_running()
)
f"Lost communication with {self.endpoint} when sending command '{command}': {e}, uBridge process running: {self.is_running()}"
)
# Now retrieve the result
@ -215,9 +213,7 @@ class UBridgeHypervisor:
if not chunk:
if retries > max_retries:
raise UbridgeError(
"No data returned from {endpoint} after sending command '{command}', uBridge process running: {run}".format(
endpoint=self.endpoint, command=command, run=self.is_running()
)
f"No data returned from {self.endpoint} after sending command '{command}', uBridge process running: {self.is_running()}"
)
else:
retries += 1
@ -227,9 +223,7 @@ class UBridgeHypervisor:
buf += chunk.decode("utf-8")
except OSError as e:
raise UbridgeError(
"Lost communication with {endpoint} after sending command '{command}': {error}, uBridge process running: {run}".format(
endpoint=self.endpoint, command=command, error=e, run=self.is_running()
)
f"Lost communication with {self.endpoint} after sending command '{command}': {e}, uBridge process running: {self.is_running()}"
)
# If the buffer doesn't end in '\n' then we can't be done
@ -238,9 +232,7 @@ class UBridgeHypervisor:
continue
except IndexError:
raise UbridgeError(
"Could not communicate with {endpoint} after sending command '{command}', uBridge process running: {run}".format(
endpoint=self.endpoint, command=command, run=self.is_running()
)
f"Could not communicate with {self.endpoint} after sending command '{command}', uBridge process running: {self.is_running()}"
)
data += buf.split("\r\n")

98
gns3server/compute/virtualbox/virtualbox_vm.py
View File

@ -234,7 +234,7 @@ class VirtualBoxVM(BaseNode):
linked_vbox_file = self._linked_vbox_file()
if not os.path.exists(linked_vbox_file):
raise VirtualBoxError("Cannot find VirtualBox linked node file: {}".format(linked_vbox_file))
raise VirtualBoxError(f"Cannot find VirtualBox linked node file: {linked_vbox_file}")
try:
tree = ET.parse(linked_vbox_file)
@ -402,11 +402,7 @@ class VirtualBoxVM(BaseNode):
self.status = "suspended"
log.info(f"VirtualBox VM '{self.name}' [{self.id}] suspended")
else:
log.warning(
"VirtualBox VM '{name}' [{id}] cannot be suspended, current state: {state}".format(
name=self.name, id=self.id, state=vm_state
)
)
log.warning(f"VirtualBox VM '{self.name}' [{self.id}] cannot be suspended, current state: {vm_state}")
async def resume(self):
"""
@ -511,9 +507,7 @@ class VirtualBoxVM(BaseNode):
os.path.join(self.working_dir, self._vmname, "Snapshots", os.path.basename(value))
):
log.info(
"VirtualBox VM '{name}' [{id}] detaching HDD {controller} {port} {device}".format(
name=self.name, id=self.id, controller=controller, port=port, device=device
)
f"VirtualBox VM '{self.name}' [{self.id}] detaching HDD {controller} {port} {device}"
)
hdd_table.append(
{
@ -530,11 +524,7 @@ class VirtualBoxVM(BaseNode):
with open(hdd_info_file, "w", encoding="utf-8") as f:
json.dump(hdd_table, f, indent=4)
except OSError as e:
log.warning(
"VirtualBox VM '{name}' [{id}] could not write HHD info file: {error}".format(
name=self.name, id=self.id, error=e.strerror
)
)
log.warning(f"VirtualBox VM '{self.name}' [{self.id}] could not write HHD info file: {e.strerror}")
return hdd_table
@ -739,15 +729,11 @@ class VirtualBoxVM(BaseNode):
log.warning(f"Could not find system property '{max_adapter_string}' for chipset {chipset}")
log.info(
"VirtualBox VM '{name}' [{id}] can have a maximum of {max} network adapters for chipset {chipset}".format(
name=self.name, id=self.id, max=self._maximum_adapters, chipset=chipset.upper()
)
f"VirtualBox VM '{self.name}' [{self.id}] can have a maximum of {self._maximum_adapters} network adapters for chipset {chipset.upper()}"
)
if adapters > self._maximum_adapters:
raise VirtualBoxError(
"The configured {} chipset limits the VM to {} network adapters. The chipset can be changed outside GNS3 in the VirtualBox VM settings.".format(
chipset.upper(), self._maximum_adapters
)
f"The configured {chipset.upper()} chipset limits the VM to {self._maximum_adapters} network adapters. The chipset can be changed outside GNS3 in the VirtualBox VM settings."
)
self._ethernet_adapters.clear()
@ -755,11 +741,7 @@ class VirtualBoxVM(BaseNode):
self._ethernet_adapters[adapter_number] = EthernetAdapter()
self._adapters = len(self._ethernet_adapters)
log.info(
"VirtualBox VM '{name}' [{id}] has changed the number of Ethernet adapters to {adapters}".format(
name=self.name, id=self.id, adapters=adapters
)
)
log.info(f"VirtualBox VM '{self.name}' [{self.id}] has changed the number of Ethernet adapters to {adapters}")
@property
def use_any_adapter(self):
@ -804,11 +786,7 @@ class VirtualBoxVM(BaseNode):
"""
self._adapter_type = adapter_type
log.info(
"VirtualBox VM '{name}' [{id}]: adapter type changed to {adapter_type}".format(
name=self.name, id=self.id, adapter_type=adapter_type
)
)
log.info(f"VirtualBox VM '{self.name}' [{self.id}]: adapter type changed to {adapter_type}")
async def _get_vm_info(self):
"""
@ -1076,11 +1054,7 @@ class VirtualBoxVM(BaseNode):
try:
adapter = self._ethernet_adapters[adapter_number]
except KeyError:
raise VirtualBoxError(
"Adapter {adapter_number} doesn't exist on VirtualBox VM '{name}'".format(
name=self.name, adapter_number=adapter_number
)
)
raise VirtualBoxError(f"Adapter {adapter_number} doesn't exist on VirtualBox VM '{self.name}'")
# check if trying to connect to a nat, bridged, host-only or any other special adapter
nic_attachments = await self._get_nic_attachements(self._maximum_adapters)
@ -1088,10 +1062,8 @@ class VirtualBoxVM(BaseNode):
if attachment in ("nat", "bridged", "intnet", "hostonly", "natnetwork"):
if not self._use_any_adapter:
raise VirtualBoxError(
"Attachment '{attachment}' is already configured on adapter {adapter_number}. "
"Please remove it or allow VirtualBox VM '{name}' to use any adapter.".format(
attachment=attachment, adapter_number=adapter_number, name=self.name
)
f"Attachment '{attachment}' is already configured on adapter {adapter_number}. "
f"Please remove it or allow VirtualBox VM '{self.name}' to use any adapter."
)
elif self.is_running():
# dynamically configure an UDP tunnel attachment if the VM is already running
@ -1109,19 +1081,11 @@ class VirtualBoxVM(BaseNode):
f"VBOX-{self._id}-{adapter_number}", self._local_udp_tunnels[adapter_number][1], nio
)
except KeyError:
raise VirtualBoxError(
"Adapter {adapter_number} doesn't exist on VirtualBox VM '{name}'".format(
name=self.name, adapter_number=adapter_number
)
)
raise VirtualBoxError(f"Adapter {adapter_number} doesn't exist on VirtualBox VM '{self.name}'")
await self._control_vm(f"setlinkstate{adapter_number + 1} on")
adapter.add_nio(0, nio)
log.info(
"VirtualBox VM '{name}' [{id}]: {nio} added to adapter {adapter_number}".format(
name=self.name, id=self.id, nio=nio, adapter_number=adapter_number
)
)
log.info(f"VirtualBox VM '{self.name}' [{self.id}]: {nio} added to adapter {adapter_number}")
async def adapter_update_nio_binding(self, adapter_number, nio):
"""
@ -1141,11 +1105,7 @@ class VirtualBoxVM(BaseNode):
else:
await self._control_vm(f"setlinkstate{adapter_number + 1} on")
except IndexError:
raise VirtualBoxError(
'Adapter {adapter_number} does not exist on VirtualBox VM "{name}"'.format(
name=self._name, adapter_number=adapter_number
)
)
raise VirtualBoxError(f'Adapter {adapter_number} does not exist on VirtualBox VM "{self._name}"')
async def adapter_remove_nio_binding(self, adapter_number):
"""
@ -1159,11 +1119,7 @@ class VirtualBoxVM(BaseNode):
try:
adapter = self._ethernet_adapters[adapter_number]
except KeyError:
raise VirtualBoxError(
"Adapter {adapter_number} doesn't exist on VirtualBox VM '{name}'".format(
name=self.name, adapter_number=adapter_number
)
)
raise VirtualBoxError(f"Adapter {adapter_number} doesn't exist on VirtualBox VM '{self.name}'")
await self.stop_capture(adapter_number)
if self.is_running():
@ -1177,11 +1133,7 @@ class VirtualBoxVM(BaseNode):
self.manager.port_manager.release_udp_port(nio.lport, self._project)
adapter.remove_nio(0)
log.info(
"VirtualBox VM '{name}' [{id}]: {nio} removed from adapter {adapter_number}".format(
name=self.name, id=self.id, nio=nio, adapter_number=adapter_number
)
)
log.info(f"VirtualBox VM '{self.name}' [{self.id}]: {nio} removed from adapter {adapter_number}")
return nio
def get_nio(self, adapter_number):
@ -1196,11 +1148,7 @@ class VirtualBoxVM(BaseNode):
try:
adapter = self.ethernet_adapters[adapter_number]
except KeyError:
raise VirtualBoxError(
"Adapter {adapter_number} doesn't exist on VirtualBox VM '{name}'".format(
name=self.name, adapter_number=adapter_number
)
)
raise VirtualBoxError(f"Adapter {adapter_number} doesn't exist on VirtualBox VM '{self.name}'")
nio = adapter.get_nio(0)
@ -1235,11 +1183,7 @@ class VirtualBoxVM(BaseNode):
)
)
log.info(
"VirtualBox VM '{name}' [{id}]: starting packet capture on adapter {adapter_number}".format(
name=self.name, id=self.id, adapter_number=adapter_number
)
)
log.info(f"VirtualBox VM '{self.name}' [{self.id}]: starting packet capture on adapter {adapter_number}")
async def stop_capture(self, adapter_number):
"""
@ -1256,8 +1200,4 @@ class VirtualBoxVM(BaseNode):
if self.ubridge:
await self._ubridge_send("bridge stop_capture {name}".format(name=f"VBOX-{self._id}-{adapter_number}"))
log.info(
"VirtualBox VM '{name}' [{id}]: stopping packet capture on adapter {adapter_number}".format(
name=self.name, id=self.id, adapter_number=adapter_number
)
)
log.info(f"VirtualBox VM '{self.name}' [{self.id}]: stopping packet capture on adapter {adapter_number}")

14
gns3server/compute/vmware/__init__.py
View File

@ -241,12 +241,12 @@ class VMware(BaseManager):
for line in f.read().splitlines():
match = re.search(r"VNET_([0-9]+)_HOSTONLY_SUBNET\s+(.*)", line)
if match:
vmnet = "vmnet{}".format(match.group(1))
vmnet = f"vmnet{match.group(1)}"
if vmnet in vmnet_interfaces.keys():
vmnet_interfaces[vmnet]["subnet"] = match.group(2)
match = re.search(r"VNET_([0-9]+)_HOSTONLY_NETMASK\s+(.*)", line)
if match:
vmnet = "vmnet{}".format(match.group(1))
vmnet = f"vmnet{match.group(1)}"
if vmnet in vmnet_interfaces.keys():
vmnet_interfaces[vmnet]["netmask"] = match.group(2)
@ -305,7 +305,7 @@ class VMware(BaseManager):
def refresh_vmnet_list(self, ubridge=True):
log.debug("Refreshing VMnet list with uBridge={}".format(ubridge))
log.debug(f"Refreshing VMnet list with uBridge={ubridge}")
if ubridge:
# VMnet host adapters must be present when uBridge is used
@ -315,7 +315,7 @@ class VMware(BaseManager):
self._vmnets_info = vmnet_interfaces.copy()
vmnet_interfaces = list(vmnet_interfaces.keys())
log.debug("Found {} VMnet interfaces".format(len(vmnet_interfaces)))
log.debug(f"Found {len(vmnet_interfaces)} VMnet interfaces")
# remove vmnets already in use
for vmware_vm in self._nodes.values():
for used_vmnet in vmware_vm.vmnets:
@ -326,7 +326,7 @@ class VMware(BaseManager):
# remove vmnets that are not managed
for vmnet in vmnet_interfaces.copy():
if vmnet in vmnet_interfaces and self.is_managed_vmnet(vmnet) is False:
log.debug("{} is not managed by GNS3".format(vmnet))
log.debug(f"{vmnet} is not managed by GNS3")
vmnet_interfaces.remove(vmnet)
self._vmnets = vmnet_interfaces
@ -677,9 +677,7 @@ class VMware(BaseManager):
default_vm_path = pairs["prefvmx.defaultvmpath"]
if not os.path.isdir(default_vm_path):
raise VMwareError(
'Could not find or access the default VM directory: "{default_vm_path}". Please change "prefvmx.defaultvmpath={default_vm_path}" in "{vmware_preferences_path}"'.format(
default_vm_path=default_vm_path, vmware_preferences_path=vmware_preferences_path
)
f'Could not find or access the default VM directory: "{default_vm_path}". Please change "prefvmx.defaultvmpath={default_vm_path}" in "{vmware_preferences_path}"'
)
vmware_vms = self._get_vms_from_directory(default_vm_path)

86
gns3server/compute/vmware/vmware_vm.py
View File

@ -361,18 +361,12 @@ class VMwareVM(BaseNode):
await self._add_ubridge_ethernet_connection(vnet, vmnet_interface, block_host_traffic)
else:
# special case on macOS, we cannot bind VMnet interfaces using the libpcap
await self._ubridge_send(
'bridge add_nio_fusion_vmnet {name} "{interface}"'.format(name=vnet, interface=vmnet_interface)
)
await self._ubridge_send(f'bridge add_nio_fusion_vmnet {vnet} "{vmnet_interface}"')
else:
await self._add_ubridge_ethernet_connection(vnet, vmnet_interface, block_host_traffic)
if isinstance(nio, NIOUDP):
await self._ubridge_send(
"bridge add_nio_udp {name} {lport} {rhost} {rport}".format(
name=vnet, lport=nio.lport, rhost=nio.rhost, rport=nio.rport
)
)
await self._ubridge_send(f"bridge add_nio_udp {vnet} {nio.lport} {nio.rhost} {nio.rport}")
if nio.capturing:
await self._ubridge_send(f'bridge start_capture {vnet} "{nio.pcap_output_file}"')
@ -418,9 +412,7 @@ class VMwareVM(BaseNode):
raise VMwareError(f"vnet {vnet} not in VMX file")
if not self._ubridge_hypervisor:
raise VMwareError("Cannot start the packet capture: uBridge is not running")
await self._ubridge_send(
'bridge start_capture {name} "{output_file}"'.format(name=vnet, output_file=output_file)
)
await self._ubridge_send(f'bridge start_capture {vnet} "{output_file}"')
async def _stop_ubridge_capture(self, adapter_number):
"""
@ -694,11 +686,7 @@ class VMwareVM(BaseNode):
self._ethernet_adapters[adapter_number] = EthernetAdapter()
self._adapters = len(self._ethernet_adapters)
log.info(
"VMware VM '{name}' [{id}] has changed the number of Ethernet adapters to {adapters}".format(
name=self.name, id=self.id, adapters=adapters
)
)
log.info(f"VMware VM '{self.name}' [{self.id}] has changed the number of Ethernet adapters to {adapters}")
@property
def adapter_type(self):
@ -719,11 +707,7 @@ class VMwareVM(BaseNode):
"""
self._adapter_type = adapter_type
log.info(
"VMware VM '{name}' [{id}]: adapter type changed to {adapter_type}".format(
name=self.name, id=self.id, adapter_type=adapter_type
)
)
log.info(f"VMware VM '{self.name}' [{self.id}]: adapter type changed to {adapter_type}")
@property
def use_any_adapter(self):
@ -760,11 +744,7 @@ class VMwareVM(BaseNode):
try:
adapter = self._ethernet_adapters[adapter_number]
except IndexError:
raise VMwareError(
"Adapter {adapter_number} doesn't exist on VMware VM '{name}'".format(
name=self.name, adapter_number=adapter_number
)
)
raise VMwareError(f"Adapter {adapter_number} doesn't exist on VMware VM '{self.name}'")
self._read_vmx_file()
# check if trying to connect to a nat, bridged or host-only adapter
@ -778,28 +758,20 @@ class VMwareVM(BaseNode):
):
if await self.is_running():
raise VMwareError(
"Attachment '{attachment}' is configured on network adapter {adapter_number}. "
"Please stop VMware VM '{name}' to link to this adapter and allow GNS3 to change the attachment type.".format(
attachment=self._vmx_pairs[connection_type], adapter_number=adapter_number, name=self.name
)
f"Attachment '{self._vmx_pairs[connection_type]}' is configured on network adapter {adapter_number}. "
f"Please stop VMware VM '{self.name}' to link to this adapter and allow GNS3 to change the attachment type."
)
else:
raise VMwareError(
"Attachment '{attachment}' is already configured on network adapter {adapter_number}. "
"Please remove it or allow VMware VM '{name}' to use any adapter.".format(
attachment=self._vmx_pairs[connection_type], adapter_number=adapter_number, name=self.name
)
f"Attachment '{self._vmx_pairs[connection_type]}' is already configured on network adapter {adapter_number}. "
f"Please remove it or allow VMware VM '{self.name}' to use any adapter."
)
adapter.add_nio(0, nio)
if self._started and self._ubridge_hypervisor:
await self._add_ubridge_connection(nio, adapter_number)
log.info(
"VMware VM '{name}' [{id}]: {nio} added to adapter {adapter_number}".format(
name=self.name, id=self.id, nio=nio, adapter_number=adapter_number
)
)
log.info(f"VMware VM '{self.name}' [{self.id}]: {nio} added to adapter {adapter_number}")
async def adapter_update_nio_binding(self, adapter_number, nio):
"""
@ -813,11 +785,7 @@ class VMwareVM(BaseNode):
try:
await self._update_ubridge_connection(adapter_number, nio)
except IndexError:
raise VMwareError(
'Adapter {adapter_number} does not exist on VMware VM "{name}"'.format(
name=self._name, adapter_number=adapter_number
)
)
raise VMwareError(f'Adapter {adapter_number} does not exist on VMware VM "{self._name}"')
async def adapter_remove_nio_binding(self, adapter_number):
"""
@ -831,11 +799,7 @@ class VMwareVM(BaseNode):
try:
adapter = self._ethernet_adapters[adapter_number]
except IndexError:
raise VMwareError(
"Adapter {adapter_number} doesn't exist on VMware VM '{name}'".format(
name=self.name, adapter_number=adapter_number
)
)
raise VMwareError(f"Adapter {adapter_number} doesn't exist on VMware VM '{self.name}'")
await self.stop_capture(adapter_number)
nio = adapter.get_nio(0)
@ -845,11 +809,7 @@ class VMwareVM(BaseNode):
if self._started and self._ubridge_hypervisor:
await self._delete_ubridge_connection(adapter_number)
log.info(
"VMware VM '{name}' [{id}]: {nio} removed from adapter {adapter_number}".format(
name=self.name, id=self.id, nio=nio, adapter_number=adapter_number
)
)
log.info(f"VMware VM '{self.name}' [{self.id}]: {nio} removed from adapter {adapter_number}")
return nio
@ -865,11 +825,7 @@ class VMwareVM(BaseNode):
try:
adapter = self.ethernet_adapters[adapter_number]
except KeyError:
raise VMwareError(
"Adapter {adapter_number} doesn't exist on VMware VM '{name}'".format(
name=self.name, adapter_number=adapter_number
)
)
raise VMwareError(f"Adapter {adapter_number} doesn't exist on VMware VM '{self.name}'")
nio = adapter.get_nio(0)
if not nio:
@ -984,11 +940,7 @@ class VMwareVM(BaseNode):
if self._started:
await self._start_ubridge_capture(adapter_number, output_file)
log.info(
"VMware VM '{name}' [{id}]: starting packet capture on adapter {adapter_number}".format(
name=self.name, id=self.id, adapter_number=adapter_number
)
)
log.info(f"VMware VM '{self.name}' [{self.id}]: starting packet capture on adapter {adapter_number}")
async def stop_capture(self, adapter_number):
"""
@ -1005,8 +957,4 @@ class VMwareVM(BaseNode):
if self._started:
await self._stop_ubridge_capture(adapter_number)
log.info(
"VMware VM '{name}' [{id}]: stopping packet capture on adapter {adapter_number}".format(
name=self.name, id=self.id, adapter_number=adapter_number
)
)
log.info(f"VMware VM '{self.name}' [{self.id}]: stopping packet capture on adapter {adapter_number}")

48
gns3server/compute/vpcs/vpcs_vm.py
View File

@ -384,21 +384,13 @@ class VPCSVM(BaseNode):
"""
if not self._ethernet_adapter.port_exists(port_number):
raise VPCSError(
"Port {port_number} doesn't exist on adapter {adapter}".format(
adapter=self._ethernet_adapter, port_number=port_number
)
)
raise VPCSError(f"Port {port_number} doesn't exist on adapter {self._ethernet_adapter}")
if self.is_running():
await self.add_ubridge_udp_connection(f"VPCS-{self._id}", self._local_udp_tunnel[1], nio)
self._ethernet_adapter.add_nio(port_number, nio)
log.info(
'VPCS "{name}" [{id}]: {nio} added to port {port_number}'.format(
name=self._name, id=self.id, nio=nio, port_number=port_number
)
)
log.info(f'VPCS "{self._name}" [{self.id}]: {nio} added to port {port_number}')
return nio
@ -411,11 +403,7 @@ class VPCSVM(BaseNode):
"""
if not self._ethernet_adapter.port_exists(port_number):
raise VPCSError(
"Port {port_number} doesn't exist on adapter {adapter}".format(
adapter=self._ethernet_adapter, port_number=port_number
)
)
raise VPCSError(f"Port {port_number} doesn't exist on adapter {self._ethernet_adapter}")
if self.is_running():
await self.update_ubridge_udp_connection(f"VPCS-{self._id}", self._local_udp_tunnel[1], nio)
@ -429,11 +417,7 @@ class VPCSVM(BaseNode):
"""
if not self._ethernet_adapter.port_exists(port_number):
raise VPCSError(
"Port {port_number} doesn't exist on adapter {adapter}".format(
adapter=self._ethernet_adapter, port_number=port_number
)
)
raise VPCSError(f"Port {port_number} doesn't exist on adapter {self._ethernet_adapter}")
await self.stop_capture(port_number)
if self.is_running():
@ -444,11 +428,7 @@ class VPCSVM(BaseNode):
self.manager.port_manager.release_udp_port(nio.lport, self._project)
self._ethernet_adapter.remove_nio(port_number)
log.info(
'VPCS "{name}" [{id}]: {nio} removed from port {port_number}'.format(
name=self._name, id=self.id, nio=nio, port_number=port_number
)
)
log.info(f'VPCS "{self._name}" [{self.id}]: {nio} removed from port {port_number}')
return nio
def get_nio(self, port_number):
@ -461,11 +441,7 @@ class VPCSVM(BaseNode):
"""
if not self._ethernet_adapter.port_exists(port_number):
raise VPCSError(
"Port {port_number} doesn't exist on adapter {adapter}".format(
adapter=self._ethernet_adapter, port_number=port_number
)
)
raise VPCSError(f"Port {port_number} doesn't exist on adapter {self._ethernet_adapter}")
nio = self._ethernet_adapter.get_nio(port_number)
if not nio:
raise VPCSError(f"Port {port_number} is not connected")
@ -489,11 +465,7 @@ class VPCSVM(BaseNode):
'bridge start_capture {name} "{output_file}"'.format(name=f"VPCS-{self._id}", output_file=output_file)
)
log.info(
"VPCS '{name}' [{id}]: starting packet capture on port {port_number}".format(
name=self.name, id=self.id, port_number=port_number
)
)
log.info(f"VPCS '{self.name}' [{self.id}]: starting packet capture on port {port_number}")
async def stop_capture(self, port_number):
"""
@ -510,11 +482,7 @@ class VPCSVM(BaseNode):
if self.ubridge:
await self._ubridge_send("bridge stop_capture {name}".format(name=f"VPCS-{self._id}"))
log.info(
"VPCS '{name}' [{id}]: stopping packet capture on port {port_number}".format(
name=self.name, id=self.id, port_number=port_number
)
)
log.info(f"VPCS '{self.name}' [{self.id}]: stopping packet capture on port {port_number}")
def _build_command(self):
"""