def _refreshInfo(self, iou_device):
self.uiIOUDeviceInfoTreeWidget.clear()
# fill out the General section
section_item = self._createSectionItem("General")
QtGui.QTreeWidgetItem(section_item, ["Name:", iou_device["name"]])
QtGui.QTreeWidgetItem(section_item, ["Server:", iou_device["server"]])
QtGui.QTreeWidgetItem(section_item, ["Image:", iou_device["image"]])
if iou_device["initial_config"]:
QtGui.QTreeWidgetItem(section_item, ["Initial config:", iou_device["initial_config"]])
if iou_device["use_default_iou_values"]:
QtGui.QTreeWidgetItem(section_item, ["RAM:", "default"])
QtGui.QTreeWidgetItem(section_item, ["NVRAM:", "default"])
else:
QtGui.QTreeWidgetItem(section_item, ["RAM:", "{} MiB".format(iou_device["ram"])])
QtGui.QTreeWidgetItem(section_item, ["NVRAM:", "{} KiB".format(iou_device["nvram"])])
# fill out the Network section
section_item = self._createSectionItem("Network")
QtGui.QTreeWidgetItem(section_item, ["Ethernet adapters:", "{} ({} interfaces)".format(iou_device["ethernet_adapters"],
iou_device["ethernet_adapters"] * 4)])
QtGui.QTreeWidgetItem(section_item, ["Serial adapters:", "{} ({} interfaces)".format(iou_device["serial_adapters"],
iou_device["serial_adapters"] * 4)])
self.uiIOUDeviceInfoTreeWidget.expandAll()
self.uiIOUDeviceInfoTreeWidget.resizeColumnToContents(0)
self.uiIOUDeviceInfoTreeWidget.resizeColumnToContents(1)
def _refreshInfo(self, vbox_vm):
self.uiVirtualBoxVMInfoTreeWidget.clear()
# fill out the General section
section_item = self._createSectionItem("General")
QtGui.QTreeWidgetItem(section_item, ["VM name:", vbox_vm["vmname"]])
QtGui.QTreeWidgetItem(section_item, ["RAM:", str(vbox_vm["ram"])])
QtGui.QTreeWidgetItem(section_item, ["Server:", vbox_vm["server"]])
QtGui.QTreeWidgetItem(section_item, [
"Remote console enabled:", "{}".format(
vbox_vm["enable_remote_console"])
])
QtGui.QTreeWidgetItem(
section_item,
["Headless mode enabled:", "{}".format(vbox_vm["headless"])])
QtGui.QTreeWidgetItem(
section_item,
["Linked base VM:", "{}".format(vbox_vm["linked_base"])])
# fill out the Network section
section_item = self._createSectionItem("Network")
QtGui.QTreeWidgetItem(
section_item, ["Adapters:", str(vbox_vm["adapters"])])
QtGui.QTreeWidgetItem(
section_item,
["Use any adapter:", "{}".format(vbox_vm["use_any_adapter"])])
QtGui.QTreeWidgetItem(section_item, ["Type:", vbox_vm["adapter_type"]])
self.uiVirtualBoxVMInfoTreeWidget.expandAll()
self.uiVirtualBoxVMInfoTreeWidget.resizeColumnToContents(0)
self.uiVirtualBoxVMInfoTreeWidget.resizeColumnToContents(1)
def loadSettings(self, settings, node, group=False):
"""
Loads the ATM bridge settings.
:param settings: the settings (dictionary)
:param node: Node instance
:param group: indicates the settings apply to a group
"""
if not group:
self.uiNameLineEdit.setText(settings["name"])
else:
self.uiNameLineEdit.setEnabled(False)
self.uiMappingTreeWidget.clear()
self._mapping = {}
self._node = node
for ethernet_port, destination in settings["mappings"].items():
item = QtGui.QTreeWidgetItem(self.uiMappingTreeWidget)
item.setText(0, ethernet_port)
item.setText(1, destination)
self.uiMappingTreeWidget.addTopLevelItem(item)
self._mapping[ethernet_port] = destination
self.uiMappingTreeWidget.resizeColumnToContents(0)
self.uiMappingTreeWidget.resizeColumnToContents(1)
def _addPortSlot(self):
"""
Adds a new port.
"""
port = self.uiPortSpinBox.value()
vlan = self.uiVlanSpinBox.value()
port_type = self.uiPortTypeComboBox.currentText()
if port in self._ports:
# update a given entry in the tree widget
item = self.uiPortsTreeWidget.findItems(
str(port), QtCore.Qt.MatchFixedString)[0]
item.setText(1, str(vlan))
item.setText(2, port_type)
else:
# add a new entry in the tree widget
item = QtGui.QTreeWidgetItem(self.uiPortsTreeWidget)
item.setText(0, str(port))
item.setText(1, str(vlan))
item.setText(2, port_type)
self.uiPortsTreeWidget.addTopLevelItem(item)
self._ports[port] = {"type": port_type, "vlan": vlan}
self.uiPortSpinBox.setValue(max(self._ports) + 1)
self.uiPortsTreeWidget.resizeColumnToContents(0)
def _addMappingSlot(self):
"""
Adds a new mapping.
"""
source_port = self.uiSourcePortSpinBox.value()
source_dlci = self.uiSourceDLCISpinBox.value()
destination_port = self.uiDestinationPortSpinBox.value()
destination_dlci = self.uiDestinationDLCISpinBox.value()
if source_port == destination_port:
QtGui.QMessageBox.critical(self, self._node.name(),
"Same source and destination ports")
return
source = "{port}:{dlci}".format(port=source_port, dlci=source_dlci)
destination = "{port}:{dlci}".format(port=destination_port,
dlci=destination_dlci)
if source in self._mapping or destination in self._mapping:
QtGui.QMessageBox.critical(self, self._node.name(),
"Mapping already defined")
return
item = QtGui.QTreeWidgetItem(self.uiMappingTreeWidget)
item.setText(0, source)
item.setText(1, destination)
self.uiMappingTreeWidget.addTopLevelItem(item)
self.uiSourcePortSpinBox.setValue(source_port + 1)
self.uiSourceDLCISpinBox.setValue(source_dlci + 1)
self.uiDestinationPortSpinBox.setValue(destination_port + 1)
self.uiDestinationDLCISpinBox.setValue(destination_dlci + 1)
self._mapping[source] = destination
def _remoteServerAddSlot(self):
"""
Adds a new remote server.
"""
if len(self._remote_servers) == 1:
QtGui.QMessageBox.critical(
self, "Remote server",
"Sorry we do not support multiple remote servers yet!")
return
host = self.uiRemoteServerPortLineEdit.text()
port = self.uiRemoteServerPortSpinBox.value()
# check if the remote server is already defined
remote_server = "{host}:{port}".format(host=host, port=port)
if remote_server in self._remote_servers:
QtGui.QMessageBox.critical(
self, "Remote server",
"Remote server {} is already defined.".format(remote_server))
return
# add a new entry in the tree widget
item = QtGui.QTreeWidgetItem(self.uiRemoteServersTreeWidget)
item.setText(0, host)
item.setText(1, str(port))
# keep track of this remote server
self._remote_servers[remote_server] = {"host": host, "port": port}
self.uiRemoteServerPortSpinBox.setValue(
self.uiRemoteServerPortSpinBox.value() + 1)
self.uiRemoteServersTreeWidget.resizeColumnToContents(0)
def _addMappingSlot(self):
"""
Adds a new mapping.
"""
source_port = self.uiSourcePortSpinBox.value()
source_vpi = self.uiSourceVPISpinBox.value()
source_vci = self.uiSourceVCISpinBox.value()
destination_port = self.uiDestinationPortSpinBox.value()
destination_vpi = self.uiDestinationVPISpinBox.value()
destination_vci = self.uiDestinationVCISpinBox.value()
if self.uiVPICheckBox.checkState() == QtCore.Qt.Unchecked:
source = "{port}:{vpi}:{vci}".format(port=source_port,
vpi=source_vpi,
vci=source_vci)
destination = "{port}:{vpi}:{vci}".format(port=destination_port,
vpi=destination_vpi,
vci=destination_vci)
else:
source = "{port}:{vpi}".format(port=source_port, vpi=source_vpi)
destination = "{port}:{vpi}".format(port=destination_port, vpi=destination_vpi)
if source in self._mapping or destination in self._mapping:
QtGui.QMessageBox.critical(self, self._node.name(), "Mapping already defined")
return
item = QtGui.QTreeWidgetItem(self.uiMappingTreeWidget)
item.setText(0, source)
item.setText(1, destination)
self.uiMappingTreeWidget.addTopLevelItem(item)
self.uiSourcePortSpinBox.setValue(source_port + 1)
self.uiDestinationPortSpinBox.setValue(destination_port + 1)
self._mapping[source] = destination
def loadPreferences(self):
"""
Loads the server preferences.
"""
servers = Servers.instance()
# load the local server preferences
local_server = servers.localServer()
index = self.uiLocalServerHostComboBox.findData(local_server.host)
if index != -1:
self.uiLocalServerHostComboBox.setCurrentIndex(index)
self.uiLocalServerPortSpinBox.setValue(local_server.port)
self.uiLocalServerPathLineEdit.setText(servers.localServerPath())
self.uiLocalServerAutoStartCheckBox.setChecked(
servers.localServerAutoStart())
# load remote server preferences
self._remote_servers.clear()
self.uiRemoteServersTreeWidget.clear()
for server_id, server in servers.remoteServers().items():
host = server.host
port = server.port
self._remote_servers[server_id] = {"host": host, "port": port}
item = QtGui.QTreeWidgetItem(self.uiRemoteServersTreeWidget)
item.setText(0, host)
item.setText(1, str(port))
self.uiRemoteServersTreeWidget.resizeColumnToContents(0)
def _qemuVMNewSlot(self):
"""
Creates a new VM.
"""
wizard = QemuVMWizard(self._qemu_vms, parent=self)
wizard.show()
if wizard.exec_():
new_vm_settings = wizard.getSettings()
key = "{server}:{name}".format(server=new_vm_settings["server"],
name=new_vm_settings["name"])
if key in self._qemu_vms:
QtGui.QMessageBox.critical(
self, "New QEMU VM", "VM name {} already exists".format(
new_vm_settings["name"]))
return
self._qemu_vms[key] = QEMU_VM_SETTINGS.copy()
self._qemu_vms[key].update(new_vm_settings)
item = QtGui.QTreeWidgetItem(self.uiQemuVMsTreeWidget)
item.setText(0, self._qemu_vms[key]["name"])
item.setIcon(0, QtGui.QIcon(self._qemu_vms[key]["default_symbol"]))
item.setData(0, QtCore.Qt.UserRole, key)
self._items.append(item)
self.uiQemuVMsTreeWidget.setCurrentItem(item)
if self._qemu_vms[key]["server"] == 'cloud':
self._qemu_vms[key]["options"] = "-nographic"
self._uploadImages(new_vm_settings)
def _addMappingSlot(self):
"""
Adds a new mapping.
"""
ethernet_port = self.uiEthernetPortSpinBox.value()
atm_port = self.uiATMPortSpinBox.value()
atm_vpi = self.uiATMVPISpinBox.value()
atm_vci = self.uiATMVCISpinBox.value()
if ethernet_port == atm_port:
QtGui.QMessageBox.critical(self, self._node.name(),
"Same source and destination ports")
return
destination = "{port}:{vpi}:{vci}".format(port=atm_port,
vpi=atm_vpi,
vci=atm_vci)
if destination in self._mapping:
QtGui.QMessageBox.critical(self, self._node.name(),
"Mapping already defined")
return
item = QtGui.QTreeWidgetItem(self.uiMappingTreeWidget)
item.setText(0, str(ethernet_port))
item.setText(1, destination)
self.uiMappingTreeWidget.addTopLevelItem(item)
self.uiEthernetPortSpinBox.setValue(ethernet_port + 1)
self.uiATMPortSpinBox.setValue(atm_port + 1)
self._mapping[ethernet_port] = destination
def loadSettings(self, settings, node, group=False):
"""
Loads the Ethernet switch settings.
:param settings: the settings (dictionary)
:param node: Node instance
:param group: indicates the settings apply to a group
"""
if not group:
self.uiNameLineEdit.setText(settings["name"])
else:
self.uiNameLineEdit.setEnabled(False)
self.uiPortsTreeWidget.clear()
self._ports = {}
self._node = node
for port, info in settings["ports"].items():
item = QtGui.QTreeWidgetItem(self.uiPortsTreeWidget)
item.setText(0, str(port))
item.setText(1, str(info["vlan"]))
item.setText(2, info["type"])
self.uiPortsTreeWidget.addTopLevelItem(item)
self._ports[port] = info
self.uiPortsTreeWidget.resizeColumnToContents(0)
self.uiPortsTreeWidget.resizeColumnToContents(1)
if len(self._ports) > 0:
self.uiPortSpinBox.setValue(max(self._ports) + 1)
def _createSectionItem(self, name):
section_item = QtGui.QTreeWidgetItem(self.uiQemuVMInfoTreeWidget)
section_item.setText(0, name)
font = section_item.font(0)
font.setBold(True)
section_item.setFont(0, font)
return section_item
def _iouImageSaveSlot(self):
"""
Adds/Saves an IOU image.
"""
path = self.uiIOUPathLineEdit.text()
startup_config = self.uiStartupConfigLineEdit.text()
use_default_iou_values = self.uiDefaultValuesCheckBox.isChecked()
nvram = self.uiNVRAMSpinBox.value()
ram = self.uiRAMSpinBox.value()
# basename doesn't work on Unix with Windows paths
if not sys.platform.startswith(
'win') and len(path) > 2 and path[1] == ":":
import ntpath
image = ntpath.basename(path)
else:
image = os.path.basename(path)
#TODO: mutiple remote server
if IOU.instance().settings()["use_local_server"]:
server = "local"
else:
server = next(iter(Servers.instance()))
if not server:
QtGui.QMessageBox.critical(self, "IOU image",
"No remote server available!")
return
server = server.host
key = "{server}:{image}".format(server=server, image=image)
item = self.uiIOUImagesTreeWidget.currentItem()
if key in self._iou_images and item and item.text(0) == image:
item.setText(0, image)
item.setText(1, server)
elif key in self._iou_images:
return
else:
# add a new entry in the tree widget
item = QtGui.QTreeWidgetItem(self.uiIOUImagesTreeWidget)
item.setText(0, image)
item.setText(1, server)
self.uiIOUImagesTreeWidget.setCurrentItem(item)
self._iou_images[key] = {
"path": path,
"image": image,
"startup_config": startup_config,
"use_default_iou_values": use_default_iou_values,
"ram": ram,
"nvram": nvram,
"server": server
}
self.uiIOUImagesTreeWidget.resizeColumnToContents(0)
self.uiIOUImagesTreeWidget.resizeColumnToContents(1)
def _iouDeviceNewSlot(self):
"""
Creates a new IOU device.
"""
wizard = IOUDeviceWizard(self._iou_devices, parent=self)
wizard.show()
if wizard.exec_():
new_device_settings = wizard.getSettings()
key = "{server}:{name}".format(
server=new_device_settings["server"],
name=new_device_settings["name"])
self._iou_devices[key] = IOU_DEVICE_SETTINGS.copy()
self._iou_devices[key].update(new_device_settings)
item = QtGui.QTreeWidgetItem(self.uiIOUDevicesTreeWidget)
item.setText(0, self._iou_devices[key]["name"])
item.setIcon(0,
QtGui.QIcon(self._iou_devices[key]["default_symbol"]))
item.setData(0, QtCore.Qt.UserRole, key)
self._items.append(item)
self.uiIOUDevicesTreeWidget.setCurrentItem(item)
if new_device_settings["server"] == 'cloud':
import logging
log = logging.getLogger(__name__)
# Start uploading the image to cloud files
self._upload_image_progress_dialog = QtGui.QProgressDialog(
"Uploading image file {}".format(
new_device_settings['image']),
"Cancel",
0,
0,
parent=self)
self._upload_image_progress_dialog.setWindowModality(
QtCore.Qt.WindowModal)
self._upload_image_progress_dialog.setWindowTitle(
"IOU image upload")
self._upload_image_progress_dialog.show()
try:
src = self._iou_devices[key]['path']
# Eg: images/IOU/i86.bin
dst = 'images/IOU/{}'.format(
self._iou_devices[key]['image'])
upload_thread = UploadFilesThread(
self,
MainWindow.instance().cloudSettings(), [(src, dst)])
upload_thread.completed.connect(self._imageUploadComplete)
upload_thread.start()
except Exception as e:
self._upload_image_progress_dialog.reject()
log.error(e)
QtGui.QMessageBox.critical(
self, "IOU image upload",
"Error uploading IOU image: {}".format(e))
def _updateRemoteServersSlot(self):
"""
Adds/Updates the available remote servers.
"""
servers = Servers.instance()
self.uiRemoteServersTreeWidget.clear()
for server in servers.remoteServers().values():
host = server.host
port = server.port
item = QtGui.QTreeWidgetItem(self.uiRemoteServersTreeWidget)
item.setText(0, host)
item.setText(1, str(port))
self.uiRemoteServersTreeWidget.resizeColumnToContents(0)
def loadPreferences(self):
"""
Loads the IOU image & device preferences.
"""
self._iou_images.clear()
self.uiIOUImagesTreeWidget.clear()
iou_images = IOU.instance().iouImages()
for iou_image in iou_images.values():
item = QtGui.QTreeWidgetItem(self.uiIOUImagesTreeWidget)
item.setText(0, iou_image["image"])
item.setText(1, iou_image["server"])
self.uiIOUImagesTreeWidget.resizeColumnToContents(0)
self.uiIOUImagesTreeWidget.resizeColumnToContents(1)
self._iou_images.update(iou_images)
def loadPreferences(self):
"""
Loads the IOS image & router preferences.
"""
self._ios_images.clear()
self.uiIOSImagesTreeWidget.clear()
ios_images = Dynamips.instance().iosImages()
for ios_image in ios_images.values():
item = QtGui.QTreeWidgetItem(self.uiIOSImagesTreeWidget)
item.setText(0, ios_image["image"])
item.setText(1, ios_image["platform"])
item.setText(2, ios_image["server"])
self.uiIOSImagesTreeWidget.resizeColumnToContents(0)
self.uiIOSImagesTreeWidget.resizeColumnToContents(1)
self._ios_images.update(ios_images)
def loadPreferences(self):
"""
Loads the IOU devices preferences.
"""
iou_module = IOU.instance()
self._iou_devices = copy.deepcopy(iou_module.iouDevices())
self._items.clear()
for key, iou_device in self._iou_devices.items():
item = QtGui.QTreeWidgetItem(self.uiIOUDevicesTreeWidget)
item.setText(0, iou_device["name"])
item.setIcon(0, QtGui.QIcon(iou_device["default_symbol"]))
item.setData(0, QtCore.Qt.UserRole, key)
self._items.append(item)
if self._items:
self.uiIOUDevicesTreeWidget.setCurrentItem(self._items[0])
self.uiIOUDevicesTreeWidget.sortByColumn(0, QtCore.Qt.AscendingOrder)
def loadPreferences(self):
"""
Loads the QEMU VM preferences.
"""
qemu_module = Qemu.instance()
self._qemu_vms = copy.deepcopy(qemu_module.qemuVMs())
self._items.clear()
for key, qemu_vm in self._qemu_vms.items():
item = QtGui.QTreeWidgetItem(self.uiQemuVMsTreeWidget)
item.setText(0, qemu_vm["name"])
item.setIcon(0, QtGui.QIcon(qemu_vm["default_symbol"]))
item.setData(0, QtCore.Qt.UserRole, key)
self._items.append(item)
if self._items:
self.uiQemuVMsTreeWidget.setCurrentItem(self._items[0])
self.uiQemuVMsTreeWidget.sortByColumn(0, QtCore.Qt.AscendingOrder)
def loadPreferences(self):
"""
Loads the IOS router preferences.
"""
dynamips_module = Dynamips.instance()
self._ios_routers = copy.deepcopy(dynamips_module.iosRouters())
self._items.clear()
for key, ios_router in self._ios_routers.items():
item = QtGui.QTreeWidgetItem(self.uiIOSRoutersTreeWidget)
item.setText(0, ios_router["name"])
item.setIcon(0, QtGui.QIcon(ios_router["default_symbol"]))
item.setData(0, QtCore.Qt.UserRole, key)
self._items.append(item)
if self._items:
self.uiIOSRoutersTreeWidget.setCurrentItem(self._items[0])
self.uiIOSRoutersTreeWidget.sortByColumn(0, QtCore.Qt.AscendingOrder)
def loadPreferences(self):
"""
Loads the VirtualBox VM preferences.
"""
vbox_module = VirtualBox.instance()
self._virtualbox_vms = copy.deepcopy(vbox_module.virtualBoxVMs())
self._items.clear()
for key, vbox_vm in self._virtualbox_vms.items():
item = QtGui.QTreeWidgetItem(self.uiVirtualBoxVMsTreeWidget)
item.setText(0, vbox_vm["vmname"])
item.setIcon(0, QtGui.QIcon(vbox_vm["default_symbol"]))
item.setData(0, QtCore.Qt.UserRole, key)
self._items.append(item)
if self._items:
self.uiVirtualBoxVMsTreeWidget.setCurrentItem(self._items[0])
self.uiVirtualBoxVMsTreeWidget.sortByColumn(
0, QtCore.Qt.AscendingOrder)
def _remoteServerAddSlot(self):
"""
Adds a new remote server.
"""
host = self.uiRemoteServerPortLineEdit.text().strip()
port = self.uiRemoteServerPortSpinBox.value()
if not re.match(
r"^[a-zA-Z0-9\.{}-]+$".format(
"\u0370-\u1CDF\u2C00-\u30FF\u4E00-\u9FBF"), host):
QtGui.QMessageBox.critical(
self, "Remote server",
"Invalid remote server hostname {}".format(host))
return
if port is None or port < 1:
QtGui.QMessageBox.critical(
self, "Remote server",
"Invalid remote server port {}".format(port))
return
# check if the remote server is already defined
remote_server = "{host}:{port}".format(host=host, port=port)
if remote_server in self._remote_servers:
QtGui.QMessageBox.critical(
self, "Remote server",
"Remote server {} is already defined.".format(remote_server))
return
# add a new entry in the tree widget
item = QtGui.QTreeWidgetItem(self.uiRemoteServersTreeWidget)
item.setText(0, host)
item.setText(1, str(port))
# keep track of this remote server
self._remote_servers[remote_server] = {"host": host, "port": port}
self.uiRemoteServerPortSpinBox.setValue(
self.uiRemoteServerPortSpinBox.value() + 1)
self.uiRemoteServersTreeWidget.resizeColumnToContents(0)
def _vboxVMNewSlot(self):
"""
Creates a new VirtualBox VM.
"""
wizard = VirtualBoxVMWizard(self._virtualbox_vms, parent=self)
wizard.show()
if wizard.exec_():
new_vm_settings = wizard.getSettings()
key = "{server}:{vmname}".format(server=new_vm_settings["server"],
vmname=new_vm_settings["vmname"])
self._virtualbox_vms[key] = VBOX_VM_SETTINGS.copy()
self._virtualbox_vms[key].update(new_vm_settings)
item = QtGui.QTreeWidgetItem(self.uiVirtualBoxVMsTreeWidget)
item.setText(0, self._virtualbox_vms[key]["vmname"])
item.setIcon(
0, QtGui.QIcon(self._virtualbox_vms[key]["default_symbol"]))
item.setData(0, QtCore.Qt.UserRole, key)
self._items.append(item)
self.uiVirtualBoxVMsTreeWidget.setCurrentItem(item)
def loadPreferences(self):
"""
Loads the server preferences.
"""
servers = Servers.instance()
# load the local server preferences
local_server_settings = servers.localServerSettings()
self._populateWidgets(local_server_settings)
# load remote server preferences
self._remote_servers.clear()
self.uiRemoteServersTreeWidget.clear()
for server_id, server in servers.remoteServers().items():
host = server.host
port = server.port
self._remote_servers[server_id] = {"host": host, "port": port}
item = QtGui.QTreeWidgetItem(self.uiRemoteServersTreeWidget)
item.setText(0, host)
item.setText(1, str(port))
self.uiRemoteServersTreeWidget.resizeColumnToContents(0)
def _refreshInfo(self, qemu_vm):
self.uiQemuVMInfoTreeWidget.clear()
# fill out the General section
section_item = self._createSectionItem("General")
QtGui.QTreeWidgetItem(section_item, ["VM name:", qemu_vm["name"]])
QtGui.QTreeWidgetItem(section_item, ["Server:", qemu_vm["server"]])
QtGui.QTreeWidgetItem(section_item,
["Memory:", "{} MB".format(qemu_vm["ram"])])
if qemu_vm["qemu_path"]:
QtGui.QTreeWidgetItem(
section_item,
["QEMU binary:",
os.path.basename(qemu_vm["qemu_path"])])
# fill out the Hard disks section
if qemu_vm["hda_disk_image"] or qemu_vm["hdb_disk_image"] or qemu_vm[
"hdc_disk_image"] or qemu_vm["hdd_disk_image"]:
section_item = self._createSectionItem("Hard disks")
if qemu_vm["hda_disk_image"]:
QtGui.QTreeWidgetItem(
section_item,
["Disk image (hda):", qemu_vm["hda_disk_image"]])
if qemu_vm["hdb_disk_image"]:
QtGui.QTreeWidgetItem(
section_item,
["Disk image (hdb):", qemu_vm["hdb_disk_image"]])
if qemu_vm["hdc_disk_image"]:
QtGui.QTreeWidgetItem(
section_item,
["Disk image (hdc):", qemu_vm["hdc_disk_image"]])
if qemu_vm["hdd_disk_image"]:
QtGui.QTreeWidgetItem(
section_item,
["Disk image (hdd):", qemu_vm["hdd_disk_image"]])
# fill out the Network section
section_item = self._createSectionItem("Network")
QtGui.QTreeWidgetItem(
section_item, ["Adapters:", str(qemu_vm["adapters"])])
QtGui.QTreeWidgetItem(section_item, ["Type:", qemu_vm["adapter_type"]])
# fill out the Linux boot section
if qemu_vm["initrd"] or qemu_vm["kernel_image"] or qemu_vm[
"kernel_command_line"]:
section_item = self._createSectionItem("Linux boot")
if qemu_vm["initrd"]:
QtGui.QTreeWidgetItem(section_item,
["Initial RAM disk:", qemu_vm["initrd"]])
if qemu_vm["kernel_image"]:
QtGui.QTreeWidgetItem(
section_item, ["Kernel image:", qemu_vm["kernel_image"]])
if qemu_vm["kernel_command_line"]:
QtGui.QTreeWidgetItem(
section_item,
["Kernel command line:", qemu_vm["kernel_command_line"]])
# performance section
section_item = self._createSectionItem("Optimizations")
if qemu_vm["cpu_throttling"]:
QtGui.QTreeWidgetItem(
section_item,
["CPU throttling:", "{}%".format(qemu_vm["cpu_throttling"])])
else:
QtGui.QTreeWidgetItem(section_item,
["CPU throttling:", "disabled"])
QtGui.QTreeWidgetItem(
section_item, ["Process priority:", qemu_vm["process_priority"]])
# fill out the Additional options section
if qemu_vm["options"]:
section_item = self._createSectionItem("Additional options")
QtGui.QTreeWidgetItem(section_item,
["Options:", qemu_vm["options"]])
self.uiQemuVMInfoTreeWidget.expandAll()
self.uiQemuVMInfoTreeWidget.resizeColumnToContents(0)
self.uiQemuVMInfoTreeWidget.resizeColumnToContents(1)
def _iosImageSaveSlot(self):
"""
Adds/Saves an IOS image.
"""
path = self.uiIOSPathLineEdit.text()
startup_config = self.uiStartupConfigLineEdit.text()
private_config = self.uiPrivateConfigLineEdit.text()
platform = self.uiPlatformComboBox.currentText()
chassis = self.uiChassisComboBox.currentText()
idlepc = self.uiIdlePCLineEdit.text()
ram = self.uiRAMSpinBox.value()
# basename doesn't work on Unix with Windows paths
if not sys.platform.startswith('win') and len(path) > 2 and path[1] == ":":
import ntpath
image = ntpath.basename(path)
else:
image = os.path.basename(path)
if image.startswith("c7200p"):
QtGui.QMessageBox.warning(self, "IOS image", "This IOS image is for the c7200 platform with NPE-G2 and using it is not recommended.\nPlease use an IOS image that do not start with c7200p.")
#TODO: mutiple remote server
if Dynamips.instance().settings()["use_local_server"]:
server = "local"
else:
server = next(iter(Servers.instance()))
if not server:
QtGui.QMessageBox.critical(self, "IOS image", "No remote server available!")
return
server = server.host
#ios_images = Dynamips.instance().iosImages()
key = "{server}:{image}".format(server=server, image=image)
item = self.uiIOSImagesTreeWidget.currentItem()
if key in self._ios_images and item and item.text(0) == image:
item.setText(0, image)
item.setText(1, platform)
item.setText(2, server)
elif key in self._ios_images:
print("Image already added")
return
else:
# add a new entry in the tree widget
item = QtGui.QTreeWidgetItem(self.uiIOSImagesTreeWidget)
item.setText(0, image)
item.setText(1, platform)
item.setText(2, server)
self.uiIOSImagesTreeWidget.setCurrentItem(item)
self._ios_images[key] = {"path": path,
"image": image,
"startup_config": startup_config,
"private_config": private_config,
"platform": platform,
"chassis": chassis,
"idlepc": idlepc,
"ram": ram,
"server": server}
self.uiIOSImagesTreeWidget.resizeColumnToContents(0)
self.uiIOSImagesTreeWidget.resizeColumnToContents(1)
def _refreshInfo(self, ios_router):
self.uiIOSRouterInfoTreeWidget.clear()
# fill out the General section
section_item = self._createSectionItem("General")
QtGui.QTreeWidgetItem(section_item, ["Name:", ios_router["name"]])
QtGui.QTreeWidgetItem(section_item, ["Server:", ios_router["server"]])
QtGui.QTreeWidgetItem(section_item,
["Platform:", ios_router["platform"]])
if ios_router["chassis"]:
QtGui.QTreeWidgetItem(section_item,
["Chassis:", ios_router["chassis"]])
QtGui.QTreeWidgetItem(section_item, ["Image:", ios_router["image"]])
if ios_router["idlepc"]:
QtGui.QTreeWidgetItem(section_item,
["Idle-PC:", ios_router["idlepc"]])
if ios_router["startup_config"]:
QtGui.QTreeWidgetItem(
section_item,
["Startup-config:", ios_router["startup_config"]])
if ios_router["private_config"]:
QtGui.QTreeWidgetItem(
section_item,
["Private-config:", ios_router["private_config"]])
if ios_router["platform"] == "c7200":
QtGui.QTreeWidgetItem(section_item,
["Midplane:", ios_router["midplane"]])
QtGui.QTreeWidgetItem(section_item, ["NPE:", ios_router["npe"]])
# fill out the Memories and disk section
section_item = self._createSectionItem("Memories and disks")
QtGui.QTreeWidgetItem(section_item,
["RAM:", "{} MiB".format(ios_router["ram"])])
QtGui.QTreeWidgetItem(section_item,
["NVRAM:", "{} KiB".format(ios_router["nvram"])])
if "iomem" in ios_router and ios_router["iomem"]:
QtGui.QTreeWidgetItem(
section_item,
["I/O memory:", "{}%".format(ios_router["iomem"])])
QtGui.QTreeWidgetItem(
section_item,
["PCMCIA disk0:", "{} MiB".format(ios_router["disk0"])])
QtGui.QTreeWidgetItem(
section_item,
["PCMCIA disk1:", "{} MiB".format(ios_router["disk1"])])
# fill out the Adapters section
section_item = self._createSectionItem("Adapters")
for slot_id in range(0, 7):
slot = "slot{}".format(slot_id)
if slot in ios_router and ios_router[slot]:
QtGui.QTreeWidgetItem(
section_item,
["Slot {}:".format(slot_id), ios_router[slot]])
if section_item.childCount() == 0:
self.uiIOSRouterInfoTreeWidget.takeTopLevelItem(
self.uiIOSRouterInfoTreeWidget.indexOfTopLevelItem(
section_item))
# fill out the WICs section
section_item = self._createSectionItem("WICs")
for wic_id in range(0, 3):
wic = "wic{}".format(wic_id)
if wic in ios_router and ios_router[wic]:
QtGui.QTreeWidgetItem(
section_item, ["WIC {}:".format(wic_id), ios_router[wic]])
if section_item.childCount() == 0:
self.uiIOSRouterInfoTreeWidget.takeTopLevelItem(
self.uiIOSRouterInfoTreeWidget.indexOfTopLevelItem(
section_item))
self.uiIOSRouterInfoTreeWidget.expandAll()
self.uiIOSRouterInfoTreeWidget.resizeColumnToContents(0)
self.uiIOSRouterInfoTreeWidget.resizeColumnToContents(1)
def _iosRouterNewSlot(self):
"""
Creates a new IOS router.
"""
wizard = IOSRouterWizard(self._ios_routers, parent=self)
wizard.show()
if wizard.exec_():
ios_settings = wizard.getSettings()
key = "{server}:{name}".format(server=ios_settings["server"],
name=ios_settings["name"])
self._ios_routers[key] = IOS_ROUTER_SETTINGS.copy()
self._ios_routers[key].update(ios_settings)
if ios_settings["server"] == 'cloud':
import logging
log = logging.getLogger(__name__)
log.debug(ios_settings["image"])
# Start uploading the image to cloud files
self._upload_image_progress_dialog = QtGui.QProgressDialog(
"Uploading image file {}".format(ios_settings['image']),
"Cancel",
0,
0,
parent=self)
self._upload_image_progress_dialog.setWindowModality(
QtCore.Qt.WindowModal)
self._upload_image_progress_dialog.setWindowTitle(
"IOS image upload")
self._upload_image_progress_dialog.show()
try:
upload_thread = UploadFilesThread(
self,
cloud_settings=MainWindow.instance().cloudSettings(),
files_to_upload=[
(self._ios_routers[key]["image"],
'images/' + os.path.relpath(
self._ios_routers[key]["image"],
self._main_window.settings().imagesDirPath()))
])
upload_thread.completed.connect(self._imageUploadComplete)
upload_thread.start()
except Exception as e:
self._upload_image_progress_dialog.reject()
log.error(e)
QtGui.QMessageBox.critical(
self, "IOS image upload",
"Error uploading IOS image: {}".format(e))
if ios_settings["platform"] == "c7200":
self._ios_routers[key]["midplane"] = "vxr"
self._ios_routers[key]["npe"] = "npe-400"
else:
self._ios_routers[key]["iomem"] = 5
for slot_id in range(0, 7):
slot = "slot{}".format(slot_id)
if slot in ios_settings:
self._ios_routers[key][slot] = ios_settings[slot]
for wic_id in range(0, 3):
wic = "wic{}".format(wic_id)
if wic in ios_settings:
self._ios_routers[key][wic] = ios_settings[wic]
self._ios_routers[key].update(ios_settings)
item = QtGui.QTreeWidgetItem(self.uiIOSRoutersTreeWidget)
item.setText(0, self._ios_routers[key]["name"])
item.setIcon(0,
QtGui.QIcon(self._ios_routers[key]["default_symbol"]))
item.setData(0, QtCore.Qt.UserRole, key)
self._items.append(item)
self.uiIOSRoutersTreeWidget.setCurrentItem(item)
