def __init__(self, main_win, screen=None): super(NSDomain, self).__init__(main_win) self.intro = \ _("Specify the domain for the NIS or LDAP name server. " "Use the domain name's exact capitalization and " "punctuation.") self.title = _("Domain Name:")
def _show(self): ''' called upon display of a screen ''' super(NSDNSChooser, self)._show() y_loc = self._paint_opening() LOGGER.debug(self.nameservice) # allow the user to choose DNS or not ynlist = [_('Configure DNS'), _('Do not configure DNS')] area = WindowArea(x_loc=0, y_loc=y_loc, scrollable_lines=len(ynlist) + 1) area.lines = self.win_size_y - (y_loc + 1) area.columns = self.win_size_x self.scroll_region_dns = ScrollWindow(area, window=self.center_win) # add the entries to the screen for idx, yon in enumerate(ynlist): win_area = WindowArea(1, textwidth(yon) + 1, idx, INDENT) ListItem(win_area, window=self.scroll_region_dns, text=yon, data_obj=yon) # finalize positioning self.main_win.do_update() self.center_win.activate_object(self.scroll_region_dns) self.scroll_region_dns.activate_object_force(self.cur_dnschoice_idx, force_to_top=True)
def validate_username(user_str, blank_ok=True): '''Ensure username complies with following rules - username can contain characters from set of alphabetic characters, numeric characters, period (.), underscore (_), and hyphen (-). - username starts with a letter. Raises UsernameInvalid if provided user name is not valid, otherwise returns True''' # # consider empty string as a valid value, since it serves # as an indicator that user account will not be created # if blank_ok and not user_str: return True if not user_str: raise UsernameInvalid(_("Username must not be blank")) # verify that username starts with alphabetic character if not user_str[0].isalpha(): raise UsernameInvalid(_("Username must start with a letter")) # verify that username contains only allowed characters if re.search(r"^[a-zA-Z][\w\-.]*$", user_str) is None: raise UsernameInvalid(_("Invalid character")) return True
def _show(self): super(NSNISAuto, self)._show() if self.nameservice.nameservice != 'NIS': raise SkipException y_loc = self._paint_opening() y_loc += self.center_win.add_paragraph(self.intro2, y_loc) y_loc += 1 ynlist = [_('Find one'), _('Specify one')] area = WindowArea(x_loc=0, y_loc=y_loc, scrollable_lines=len(ynlist) + 1) area.lines = self.win_size_y - (y_loc + 1) area.columns = self.win_size_x self.scroll_region = ScrollWindow(area, window=self.center_win) y_loc += 1 # blank line # add the entries to the screen for idx, yon in enumerate(ynlist): y_loc += 1 win_area = WindowArea(lines=1, columns=textwidth(yon) + 1, y_loc=idx, x_loc=INDENT) ListItem(win_area, window=self.scroll_region, text=yon, data_obj=yon) self.main_win.do_update() self.center_win.activate_object(self.scroll_region) self.scroll_region.activate_object_force(self.cur_nisnschoice_idx, force_to_top=True) y_loc += 1 # blank line self.center_win.add_paragraph(self.intro3, y_loc)
def validate_password(password): '''validates the password entered''' # check the length if not password or len(password) <= 0: raise PasswordInvalid(_('Password must be entered.')) elif len(password) < 6: raise PasswordInvalid(_('Password must contain at least 6 ' 'characters.')) else: # check that the password contains characters # and digit or special characters has_char = has_digit = has_special = False for char in password: if char.isalpha(): has_char = True elif char.isdigit(): has_digit = True else: has_special = True if not has_char: raise PasswordInvalid(_('Password must contain 1 alphabetical ' 'character.')) elif not has_digit and not has_special: raise PasswordInvalid(_('Password must contain 1 digit/special ' 'character.')) return True
def __init__(self, main_win, screen=None): super(NSDNSSearch, self).__init__(main_win) self.intro = \ _("Enter a list of domains to be searched when a DNS " "query is made. If no domain is entered, only the " "DNS domain chosen for this system will be searched.") self.title = _("Search domain:")
def __init__(self, main_win, screen=None): super(NSLDAPProxyBindInfo, self).__init__(main_win) self.intro = \ _("Specify the LDAP proxy bind distinguished name and the " "LDAP proxy bind password. The network administrator " "can provide this information.") self.title = _("Proxy bind distinguished name:") self.title2 = _("Proxy bind password:")
def minute_valid(minute_edit): '''Check validity of minute as each char entered''' minute_str = minute_edit.get_text() LOGGER.log(LOG_LEVEL_INPUT, "validating minute, text=%s=", minute_str) if minute_str and not minute_str.isdigit(): raise UIMessage(_("Minute must be numeric")) if len(minute_str) >= 2 and (int(minute_str) > 59): raise UIMessage(_("Minute out of range")) return True
def minute_valid(minute_edit): '''Check validity of minute as each char entered''' minute_str = minute_edit.get_text() LOGGER.log(LOG_LEVEL_INPUT, "validating minute, text=%s=", minute_str) if minute_str and not minute_str.isdigit(): raise UIMessage(_("Minute must be numeric")) if len(minute_str) >= 2 and (int(minute_str) > 59): raise UIMessage(_("Minute out of range")) return True
def hour_valid(hour_edit): '''Check validity of hour as each char entered''' hour_str = hour_edit.get_text() LOGGER.log(LOG_LEVEL_INPUT, "validating hour, text=%s=", hour_str) if hour_str and not hour_str.isdigit(): raise UIMessage(_("Hour must be numeric")) if len(hour_str) >= 2 and (int(hour_str) > 23): LOGGER.debug("hour out of range, =%s", hour_str) raise UIMessage(_("Hour out of range")) return True
def __init__(self, main_win, screen=None): super(NSNISAuto, self).__init__(main_win) self.intro = \ _("Specify how to find a name server for this system.") self.intro2 = \ _("Either let the software search for a name server, " "or specify a name server in the following screen. ") self.intro3 = \ _("The software can find a name server only if that " "server is on the local subnet.")
def hour_valid(hour_edit): '''Check validity of hour as each char entered''' hour_str = hour_edit.get_text() LOGGER.log(LOG_LEVEL_INPUT, "validating hour, text=%s=", hour_str) if hour_str and not hour_str.isdigit(): raise UIMessage(_("Hour must be numeric")) if len(hour_str) >= 2 and (int(hour_str) > 23): LOGGER.debug("hour out of range, =%s", hour_str) raise UIMessage(_("Hour out of range")) return True
def __init__(self, main_win, screen=None): global LOGGER if LOGGER is None: LOGGER = logging.getLogger(INSTALL_LOGGER_NAME + ".sysconfig") super(TimeZone, self).__init__(main_win) self.sys_info = None if screen is None: self.screen = TimeZone.TIMEZONE else: self.screen = screen self.tz_tuples = None self.tz_list = None self.cur_timezone_idx = 0 self.cur_timezone_parent = None self.last_timezone_parent = None self.cur_continent = None self.cur_country = None self.scroll_region = None self.last_country = None self.last_continent = None if self.screen == TimeZone.TIMEZONE: self.header_text = _("Time Zone") self.intro = _("Select your time zone.") self.title = _("Time Zones") elif self.screen == TimeZone.LOCATIONS: self.header_text = _("Time Zone: Locations") self.intro = _("Select the location that contains your time zone.") self.title = _("Locations") self.help_data = (None, None) else: self.header_text = _("Time Zone: Regions") self.intro = _("Select the region that contains your time zone.") self.title = _("Regions") self.help_data = (None, None)
def __init__(self, main_win, screen=None): global LOGGER if LOGGER is None: LOGGER = logging.getLogger(INSTALL_LOGGER_NAME + ".sysconfig") super(TimeZone, self).__init__(main_win) self.sys_info = None if screen is None: self.screen = TimeZone.TIMEZONE else: self.screen = screen self.tz_tuples = None self.tz_list = None self.cur_timezone_idx = 0 self.cur_timezone_parent = None self.last_timezone_parent = None self.cur_continent = None self.cur_country = None self.scroll_region = None self.last_country = None self.last_continent = None if self.screen == TimeZone.TIMEZONE: self.header_text = _("Time Zone") self.intro = _("Select your time zone.") self.title = _("Time Zones") elif self.screen == TimeZone.LOCATIONS: self.header_text = _("Time Zone: Locations") self.intro = _("Select the location that contains your time zone.") self.title = _("Locations") self.help_data = (None, None) else: self.header_text = _("Time Zone: Regions") self.intro = _("Select the region that contains your time zone.") self.title = _("Regions") self.help_data = (None, None)
def validate(self): validate_ldap_profile(self.ldap_profile.get_text()) ldap_ip = self.ldap_ip.get_text() if self.nameservice.dns: validate_host_or_ip(ldap_ip) else: validate_ip(ldap_ip) if not self.ldap_profile.get_text(): raise UIMessage(_("The LDAP profile name cannot be blank.")) if not ldap_ip: raise UIMessage(_("The LDAP server IP address cannot be blank."))
def __init__(self, main_win, screen=None): super(NSLDAPProxyBindInfo, self).__init__(main_win) self.intro = \ _("Specify the LDAP proxy bind distinguished name and the " "LDAP proxy bind password. The network administrator " "can provide this information.") self.title = _("Proxy bind distinguished name:") # temporary code until ns1_convert method is integrated if hasattr(nss.nssscf, 'ns1_convert'): self.title2 = _("Proxy bind password:"******"Encrypted proxy bind password:")
def validate_ldap_profile(profile): ''' given an LDAP profile string, validate it Arg: profile - LDAP profile string Raises: UIMessage on failure ''' if not profile: raise UIMessage(_("The LDAP profile name cannot be blank.")) emsg = _("Whitespace characters and quotation marks are not allowed in " "LDAP profile names.") for cha in profile: if cha in string.whitespace or cha in "'\"": raise UIMessage(emsg)
def validate(self): '''Check for mismatched passwords, bad login names, etc.''' # Note: the Root and User password fields may be filled with # asterisks if the user previously invoked this screen. Therefore, # if not empty we check their modified flags before validating the # contents. if self.root_pass_edit.modified: root_pass_set = bool(self.root_pass_edit.get_text()) else: root_pass_set = (self.root.passlen != 0) # Root password is mandatory and, if modified, must be valid if not root_pass_set or self.root_pass_edit.modified: pass_valid(self.root_pass_edit, msg_prefix=UserScreen.ROOT_LABEL + " ") # Root password confirmation must match original Root password if not self.root_pass_edit.compare(self.root_confirm_edit): raise UIMessage(_("Root passwords don't match")) # User account disabled, skip related validation steps. if not self.show_user_account: return if self.user_pass_edit.modified: user_pass_set = bool(self.user_pass_edit.get_text()) else: user_pass_set = (self.user.passlen != 0) login_name = self.username_edit.get_text() LOGGER.debug("login_name=%s", login_name) real_name = self.real_name_edit.get_text() LOGGER.debug("real_name=%s", real_name) # Username (if specified) must be valid login_valid(self.username_edit) if login_name: # If Username was entered then: # - User password is mandatory and, if modified, must be valid # - User password confirmation must match original User password if not user_pass_set or self.user_pass_edit.modified: pass_valid(self.user_pass_edit, msg_prefix=UserScreen.USER_PASS_LABEL + " ") if not self.user_pass_edit.compare(self.user_confirm_edit): raise UIMessage(_("User passwords don't match")) else: # If either Real name or User password are specified then # Username must also be specified if real_name or user_pass_set: raise UIMessage( _("Enter username or clear all user " "account fields"))
def validate(self): '''Check for mismatched passwords, bad login names, etc.''' # Note: the Root and User password fields may be filled with # asterisks if the user previously invoked this screen. Therefore, # if not empty we check their modified flags before validating the # contents. if self.root_pass_edit.modified: root_pass_set = bool(self.root_pass_edit.get_text()) else: root_pass_set = (self.root.passlen != 0) # Root password is mandatory and, if modified, must be valid if not root_pass_set or self.root_pass_edit.modified: pass_valid(self.root_pass_edit, msg_prefix=UserScreen.ROOT_LABEL + " ") # Root password confirmation must match original Root password if not self.root_pass_edit.compare(self.root_confirm_edit): raise UIMessage(_("Root passwords don't match")) # User account disabled, skip related validation steps. if not self.show_user_account: return if self.user_pass_edit.modified: user_pass_set = bool(self.user_pass_edit.get_text()) else: user_pass_set = (self.user.passlen != 0) login_name = self.username_edit.get_text() LOGGER.debug("login_name=%s", login_name) real_name = self.real_name_edit.get_text() LOGGER.debug("real_name=%s", real_name) # Username (if specified) must be valid login_valid(self.username_edit) if login_name: # If Username was entered then: # - User password is mandatory and, if modified, must be valid # - User password confirmation must match original User password if not user_pass_set or self.user_pass_edit.modified: pass_valid(self.user_pass_edit, msg_prefix=UserScreen.USER_PASS_LABEL + " ") if not self.user_pass_edit.compare(self.user_confirm_edit): raise UIMessage(_("User passwords don't match")) else: # If either Real name or User password are specified then # Username must also be specified if real_name or user_pass_set: raise UIMessage(_("Enter username or clear all user " "account fields"))
def inc_validate_nowhite_nospecial(edit_field, etext='<empty>'): '''Incrementally validate EditField as the user enters it Args: edit_field - EditField object for validation etext - text to paste upon error Raises: UIMessage upon finding whitespace and special characters other than hyphens and underscores ''' profile = edit_field.get_text() if not profile: raise UIMessage(_("The %s cannot be blank.") % etext) global NO_WHITE_NO_SPECIAL_PATTERN if not NO_WHITE_NO_SPECIAL_PATTERN.match(profile.upper()): raise UIMessage(_('Invalid character for %s.') % etext)
def get_networks(self): '''Build a summary of the networks in the install_profile, returned as a list of strings ''' network_summary = [] # hostname belongs to 'identity' group if configure_group(SC_GROUP_IDENTITY): network_summary.append(_(" Computer name: %s") % self.sysconfig.system.hostname) if not configure_group(SC_GROUP_NETWORK): return network_summary nic = self.sysconfig.nic if nic.type == NetworkInfo.AUTOMATIC: network_summary.append(_(" Network Configuration: Automatic")) elif nic.type == NetworkInfo.NONE: network_summary.append(_(" Network Configuration: None")) elif nic.type == NetworkInfo.FROMGZ: network_summary.append(_(" Network Configuration:" " Mandated from global zone")) elif nic.type == NetworkInfo.MANUAL: network_summary.append(_(" Manual Configuration: %s") % NetworkInfo.get_nic_desc(nic.nic_iface)) network_summary.append(_("IP Address: %s") % nic.ip_address) network_summary.append(_("Netmask: %s") % nic.netmask) if nic.gateway: network_summary.append(_("Router: %s") % nic.gateway) return network_summary
def get_networks(self): '''Build a summary of the networks in the install_profile, returned as a list of strings ''' network_summary = [] # hostname belongs to 'identity' group if configure_group(SC_GROUP_IDENTITY): network_summary.append(_(" Computer name: %s") % self.sysconfig.system.hostname) if not configure_group(SC_GROUP_NETWORK): return network_summary nic = self.sysconfig.nic if nic.type == NetworkInfo.AUTOMATIC: network_summary.append(_(" Network Configuration: Automatic")) elif nic.type == NetworkInfo.NONE: network_summary.append(_(" Network Configuration: None")) elif nic.type == NetworkInfo.FROMGZ: network_summary.append(_(" Network Configuration:" " Mandated from global zone")) elif nic.type == NetworkInfo.MANUAL: network_summary.append(_(" Manual Configuration: %s") % NetworkInfo.get_nic_desc(nic.nic_iface)) network_summary.append(_("IP Address: %s") % nic.ip_address) network_summary.append(_("Netmask: %s") % nic.netmask) if nic.gateway: network_summary.append(_("Router: %s") % nic.gateway) return network_summary
def validate_ldap_proxy_bind_psw(proxy_psw): ''' given an LDAP proxy bind password string, validate it Arg: profile - LDAP proxy bind password Raises: UIMessage on failure ''' if not proxy_psw: raise UIMessage(_("The LDAP proxy bind password may not be blank.")) for cha in proxy_psw: if cha in string.whitespace: raise UIMessage(_("The LDAP proxy bind password may not contain " "whitespace characters.")) if cha in "'\"": raise UIMessage(_("The LDAP proxy bind password may not contain " "quotation marks."))
def incremental_validate_domain(edit_field): '''Incrementally validate EditField as a domain as the user enters it Arg: edit_field - EditField object with domain to validate Raises: UIMessage if invalid character typed ''' domain = edit_field.get_text() for label in domain.split('.'): if len(label) > 63: raise UIMessage( _("Domain labels must have less than 64 characters")) if label.startswith('-'): raise UIMessage(_('A domain label may not begin with a hyphen.')) global INCREMENTAL_DOMAIN_LABEL_PATTERN if not INCREMENTAL_DOMAIN_LABEL_PATTERN.match(label.upper()): raise UIMessage(_('Invalid character for domain name.'))
def get_users(self): '''Build a summary of the user information, and return it as a list of strings ''' root = self.sysconfig.users.root primary = self.sysconfig.users.user user_summary = [] if not root.password: user_summary.append(_(" Warning: No root password set")) if primary.login_name: user_summary.append(_(" Username: %s") % primary.login_name) else: user_summary.append(_(" No user account")) return user_summary
def validate(self): '''Ensure hostname is set and a network type is chosen (unless no NICs are present) ''' hostname_text = self.hostname.get_text() if not hostname_text: raise UIMessage(_("A Hostname is required.")) if len(hostname_text) < 2: raise UIMessage(_("A Hostname must be at least two characters.")) if self.configure_network and self.have_nic and self.nic_info.type is None: item_key = self.center_win.get_active_object().item_key if item_key not in self.net_type_dict: raise UIMessage(_("Select the wired network configuration: " "Automatically, Manually, or None."))
def validate_ldap_proxy_dn(proxy_dn): ''' given an LDAP proxy distinguished name string, validate it Arg: profile - LDAP proxy distinguished name Raises: UIMessage on failure ''' if not proxy_dn: raise UIMessage(_( "The LDAP proxy bind distinguished name may not be blank.")) for cha in proxy_dn: if cha in string.whitespace: raise UIMessage(_("The LDAP proxy bind distinguished name may not " "contain whitespace characters.")) if cha in "'\"": raise UIMessage(_("The LDAP proxy bind distinguished name may not " "contain quotation marks."))
def validate(self): '''Ensure hostname is set and a network type is chosen (unless no NICs are present) ''' hostname_text = self.hostname.get_text() if not hostname_text: raise UIMessage(_("A Hostname is required.")) if len(hostname_text) < 2: raise UIMessage(_("A Hostname must be at least two characters.")) if self.configure_network and self.have_nic: item_key = self.center_win.get_active_object().item_key if item_key not in self.net_type_dict: raise UIMessage(_("Select the wired network configuration: " "Automatically, Manually, or None."))
def get_users(self): '''Build a summary of the user information, and return it as a list of strings ''' root = self.sysconfig.users.root primary = self.sysconfig.users.user user_summary = [] if not root.password: user_summary.append(_(" Warning: No root password set")) if primary.login_name: user_summary.append(_(" Username: %s") % primary.login_name) else: user_summary.append(_(" No user account")) return user_summary
def validate(self): '''Verify each of the edit fields''' year_value = self.year_edit.get_text() month_value = self.month_edit.get_text() day_value = self.day_edit.get_text() hour_value = self.hour_edit.get_text() minute_value = self.minute_edit.get_text() LOGGER.debug("year_value=%s", year_value) LOGGER.debug("month_value=%s", month_value) LOGGER.debug("day_value=%s", day_value) LOGGER.debug("hour_value=%s", hour_value) LOGGER.debug("minute_value=%s", minute_value) had_err = False if not self.year_edit.run_on_exit(): had_err = True if not self.month_edit.run_on_exit(): had_err = True if not self.day_edit.run_on_exit(): had_err = True if not self.hour_edit.run_on_exit(): had_err = True if not self.minute_edit.run_on_exit(): had_err = True if had_err: raise UIMessage(_("Invalid date/time. See errors above."))
def _show(self): super(NSLDAPProxyBindInfo, self)._show() if self.nameservice.nameservice != 'LDAP': raise SkipException if self.nameservice.ldap_proxy_bind == \ NameServiceInfo.LDAP_CHOICE_NO_PROXY_BIND: raise SkipException y_loc = self._paint_opening() y_loc += 1 # blank line self.center_win.add_text(self.title, y_loc, INDENT) y_loc += 1 # edit field on following line since it should be big cols = self.win_size_x - INDENT - 2 area = WindowArea(1, cols, y_loc, INDENT + 2, scrollable_columns=MAXDNLEN + 1) self.ldap_pb_dn = EditField(area, window=self.center_win, text=self.nameservice.ldap_pb_dn, error_win=self.main_win.error_line) # in case of error, tell user what is being validated self.ldap_pb_dn.validate_kwargs['etext'] = _('distinguished name') y_loc += 2 # blank line titlelen = textwidth(self.title2) self.center_win.add_text(self.title2, y_loc, NameService.SCROLL_SIZE) cols = self.win_size_x - titlelen - INDENT - 1 area = WindowArea(1, cols, y_loc, titlelen + INDENT + 1) self.ldap_pb_psw = EditField(area, window=self.center_win, text=self.nameservice.ldap_pb_psw, error_win=self.main_win.error_line, masked=True) self.main_win.do_update() self.center_win.activate_object(self.ldap_pb_dn)
def validate(self): '''Verify each of the edit fields''' year_value = self.year_edit.get_text() month_value = self.month_edit.get_text() day_value = self.day_edit.get_text() hour_value = self.hour_edit.get_text() minute_value = self.minute_edit.get_text() LOGGER.debug("year_value=%s", year_value) LOGGER.debug("month_value=%s", month_value) LOGGER.debug("day_value=%s", day_value) LOGGER.debug("hour_value=%s", hour_value) LOGGER.debug("minute_value=%s", minute_value) had_err = False if not self.year_edit.run_on_exit(): had_err = True if not self.month_edit.run_on_exit(): had_err = True if not self.day_edit.run_on_exit(): had_err = True if not self.hour_edit.run_on_exit(): had_err = True if not self.minute_edit.run_on_exit(): had_err = True if had_err: raise UIMessage(_("Invalid date/time. See errors above."))
def __init__(self, main_win): super(NSAltChooser, self).__init__(main_win) self.intro = \ _("From the list below, select one name service to be " "used by this system. If the desired name service is not " "listed, select None. The selected name service may be " "used in conjunction with DNS.")
class NSNISIP(NameService): HEADER_TEXT = _("NIS Name Server Information") HELP_DATA = (SCI_HELP + "/%s/nis.txt", HEADER_TEXT) def __init__(self, main_win): super(NSNISIP, self).__init__(main_win) def _show(self): super(NSNISIP, self)._show() LOGGER.info("self.nameservice: %s" % self.nameservice) if self.nameservice.nameservice != 'NIS': raise SkipException if self.nameservice.nis_auto == NameServiceInfo.NIS_CHOICE_AUTO: raise SkipException if self.nameservice.dns: self.intro = \ _("Enter the host name or IP address of the name server. " "A host name must have at least 2 characters and can be " "alphanumeric and can contain hyphens. IP " "addresses must contain four sets of numbers separated " "by periods (for example, 129.200.9.1).") self.title = _("Server's host name or IP address:") else: self.intro = \ _("Enter the IP address of the name server. IP " "addresses must contain four sets of numbers separated " "by periods (for example, 129.200.9.1).") self.title = _("Server's IP address:") y_loc = self._paint_opening() self.center_win.add_text(self.title, y_loc, INDENT) aligned_x_loc = textwidth(self.title) + INDENT + 1 cols = self.win_size_x - aligned_x_loc area = WindowArea(1, cols, y_loc, aligned_x_loc) self.center_win.add_text(self.title, y_loc, INDENT) area = WindowArea(1, cols, y_loc, aligned_x_loc, scrollable_columns=NameService.HOSTNAME_SCREEN_LEN + 1) # create edit field, validating for host name or IP address depending # on whether DNS was selected self.nis_ip = EditField(area, window=self.center_win, text=self.nameservice.nis_ip, error_win=self.main_win.error_line, validate=(incremental_validate_host if self.nameservice.dns else incremental_validate_ip)) self.main_win.do_update() self.center_win.activate_object(self.nis_ip) def validate(self): nis_ip = self.nis_ip.get_text() if self.nameservice.dns: validate_host_or_ip(nis_ip) else: validate_ip(nis_ip) if not nis_ip: raise UIMessage(_("The NIS server IP address cannot be blank.")) def on_change_screen(self): self.nameservice.nis_ip = self.nis_ip.get_text()
def build_summary(self): '''Build a textual summary from solaris_install.sysconfig profile''' if self.sysconfig is None: return "" else: summary_text = [] # display summary only for configured areas # locale and timezone belong to SC_GROUP_LOCATION group if configure_group(SC_GROUP_LOCATION): summary_text.append(self.get_tz_summary()) summary_text.append("") summary_text.append(_("Language: *The following can be changed" " when logging in.")) if self.sysconfig.system.locale is None: self.sysconfig.system.determine_locale() summary_text.append(_(" Default language: %s") % self.sysconfig.system.actual_lang) # keyboard layout belongs to SC_GROUP_KBD group if configure_group(SC_GROUP_KBD): summary_text.append("") summary_text.append(_("Keyboard layout: *The following can be " "changed when logging in.")) summary_text.append(_(" Default keyboard layout: %s") % self.sysconfig.system.keyboard) summary_text.append("") if hasattr(self.sysconfig.system, 'terminal_type'): summary_text.append(_("Terminal type: %s") % self.sysconfig.system.terminal_type) # user/root accounts belong to SC_GROUP_USERS group if configure_group(SC_GROUP_USERS): summary_text.append("") summary_text.append(_("Users:")) summary_text.extend(self.get_users()) # network belongs to SC_GROUP_IDENTITY and SC_GROUP_NETWORK groups if configure_group(SC_GROUP_NETWORK) or \ configure_group(SC_GROUP_IDENTITY): summary_text.append("") summary_text.append(_("Network:")) summary_text.extend(self.get_networks()) if configure_group(SC_GROUP_NS): self._get_nameservice(summary_text) # support configuration if configure_group(SC_GROUP_SUPPORT): summary_text.append("") summary_text.append(_("Support configuration:")) summary_text.extend(self.get_support()) return "\n".join(summary_text)
def hour_on_exit(hour_edit): '''Check hour when exiting field''' hour_str = hour_edit.get_text() LOGGER.debug("hour_on_exit, =%s=", hour_str) if not hour_str: raise UIMessage(_("Hour out of range")) hour_valid(hour_edit) return True
def minute_on_exit(minute_edit): '''Check minute when exiting field''' minute_str = minute_edit.get_text() LOGGER.debug("minute_on_exit, =%s=", minute_str) if not minute_str: raise UIMessage(_("Minute out of range")) minute_valid(minute_edit) return True
def pass_match(pw_field, linked_win=None): '''Make sure passwords match''' if linked_win is None or pw_field.compare(linked_win): return True else: pw_field.clear_text() linked_win.clear_text() raise UIMessage(_("Passwords don't match"))
def validate(self): found = False for field in self.dns_server_list: validate_ip(field.get_text()) if field.get_text(): found = True if not found: raise UIMessage(_("At least one name server must be specified."))
def minute_on_exit(minute_edit): '''Check minute when exiting field''' minute_str = minute_edit.get_text() LOGGER.debug("minute_on_exit, =%s=", minute_str) if not minute_str: raise UIMessage(_("Minute out of range")) minute_valid(minute_edit) return True
def hour_on_exit(hour_edit): '''Check hour when exiting field''' hour_str = hour_edit.get_text() LOGGER.debug("hour_on_exit, =%s=", hour_str) if not hour_str: raise UIMessage(_("Hour out of range")) hour_valid(hour_edit) return True
def pass_match(pw_field, linked_win=None): '''Make sure passwords match''' if linked_win is None or pw_field.compare(linked_win): return True else: pw_field.clear_text() linked_win.clear_text() raise UIMessage(_("Passwords don't match"))
def validate(self): nis_ip = self.nis_ip.get_text() if self.nameservice.dns: validate_host_or_ip(nis_ip) else: validate_ip(nis_ip) if not nis_ip: raise UIMessage(_("The NIS server IP address cannot be blank."))
def hostname_is_valid(edit_field): '''Check hostname for characters other than a-zA-Z0-9 and hyphens''' user_str = edit_field.get_text() if not user_str: return True test_str = user_str.replace(u"-", "a") if not test_str.isalnum(): raise UIMessage(_("The Hostname can only contain letters, numbers, " "and minus signs (-)."))
def year_on_exit(year_edit): '''Check year when exiting field''' year_str = year_edit.get_text() LOGGER.debug("year_on_exit, =%s=", year_str) year_valid(year_edit) if (len(year_str) != 4): LOGGER.debug("on exit year out of range=%s", input) raise UIMessage(_("Year out of range")) return True
def month_on_exit(month_edit): '''Check month when exiting field''' month_str = month_edit.get_text() LOGGER.debug("month_on_exit, =%s=", month_str) month_valid(month_edit) if (len(month_str) == 0 or int(month_str) == 0): LOGGER.debug("on exit month out of range=%s", month_str) raise UIMessage(_("Month out of range")) return True
def day_on_exit(day_edit): '''Check day when exiting field''' day_str = day_edit.get_text() LOGGER.debug("day_on_exit, =%s=", day_str) day_valid(day_edit) if (len(day_str) == 0 or int(day_str) == 0): LOGGER.debug("on exit day out of range=%s", day_str) raise UIMessage(_("Day out of range")) return True
def day_valid(day_edit, month_edit=None, year_edit=None, date_time=None): '''Check validity of day as each char entered''' day_str = day_edit.get_text() LOGGER.log(LOG_LEVEL_INPUT, "validating day, text=%s=", day_str) if not day_str: return True if not day_str.isdigit(): raise UIMessage(_("Day must be numeric")) LOGGER.log(LOG_LEVEL_INPUT, "len = %s, text=%s ", len(day_str), day_str) # When screen first comes up, there is no month/year_edit if (month_edit is None or year_edit is None): return True days_in_month = get_days_in_month(month_edit, year_edit, date_time) if (len(day_str) >= 2): if (int(day_str) > days_in_month or int(day_str) == 0): LOGGER.debug("day out of range, =%s", day_str) raise UIMessage(_("Day out of range")) return True
def month_valid(month_edit, day_edit=None, year_edit=None, date_time=None): '''Check validity of month as each char entered''' if date_time: date_time.month_is_valid = False month_str = month_edit.get_text() LOGGER.log(LOG_LEVEL_INPUT, "validating month, text=%s=", month_str) if not month_str: return True if not month_str.isdigit(): raise UIMessage(_("Month must be numeric")) LOGGER.debug("len = %s, text=%s ", len(month_str), month_str) if len(month_str) >= 2: if (int(month_str) > 12 or int(month_str) == 0): LOGGER.log(LOG_LEVEL_INPUT, "month out of range, =%s", month_str) raise UIMessage(_("Month out of range")) if date_time: date_time.month_is_valid = True if int(month_str) > 0: check_day_range(month_edit, day_edit, year_edit, date_time) return True
def validate(self): '''Verify the syntactical validity of the IP Address fields''' ip_fields = [self.ip_field, self.netmask_field, self.gateway_field] for field in ip_fields: validate_ip(field) if not self.ip_field.get_text(): raise UIMessage(_("IP Address must not be empty")) if not self.netmask_field.get_text(): raise UIMessage(_("Netmask must not be empty")) else: try: netmask = self.netmask_field.get_text() IPAddress.convert_address(netmask, check_netmask=True) except ValueError as err: if err[0] == IPAddress.MSG_NO_LEADING_ZEROS: raise UIMessage(NICConfigure.MSG_NO_LEADING_ZEROS % self.netmask_field.data_obj) raise UIMessage(_("'%s' is not a valid netmask") % netmask)
def incremental_validate_ip(edit_field): '''Incrementally validate the IP Address as the user enters it''' ip_address = edit_field.get_text() if not ip_address: return True try: IPAddress.incremental_check(ip_address) except ValueError as err: if err[0] == IPAddress.MSG_NO_LEADING_ZEROS: raise UIMessage(NICConfigure.MSG_NO_LEADING_ZEROS % edit_field.data_obj) raise UIMessage(_("%s must be of the form xxx.xxx.xxx.xxx") % edit_field.data_obj) return True
def year_valid(year_edit, month_edit=None, day_edit=None, date_time=None): '''Check validity of year as each char entered''' if date_time: date_time.year_is_valid = False year_str = year_edit.get_text() if not year_str: return True now = datetime.datetime.now() LOGGER.log(LOG_LEVEL_INPUT, "validating year, text=%s=", year_str) if not year_str.isdigit(): raise UIMessage(_("Year must be numeric")) if year_str[0] != now.strftime("%Y")[0]: LOGGER.debug("year doesn't start with 2, text=%s", year_str) raise UIMessage(_("Year out of range")) if len(year_str) > 1 and year_str[1] != now.strftime("%Y")[1]: LOGGER.debug("year out of range=%s", year_str) raise UIMessage(_("Year out of range")) if date_time: date_time.year_is_valid = True if len(year_str) == 4: check_day_range(month_edit, day_edit, year_edit, date_time) return True
def build_summary(self): '''Build a textual summary from solaris_install.sysconfig profile''' if self.sysconfig is None: return "" else: summary_text = [] # display summary only for configured areas # locale and timezone belong to SC_GROUP_LOCATION group if configure_group(SC_GROUP_LOCATION): summary_text.append(self.get_tz_summary()) summary_text.append("") summary_text.append(_("Language: *The following can be changed" " when logging in.")) if self.sysconfig.system.locale is None: self.sysconfig.system.determine_locale() summary_text.append(_(" Default language: %s") % self.sysconfig.system.actual_lang) # keyboard layout belongs to SC_GROUP_KBD group if configure_group(SC_GROUP_KBD): summary_text.append("") summary_text.append(_("Keyboard layout: *The following can be " "changed when logging in.")) summary_text.append(_(" Default keyboard layout: %s") % self.sysconfig.system.keyboard) summary_text.append("") if hasattr(self.sysconfig.system, 'terminal_type'): summary_text.append(_("Terminal type: %s") % self.sysconfig.system.terminal_type) # user/root accounts belong to SC_GROUP_USERS group if configure_group(SC_GROUP_USERS): summary_text.append("") summary_text.append(_("Users:")) summary_text.extend(self.get_users()) # network belongs to SC_GROUP_IDENTITY and SC_GROUP_NETWORK groups if configure_group(SC_GROUP_NETWORK) or \ configure_group(SC_GROUP_IDENTITY): summary_text.append("") summary_text.append(_("Network:")) summary_text.extend(self.get_networks()) if configure_group(SC_GROUP_NS): self._get_nameservice(summary_text) return "\n".join(summary_text)
def validate_ip(edit_field): '''Wrap a call to IPAddress.check_address and raise a UIMessage with appropriate message text ''' ip_address = edit_field.get_text() if not ip_address: return True try: IPAddress.convert_address(ip_address) except ValueError as err: if err[0] == IPAddress.MSG_NO_LEADING_ZEROS: raise UIMessage(NICConfigure.MSG_NO_LEADING_ZEROS % edit_field.data_obj) raise UIMessage(_("%s must be of the form xxx.xxx.xxx.xxx") % edit_field.data_obj) return True
def _show(self): '''Display the static paragraph WELCOME_TEXT and all applicable bullet items''' sc_options = get_sc_options_from_doc() max_width = self.win_size_x - WelcomeScreen.INDENT - 1 text = convert_paragraph(WelcomeScreen.WELCOME_TEXT, max_width) # list configuration groups in a comma-separated list with # bullet on first line and indentation on subsequent lines grouplist = list() if configure_group(SC_GROUP_NETWORK): grouplist.append(_("network")) elif configure_group(SC_GROUP_IDENTITY): grouplist.append(_("system hostname")) if configure_group(SC_GROUP_LOCATION): grouplist.append(_("time zone")) if configure_group(SC_GROUP_DATETIME): grouplist.append(_("date and time")) if configure_group(SC_GROUP_USERS): grouplist.append(_("user and root accounts")) if configure_group(SC_GROUP_NS): grouplist.append(_("name services")) grouplist = ", ".join(grouplist) grouplist = convert_paragraph(grouplist, max_width - len(WelcomeScreen.BULLET)) for ln in range(len(grouplist)): if ln == 0: text.append(WelcomeScreen.BULLET + grouplist[ln]) else: text.append(WelcomeScreen.BULLET_INDENT + grouplist[ln]) # display navigation instructions and profile path fmt = {"scprof": sc_options.profile} text.extend(convert_paragraph(WelcomeScreen.NAVIPRO_TEXT % fmt, max_width)) # indent and align while bulletting for bullet in WelcomeScreen.BULLET_ITEMS: btext = convert_paragraph(bullet, max_width - len(WelcomeScreen.BULLET)) for ln in range(len(btext)): if ln == 0: text.append(WelcomeScreen.BULLET + btext[ln]) else: text.append(WelcomeScreen.BULLET_INDENT + btext[ln]) # prepare welcome text in entire window for scrolling area = WindowArea(x_loc=0, y_loc=1, scrollable_lines=(len(text) + 1)) area.lines = self.win_size_y - 1 area.columns = self.win_size_x scroll_region = ScrollWindow(area, window=self.center_win) scroll_region.add_paragraph(text, start_x=WelcomeScreen.INDENT) self.center_win.activate_object(scroll_region)
def get_tz_summary(self): '''Return a string summary of the timezone selection''' timezone = self.sysconfig.system.tz_timezone return _("Time Zone: %s") % timezone
def set_actions(self): '''Replace the default F2_Continue with F2_Apply''' install_action = Action(curses.KEY_F2, _("Apply"), self.main_win.screen_list.get_next) self.main_win.actions[install_action.key] = install_action
def nameservice_summary(nameservice, summary): '''sppend name service summary information Args: nameservice - name service info summary - list of summary lines to append to ''' if not nameservice: return if not nameservice.dns and not nameservice.nameservice: return # fetch localized name for name service if nameservice.dns: summary.append(_("Name service: %s") % NameService.USER_CHOICE_DNS) # strip empty list entries dnslist = [ln for ln in nameservice.dns_server if ln] summary.append(_("DNS servers: ") + " ".join(dnslist)) dnslist = [ln for ln in nameservice.dns_search if ln] summary.append(_("DNS Domain search list: ") + " ".join(dnslist)) if nameservice.nameservice == 'LDAP': ns_idx = NameService.CHOICE_LIST.index(nameservice.nameservice) summary.append(_("Name service: %s") % NameService.USER_CHOICE_LIST[ns_idx]) summary.append(_("Domain: %s") % nameservice.domain) summary.append(_("LDAP profile: ") + nameservice.ldap_profile) summary.append(_("LDAP server's IP: ") + nameservice.ldap_ip) summary.append(_("LDAP search base: ") + nameservice.ldap_search_base) if nameservice.ldap_proxy_bind == \ NameServiceInfo.LDAP_CHOICE_PROXY_BIND: summary.append(_("LDAP proxy bind distinguished name: ") + nameservice.ldap_pb_dn) summary.append(_("LDAP proxy bind password: [concealed]")) elif nameservice.nameservice == 'NIS': ns_idx = NameService.CHOICE_LIST.index(nameservice.nameservice) summary.append(_("Name service: %s") % NameService.USER_CHOICE_LIST[ns_idx]) summary.append(_("Domain: %s") % nameservice.domain) if nameservice.nis_auto == NameServiceInfo.NIS_CHOICE_AUTO: summary.append(_("NIS server: broadcast")) elif nameservice.nis_ip: summary.append(_("NIS server's IP: ") + nameservice.nis_ip) # offer user help for modifying name service sources if nameservice.dns: summary.append(_("Note: DNS will be configured to resolve " "host and IP node names.")) summary.append(_("This setting can be modified upon " "rebooting. For example:")) summary.append("# svccfg -s svc:/system/name-service/switch") summary.append("svc:/system/name-service/switch> " "setprop config/host=\"files nis dns\"") summary.append("svc:/system/name-service/switch> quit") summary.append("# svcadm refresh svc:/system/name-service/switch") summary.append(_("See nsswitch.conf(4), svccfg(1M) and " "nscfg(1M)."))