# addnetwork.py - Copyright (C) 2009 Red Hat, Inc. # Written by Darryl L. Pierce # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; version 2 of the License. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, # MA 02110-1301, USA. A copy of the GNU General Public License is # also available at http://www.gnu.org/copyleft/gpl.html. from snack import Checkbox from snack import Entry from snack import Label from snack import RadioBar from IPy import IP import logging import re from vmmconfigscreen import VmmTuiConfigScreen from networkconfig import NetworkConfig NETWORK_NAME_PAGE = 1 IPV4_ADDRESS_PAGE = 2 PUBLIC_NETWORK_ALERT_PAGE = 3 NETWORK_DETAILS_PAGE = 4 DHCP_RANGE_PAGE = 5 NETWORK_TYPE_PAGE = 6 SELECT_PHYSICAL_NETWORK_PAGE = 7 SUMMARY_PAGE = 8 class AddNetworkConfigScreen(VmmTuiConfigScreen): def __init__(self): VmmTuiConfigScreen.__init__(self, "Create A Virtual Network Interface") self.__config = NetworkConfig() self.__end_address = None self.__start_address = None self.__name = None self.__isolated_network = None self.__physical_devices = None self.__ipv4_address = None def get_elements_for_page(self, screen, page): if page is NETWORK_NAME_PAGE: return self.get_network_name_page(screen) elif page is IPV4_ADDRESS_PAGE: return self.get_ipv4_address_page(screen) elif page is PUBLIC_NETWORK_ALERT_PAGE: return self.get_public_network_alert_page(screen) elif page is NETWORK_DETAILS_PAGE: return self.get_network_details_page(screen) elif page is DHCP_RANGE_PAGE: return self.get_dhcp_range_page(screen) elif page is NETWORK_TYPE_PAGE: return self.get_network_type_page(screen) elif page is SELECT_PHYSICAL_NETWORK_PAGE: return self.get_select_physical_network_page(screen) elif page is SUMMARY_PAGE: return self.get_summary_page(screen) def validate_input(self, page, errors): if page is NETWORK_NAME_PAGE: if len(self.__name.value()) > 0: if re.match("^[a-zA-Z0-9_]*$", self.__name.value()): return True else: errors.append("The network name can only contain letters, numbers and the underscore, and no spaces.") else: errors.append("Network name must be non-blank and less than 50 characters") elif page is IPV4_ADDRESS_PAGE: if len(self.__ipv4_address.value()) > 0: try: self.__config.set_ipv4_address(self.__ipv4_address.value()) return True except Exception, error: errors.append("The network address could not be understood: %s" % str(error)) else: errors.append("Network must be entered in the format 1.2.3.4/8") elif page is PUBLIC_NETWORK_ALERT_PAGE: return True elif page is NETWORK_DETAILS_PAGE: return True elif page is DHCP_RANGE_PAGE: try: if len(self.__start_address.value()) > 0 and len(self.__end_address.value()) > 0: start = IP(self.__start_address.value(), ) end = IP(self.__end_address.value()) if not self.__config.is_bad_address(start) and not self.__config.is_bad_address(end): return True else: errors.append("Start and/or end address are outside of the choosen network.") else: errors.append("Start and end address must be non-blank.") except Exception, error: logging.error(str(error)) errors.append("The start and/or end addresses could not be understood.") elif page is NETWORK_TYPE_PAGE: return True elif page is SELECT_PHYSICAL_NETWORK_PAGE: return True elif page is SUMMARY_PAGE: return True return False def process_input(self, page): if page is NETWORK_NAME_PAGE: self.__config.set_name(self.__name.value()) elif page is DHCP_RANGE_PAGE: self.__config.set_ipv4_start_address(self.__start_address.value()) self.__config.set_ipv4_end_address(self.__end_address.value()) elif page is NETWORK_TYPE_PAGE: self.__config.set_isolated_network(self.__isolated_network.value()) elif page is SELECT_PHYSICAL_NETWORK_PAGE: self.__config.set_physical_device(self.__physical_devices.getSelection()) elif page is SUMMARY_PAGE: self.get_libvirt().define_network(self.__config) self.set_finished() def get_next_page(self, page): if page is IPV4_ADDRESS_PAGE: if self.__config.is_public_ipv4_network(): return PUBLIC_NETWORK_ALERT_PAGE else: return NETWORK_DETAILS_PAGE if page is NETWORK_TYPE_PAGE: if self.__config.is_isolated_network(): return SUMMARY_PAGE else: return SELECT_PHYSICAL_NETWORK_PAGE return VmmTuiConfigScreen.get_next_page(self, page) def get_back_page(self, page): if page is NETWORK_DETAILS_PAGE: return IPV4_ADDRESS_PAGE if page is SUMMARY_PAGE: if self.__config.is_isolated_network(): return NETWORK_TYPE_PAGE else: return SELECT_PHYSICAL_NETWORK_PAGE return VmmTuiConfigScreen.get_back_page(self, page) def page_has_finish(self, page): if page is SUMMARY_PAGE: return True return False def page_has_next(self, page): if page < SUMMARY_PAGE: return True def page_has_back(self, page): if page > NETWORK_NAME_PAGE: return True return False def get_network_name_page(self, screen): ignore = screen self.__name = Entry(50, self.__config.get_name()) fields = [] fields.append(("Network name", self.__name)) return [Label("Please choose a name for your virtual network"), self.create_grid_from_fields(fields)] def get_ipv4_address_page(self, screen): ignore = screen self.__ipv4_address = Entry(18, self.__config.get_ipv4_address()) fields = [] fields.append(("Network", self.__ipv4_address)) return [Label("You will need to choose an IPv4 address space for the virtual network"), self.create_grid_from_fields(fields)] def get_network_details_page(self, screen): ignore = screen fields = [] fields.append(("Network details", None)) fields.append(("Network", self.__config.get_ipv4_address())) fields.append(("Netmask", self.__config.get_ipv4_netmask())) fields.append(("Broadcast", self.__config.get_ipv4_broadcast())) fields.append(("Gateway", self.__config.get_ipv4_gateway())) fields.append(("Size", "%i" % self.__config.get_ipv4_max_addresses())) fields.append(("Type", self.__config.get_ipv4_network_type())) return [self.create_grid_from_fields(fields)] def get_public_network_alert_page(self, screen): ignore = screen return [Label("Check Network Address"), Label("The network should normally use a private IPv4 address."), Label("Use this non-private address anyway?")] def get_dhcp_range_page(self, screen): ignore = screen self.__start_address = Entry(15, self.__config.get_ipv4_start_address()) self.__end_address = Entry(15, self.__config.get_ipv4_end_address()) fields = [] fields.append(("Select the DHCP range", None)) fields.append(("Start", self.__start_address)) fields.append(("End", self.__end_address)) return [Label("Selecting The DHCP Range"), self.create_grid_from_fields(fields), Label("TIP: Unless you wish to reserve some addresses to allow static network"), Label("configuration in virtual machines, these paraemters can be left with"), Label("their default values.")] def get_network_type_page(self, screen): ignore = screen self.__isolated_network = Checkbox("Isolated virtual network", self.__config.is_isolated_network()) fields = [] fields.append((self.__isolated_network, None)) return [Label("Please indicate whether this virtual network should be"), Label("connected to the physical network."), self.create_grid_from_fields(fields)] def get_select_physical_network_page(self, screen): ignore = screen devices = [] devices.append(["NAT to any physical device", "", self.__config.get_physical_device() == ""]) for device in self.get_libvirt().list_network_devices(): devices.append(["NAT to physical device %s" % device, device, self.__config.get_physical_device() == device]) self.__physical_devices = RadioBar(screen, (devices)) fields = [] fields.append(("Forward to physical network", self.__physical_devices)) return [Label("Connecting To Physical Network"), self.create_grid_from_fields(fields)] def get_summary_page(self, screen): ignore = screen fields = [] fields.append(("Summary", None)) fields.append(("Network name", self.__config.get_name())) fields.append(("IPv4 network", None)) fields.append(("Network", self.__config.get_ipv4_address())) fields.append(("Gateway", self.__config.get_ipv4_gateway())) fields.append(("Netmask", self.__config.get_ipv4_netmask())) fields.append(("DHCP", None)) fields.append(("Start address", self.__config.get_ipv4_start_address())) fields.append(("End address", self.__config.get_ipv4_end_address())) fields.append(("Forwarding", None)) forwarding = "Isolated virtual network" if not self.__config.is_isolated_network(): forwarding = "NAT to %s" % self.__config.get_physical_device_text() fields.append(("Connectivity", forwarding)) return [Label("Ready To Create Network"), self.create_grid_from_fields(fields)] def AddNetwork(): screen = AddNetworkConfigScreen() screen.start()