511 lines
17 KiB
Python
Executable File
511 lines
17 KiB
Python
Executable File
"""
|
|
Copyright (c) 2015-2017 Wind River Systems, Inc.
|
|
|
|
SPDX-License-Identifier: Apache-2.0
|
|
|
|
"""
|
|
|
|
from collections import OrderedDict
|
|
import netaddr
|
|
import xml.etree.ElementTree as ET
|
|
|
|
import wx
|
|
|
|
from common import utils, exceptions
|
|
from common.guicomponents import Field, TYPES, prepare_fields, on_change, \
|
|
set_icons, handle_sub_show
|
|
from common.configobjects import HOST_XML_ATTRIBUTES
|
|
from common.validator import TiS_VERSION
|
|
|
|
PAGE_SIZE = (200, 200)
|
|
WINDOW_SIZE = (570, 700)
|
|
CB_TRUE = True
|
|
CB_FALSE = False
|
|
PADDING = 10
|
|
|
|
IMPORT_ID = 100
|
|
EXPORT_ID = 101
|
|
|
|
INTERNAL_ID = 105
|
|
EXTERNAL_ID = 106
|
|
|
|
filedir = ""
|
|
filename = ""
|
|
|
|
# Globals
|
|
BULK_ADDING = False
|
|
|
|
|
|
class HostPage(wx.Panel):
|
|
def __init__(self, parent):
|
|
wx.Panel.__init__(self, parent=parent)
|
|
|
|
self.parent = parent
|
|
self.sizer = wx.BoxSizer(wx.VERTICAL)
|
|
self.SetSizer(self.sizer)
|
|
self.fieldgroup = []
|
|
self.fieldgroup.append(OrderedDict())
|
|
self.fieldgroup.append(OrderedDict())
|
|
self.fieldgroup.append(OrderedDict())
|
|
|
|
self.fields_sizer1 = wx.GridBagSizer(vgap=10, hgap=10)
|
|
self.fields_sizer2 = wx.GridBagSizer(vgap=10, hgap=10)
|
|
self.fields_sizer3 = wx.GridBagSizer(vgap=10, hgap=10)
|
|
|
|
# Basic Fields
|
|
self.fieldgroup[0]['personality'] = Field(
|
|
text="Personality",
|
|
type=TYPES.choice,
|
|
choices=['compute', 'controller', 'storage'],
|
|
initial='compute'
|
|
)
|
|
self.fieldgroup[0]['hostname'] = Field(
|
|
text="Hostname",
|
|
type=TYPES.string,
|
|
initial=parent.get_next_hostname()
|
|
)
|
|
self.fieldgroup[0]['mgmt_mac'] = Field(
|
|
text="Management MAC Address",
|
|
type=TYPES.string,
|
|
initial=""
|
|
)
|
|
self.fieldgroup[0]['mgmt_ip'] = Field(
|
|
text="Management IP Address",
|
|
type=TYPES.string,
|
|
initial=""
|
|
)
|
|
self.fieldgroup[0]['location'] = Field(
|
|
text="Location",
|
|
type=TYPES.string,
|
|
initial=""
|
|
)
|
|
|
|
# Board Management
|
|
self.fieldgroup[1]['uses_bm'] = Field(
|
|
text="This host uses Board Management",
|
|
type=TYPES.checkbox,
|
|
initial="",
|
|
shows=['bm_ip', 'bm_username',
|
|
'bm_password', 'power_on'],
|
|
transient=True
|
|
)
|
|
self.fieldgroup[1]['bm_ip'] = Field(
|
|
text="Board Management IP Address",
|
|
type=TYPES.string,
|
|
initial=""
|
|
)
|
|
self.fieldgroup[1]['bm_username'] = Field(
|
|
text="Board Management username",
|
|
type=TYPES.string,
|
|
initial=""
|
|
)
|
|
self.fieldgroup[1]['bm_password'] = Field(
|
|
text="Board Management password",
|
|
type=TYPES.string,
|
|
initial=""
|
|
)
|
|
self.fieldgroup[1]['power_on'] = Field(
|
|
text="Power on host",
|
|
type=TYPES.checkbox,
|
|
initial="N",
|
|
transient=True
|
|
)
|
|
|
|
# Installation Parameters
|
|
self.fieldgroup[2]['boot_device'] = Field(
|
|
text="Boot Device",
|
|
type=TYPES.string,
|
|
initial=""
|
|
)
|
|
self.fieldgroup[2]['rootfs_device'] = Field(
|
|
text="Rootfs Device",
|
|
type=TYPES.string,
|
|
initial=""
|
|
)
|
|
self.fieldgroup[2]['install_output'] = Field(
|
|
text="Installation Output",
|
|
type=TYPES.choice,
|
|
choices=['text', 'graphical'],
|
|
initial="text"
|
|
)
|
|
self.fieldgroup[2]['console'] = Field(
|
|
text="Console",
|
|
type=TYPES.string,
|
|
initial=""
|
|
)
|
|
|
|
prepare_fields(self, self.fieldgroup[0], self.fields_sizer1,
|
|
self.on_change)
|
|
prepare_fields(self, self.fieldgroup[1], self.fields_sizer2,
|
|
self.on_change)
|
|
prepare_fields(self, self.fieldgroup[2], self.fields_sizer3,
|
|
self.on_change)
|
|
|
|
# Bind button handlers
|
|
self.Bind(wx.EVT_CHOICE, self.on_personality,
|
|
self.fieldgroup[0]['personality'].input)
|
|
|
|
self.Bind(wx.EVT_TEXT, self.on_hostname,
|
|
self.fieldgroup[0]['hostname'].input)
|
|
|
|
# Control Buttons
|
|
self.button_sizer = wx.BoxSizer(orient=wx.HORIZONTAL)
|
|
|
|
self.add = wx.Button(self, -1, "Add a New Host")
|
|
self.Bind(wx.EVT_BUTTON, self.on_add, self.add)
|
|
|
|
self.remove = wx.Button(self, -1, "Remove this Host")
|
|
self.Bind(wx.EVT_BUTTON, self.on_remove, self.remove)
|
|
|
|
self.button_sizer.Add(self.add)
|
|
self.button_sizer.Add(self.remove)
|
|
|
|
# Add fields and spacers
|
|
self.sizer.Add(self.fields_sizer1)
|
|
self.sizer.AddWindow(wx.StaticLine(self, -1), 0, wx.EXPAND | wx.ALL,
|
|
PADDING)
|
|
self.sizer.Add(self.fields_sizer2)
|
|
self.sizer.AddWindow(wx.StaticLine(self, -1), 0, wx.EXPAND | wx.ALL,
|
|
PADDING)
|
|
self.sizer.Add(self.fields_sizer3)
|
|
self.sizer.AddStretchSpacer()
|
|
self.sizer.AddWindow(wx.StaticLine(self, -1), 0, wx.EXPAND | wx.ALL,
|
|
PADDING)
|
|
self.sizer.Add(self.button_sizer, border=10, flag=wx.CENTER)
|
|
|
|
def on_hostname(self, event, string=None):
|
|
"""Update the List entry text to match the new hostname
|
|
"""
|
|
string = string or event.GetString()
|
|
index = self.parent.GetSelection()
|
|
self.parent.SetPageText(index, string)
|
|
self.parent.parent.Layout()
|
|
|
|
def on_personality(self, event, string=None):
|
|
"""Remove hostname field if it's a storage or controller
|
|
"""
|
|
string = string or event.GetString()
|
|
index = self.parent.GetSelection()
|
|
if string == 'compute':
|
|
self.fieldgroup[0]['hostname'].show(True)
|
|
self.parent.SetPageText(index,
|
|
self.fieldgroup[0]['hostname'].get_value())
|
|
return
|
|
elif string == 'controller':
|
|
self.fieldgroup[0]['hostname'].show(False)
|
|
elif string == 'storage':
|
|
self.fieldgroup[0]['hostname'].show(False)
|
|
self.parent.SetPageText(index, string)
|
|
self.parent.Layout()
|
|
|
|
def on_add(self, event):
|
|
try:
|
|
self.validate()
|
|
except Exception as ex:
|
|
wx.LogError("Error on page: " + ex.message)
|
|
return
|
|
|
|
self.parent.new_page()
|
|
|
|
def on_remove(self, event):
|
|
if self.parent.GetPageCount() is 1:
|
|
wx.LogError("Must leave at least one host")
|
|
return
|
|
index = self.parent.GetSelection()
|
|
self.parent.DeletePage(index)
|
|
|
|
def to_xml(self):
|
|
"""Create the XML for this host
|
|
"""
|
|
self.validate()
|
|
|
|
attrs = ""
|
|
# Generic handling
|
|
for fgroup in self.fieldgroup:
|
|
for name, field in fgroup.items():
|
|
if field.transient or not field.get_value():
|
|
continue
|
|
attrs += "\t\t<" + name + ">" + \
|
|
field.get_value() + "</" + name + ">\n"
|
|
|
|
# Special Fields
|
|
if self.fieldgroup[1]['power_on'].get_value() is 'Y':
|
|
attrs += "\t\t<power_on/>\n"
|
|
|
|
if self.fieldgroup[1]['uses_bm'].get_value() is 'Y':
|
|
attrs += "\t\t<bm_type>bmc</bm_type>\n"
|
|
|
|
return "\t<host>\n" + attrs + "\t</host>\n"
|
|
|
|
def validate(self):
|
|
if self.fieldgroup[0]['personality'].get_value() == "compute" and not \
|
|
utils.is_valid_hostname(
|
|
self.fieldgroup[0]['hostname'].get_value()):
|
|
raise exceptions.ValidateFail(
|
|
"Hostname %s is not valid" %
|
|
self.fieldgroup[0]['hostname'].get_value())
|
|
|
|
if not utils.is_valid_mac(self.fieldgroup[0]['mgmt_mac'].get_value()):
|
|
raise exceptions.ValidateFail(
|
|
"Management MAC address %s is not valid" %
|
|
self.fieldgroup[0]['mgmt_mac'].get_value())
|
|
|
|
ip = self.fieldgroup[0]['mgmt_ip'].get_value()
|
|
if ip:
|
|
try:
|
|
netaddr.IPAddress(ip)
|
|
except Exception:
|
|
raise exceptions.ValidateFail(
|
|
"Management IP address %s is not valid" % ip)
|
|
|
|
if self.fieldgroup[1]['uses_bm'].get_value() == 'Y':
|
|
ip = self.fieldgroup[1]['bm_ip'].get_value()
|
|
if ip:
|
|
try:
|
|
netaddr.IPAddress(ip)
|
|
except Exception:
|
|
raise exceptions.ValidateFail(
|
|
"Board Management IP address %s is not valid" % ip)
|
|
|
|
else:
|
|
raise exceptions.ValidateFail(
|
|
"Board Management IP is not specified. "
|
|
"External Board Management Network requires Board "
|
|
"Management IP address.")
|
|
|
|
def on_change(self, event):
|
|
on_change(self, self.fieldgroup[1], event)
|
|
|
|
def set_field(self, name, value):
|
|
for fgroup in self.fieldgroup:
|
|
for fname, field in fgroup.items():
|
|
if fname == name:
|
|
field.set_value(value)
|
|
|
|
|
|
class HostBook(wx.Listbook):
|
|
def __init__(self, parent):
|
|
wx.Listbook.__init__(self, parent, style=wx.BK_DEFAULT)
|
|
|
|
self.parent = parent
|
|
self.Layout()
|
|
# Add a starting host
|
|
self.new_page()
|
|
|
|
self.Bind(wx.EVT_LISTBOOK_PAGE_CHANGED, self.on_changed)
|
|
self.Bind(wx.EVT_LISTBOOK_PAGE_CHANGING, self.on_changing)
|
|
|
|
def on_changed(self, event):
|
|
event.Skip()
|
|
|
|
def on_changing(self, event):
|
|
# Trigger page validation before leaving
|
|
if BULK_ADDING:
|
|
event.Skip()
|
|
return
|
|
index = self.GetSelection()
|
|
try:
|
|
if index != -1:
|
|
self.GetPage(index).validate()
|
|
except Exception as ex:
|
|
wx.LogError("Error on page: " + ex.message)
|
|
event.Veto()
|
|
return
|
|
event.Skip()
|
|
|
|
def new_page(self, hostname=None):
|
|
new_page = HostPage(self)
|
|
self.AddPage(new_page, hostname or self.get_next_hostname())
|
|
self.SetSelection(self.GetPageCount() - 1)
|
|
return new_page
|
|
|
|
def get_next_hostname(self, suggest=None):
|
|
prefix = "compute-"
|
|
new_suggest = suggest or 0
|
|
|
|
for existing in range(self.GetPageCount()):
|
|
if prefix + str(new_suggest) in self.GetPageText(existing):
|
|
new_suggest = self.get_next_hostname(suggest=new_suggest + 1)
|
|
|
|
if suggest:
|
|
prefix = ""
|
|
return prefix + str(new_suggest)
|
|
|
|
def to_xml(self):
|
|
"""Create the complete XML and allow user to save
|
|
"""
|
|
xml = "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n" \
|
|
"<hosts version=\"" + TiS_VERSION + "\">\n"
|
|
for index in range(self.GetPageCount()):
|
|
try:
|
|
xml += self.GetPage(index).to_xml()
|
|
except Exception as ex:
|
|
wx.LogError("Error on page number %s: %s" %
|
|
(index + 1, ex.message))
|
|
return
|
|
xml += "</hosts>"
|
|
|
|
writer = wx.FileDialog(self,
|
|
message="Save Host XML File",
|
|
defaultDir=filedir or "",
|
|
defaultFile=filename or "TiS_hosts.xml",
|
|
wildcard="XML file (*.xml)|*.xml",
|
|
style=wx.FD_SAVE,
|
|
)
|
|
|
|
if writer.ShowModal() == wx.ID_CANCEL:
|
|
return
|
|
|
|
# Write the XML file to disk
|
|
try:
|
|
with open(writer.GetPath(), "wb") as f:
|
|
f.write(xml.encode('utf-8'))
|
|
except IOError:
|
|
wx.LogError("Error writing hosts xml file '%s'." %
|
|
writer.GetPath())
|
|
|
|
|
|
class HostGUI(wx.Frame):
|
|
def __init__(self):
|
|
wx.Frame.__init__(self, None, wx.ID_ANY,
|
|
"Titanium Cloud Host File Creator v" + TiS_VERSION,
|
|
size=WINDOW_SIZE)
|
|
self.panel = wx.Panel(self)
|
|
|
|
self.sizer = wx.BoxSizer(wx.VERTICAL)
|
|
self.book = HostBook(self.panel)
|
|
self.sizer.Add(self.book, 1, wx.ALL | wx.EXPAND, 5)
|
|
self.panel.SetSizer(self.sizer)
|
|
set_icons(self)
|
|
|
|
menu_bar = wx.MenuBar()
|
|
|
|
# File
|
|
file_menu = wx.Menu()
|
|
import_item = wx.MenuItem(file_menu, IMPORT_ID, '&Import')
|
|
file_menu.AppendItem(import_item)
|
|
export_item = wx.MenuItem(file_menu, EXPORT_ID, '&Export')
|
|
file_menu.AppendItem(export_item)
|
|
menu_bar.Append(file_menu, '&File')
|
|
self.Bind(wx.EVT_MENU, self.on_import, id=IMPORT_ID)
|
|
self.Bind(wx.EVT_MENU, self.on_export, id=EXPORT_ID)
|
|
|
|
self.SetMenuBar(menu_bar)
|
|
self.Layout()
|
|
self.SetMinSize(WINDOW_SIZE)
|
|
self.Show()
|
|
|
|
def on_import(self, e):
|
|
global BULK_ADDING
|
|
try:
|
|
BULK_ADDING = True
|
|
msg = ""
|
|
|
|
reader = wx.FileDialog(self,
|
|
"Import Existing Titanium Cloud Host File",
|
|
"", "", "XML file (*.xml)|*.xml",
|
|
wx.FD_OPEN | wx.FD_FILE_MUST_EXIST)
|
|
|
|
if reader.ShowModal() == wx.ID_CANCEL:
|
|
return
|
|
|
|
# Read in the config file
|
|
try:
|
|
with open(reader.GetPath(), 'rb') as f:
|
|
contents = f.read()
|
|
root = ET.fromstring(contents)
|
|
except Exception as ex:
|
|
wx.LogError("Cannot parse host file, Error: %s." % ex)
|
|
return
|
|
|
|
# Check version of host file
|
|
if root.get('version', "") != TiS_VERSION:
|
|
msg += "Warning: This file was created using tools for a " \
|
|
"different version of Titanium Cloud than this tool " \
|
|
"was designed for (" + TiS_VERSION + ")"
|
|
|
|
for idx, xmlhost in enumerate(root.findall('host')):
|
|
hostname = None
|
|
name_elem = xmlhost.find('hostname')
|
|
if name_elem is not None:
|
|
hostname = name_elem.text
|
|
new_host = self.book.new_page()
|
|
self.book.GetSelection()
|
|
try:
|
|
for attr in HOST_XML_ATTRIBUTES:
|
|
elem = xmlhost.find(attr)
|
|
if elem is not None and elem.text:
|
|
# Enable and display bm section if used
|
|
if attr == 'bm_type' and elem.text:
|
|
new_host.set_field("uses_bm", "Y")
|
|
handle_sub_show(
|
|
new_host.fieldgroup[1],
|
|
new_host.fieldgroup[1]['uses_bm'].shows,
|
|
True)
|
|
new_host.Layout()
|
|
|
|
# Basic field setting
|
|
new_host.set_field(attr, elem.text)
|
|
|
|
# Additional functionality for special fields
|
|
if attr == 'personality':
|
|
# Update hostname visibility and page title
|
|
new_host.on_personality(None, elem.text)
|
|
|
|
# Special handling for presence of power_on element
|
|
if attr == 'power_on' and elem is not None:
|
|
new_host.set_field(attr, "Y")
|
|
|
|
new_host.validate()
|
|
except Exception as ex:
|
|
if msg:
|
|
msg += "\n"
|
|
msg += "Warning: Added host %s has a validation error, " \
|
|
"reason: %s" % \
|
|
(hostname or ("with index " + str(idx)),
|
|
ex.message)
|
|
# No longer delete hosts with validation errors,
|
|
# The user can fix them up before exporting
|
|
# self.book.DeletePage(new_index)
|
|
|
|
if msg:
|
|
wx.LogWarning(msg)
|
|
finally:
|
|
BULK_ADDING = False
|
|
self.Layout()
|
|
|
|
def on_export(self, e):
|
|
# Do a validation of current page first
|
|
index = self.book.GetSelection()
|
|
try:
|
|
if index != -1:
|
|
self.book.GetPage(index).validate()
|
|
except Exception as ex:
|
|
wx.LogError("Error on page: " + ex.message)
|
|
return
|
|
|
|
# Check for hostname conflicts
|
|
hostnames = []
|
|
for existing in range(self.book.GetPageCount()):
|
|
hostname = self.book.GetPage(
|
|
existing).fieldgroup[0]['hostname'].get_value()
|
|
if hostname in hostnames:
|
|
wx.LogError("Cannot export, duplicate hostname '%s'" %
|
|
hostname)
|
|
return
|
|
# Ignore multiple None hostnames
|
|
elif hostname:
|
|
hostnames.append(hostname)
|
|
|
|
self.book.to_xml()
|
|
|
|
|
|
def main():
|
|
app = wx.App(0) # Start the application
|
|
HostGUI()
|
|
app.MainLoop()
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|