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 _show(self):
# This will be used (and re-used) later. It defines a subwindow's
# location at 1, 1, with width 20 and height 1
win_area = WindowArea(y_loc=1, x_loc=1, lines=1, columns=20)
# Creating an empty editable field is just as simple as creating
# a list item: define a location, and a parent window.
field_one = EditField(win_area, window=self.center_win)
# Side trick - a WindowArea can be reused. In this case, the y-coord
# is updated, and then win_area is used for the next EditField.
win_area.y_loc = 2
# Setting default text for a field is also simple:
field_two = EditField(win_area, window=self.center_win, text="default")
# For the Text Installer and SCI tool, however, an extra step must
# be taken. To help with labeling and highlighting, each EditField
# should be wrapped in a ListItem, like so:
win_area.y_loc = 3
list_three = ListItem(win_area, window=self.center_win, text="3: ")
edit_area = WindowArea(y_loc=0, x_loc=5, lines=1, columns=10)
field_three = EditField(edit_area, window=list_three)
# Note that the 'window' parameter for field_three is 'list_three',
# and that edit_area is a position relative to list_three.
win_area.y_loc = 4
list_four = ListItem(win_area, window=self.center_win, text="4: ")
# Since WindowAreas are relative to their parent, edit_area can
# be reused with no modifications
field_four = EditField(edit_area, window=list_four, text="default")
# As with lists, edit fields must be explicitly given focus. Note that
# focus can be given by index, or by reference.
self.center_win.activate_object(field_two)
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()
class NSLDAPProxyBindInfo(NameService):
HEADER_TEXT = _("Specify LDAP Profile Proxy Bind Information")
HELP_DATA = (SCI_HELP + "/%s/ldap_proxy.txt", HEADER_TEXT)
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:"******"The LDAP proxy server distinguished name cannot be blank."))
validate_ldap_proxy_bind_psw(self.ldap_pb_psw.get_text())
def on_change_screen(self):
self.nameservice.ldap_pb_dn = self.ldap_pb_dn.get_text()
self.nameservice.ldap_pb_psw = self.ldap_pb_psw.get_text()
def _show(self):
super(NSDNSServer, self)._show()
# check dictionary of screens associated with name service selections
if not self.nameservice.dns:
raise SkipException
y_loc = self._paint_opening()
self.dns_server_list = []
find_1st_nonblank = None
find_last_nonblank = -1
for i in range(NameServiceInfo.MAXDNSSERV):
self.center_win.add_text(self.title, y_loc, INDENT)
area = WindowArea(1, MAXIP, y_loc,
textwidth(self.title) + INDENT + 1)
y_loc += 1
if i < len(self.nameservice.dns_server) and \
self.nameservice.dns_server[i] is not None:
text = self.nameservice.dns_server[i]
else:
text = ''
# find first blank field or last non-blank field
if text:
find_last_nonblank = i
elif find_1st_nonblank is None:
find_1st_nonblank = i
self.dns_server_list += [EditField(area, window=self.center_win,
text=text,
validate=incremental_validate_ip,
error_win=self.main_win.error_line)]
self.main_win.do_update()
# position cursor on first blank or after last field
if find_1st_nonblank is None:
idx = min(find_last_nonblank + 1, NameServiceInfo.MAXDNSSERV - 1)
else:
idx = find_1st_nonblank
self.center_win.activate_object(self.dns_server_list[idx])
def _show(self):
# The _show method will not only create the four desired EditFields,
# but restore saved state as well.
win_area = WindowArea(lines=1, columns=40, y_loc=1, x_loc=1)
edit_area = WindowArea(lines=1, columns=20, y_loc=0, x_loc=10)
for field_num in range(4):
win_area.y_loc += 1
field_label = "%s: " % field_num
list_item = ListItem(win_area,
window=self.center_win,
text=field_label)
# Grab the saved text for the field (assume it's been saved for
# now; *how* to go about saving it is below)
field_text = self.saved_text[field_num]
# And then set that as the text for the field
edit_field = EditField(edit_area,
window=list_item,
text=field_text)
# Save a reference to the field so other methods can access
# their data:
self.fields[field_num] = edit_field
# Since this series of fields also acts as a selectable list,
# the current selection can be restored as well by changing which
# object is active:
self.center_win.activate_object(self.current_selection)
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 _show(self):
''' show domain '''
super(NSDomain, self)._show()
if not _has_name_service():
raise SkipException
if not self.nameservice.nameservice:
raise SkipException
y_loc = self._paint_opening()
cols = min(MAXDOMAINLEN + 1,
self.win_size_x - textwidth(self.title) - INDENT - 1)
self.center_win.add_text(self.title, y_loc, INDENT)
area = WindowArea(1, cols, y_loc, textwidth(self.title) + INDENT + 1,
scrollable_columns=MAXDOMAINLEN + 1)
self.domain = EditField(area, window=self.center_win,
text=self.nameservice.domain,
validate=incremental_validate_domain,
error_win=self.main_win.error_line)
self.main_win.do_update()
self.center_win.activate_object(self.domain)
def create_list_item(self, next_part, win, list_area):
'''Add an entry for next_part (a Partition or Slice) to
the DiskWindow
'''
list_item = ListItem(list_area, window=win, data_obj=next_part)
list_item.key_dict.update(DiskWindow.ADD_KEYS)
edit_field = EditField(self.edit_area, window=list_item,
numeric_pad=" ",
validate=decimal_valid,
on_exit=on_exit_edit,
error_win=self.error_win,
add_obj=False,
data_obj=next_part)
edit_field.right_justify = True
edit_field.validate_kwargs["disk_win"] = self
edit_field.on_exit_kwargs["disk_win"] = self
edit_field.key_dict.update(DiskWindow.ADD_KEYS)
self.update_part(part_field=list_item)
return list_item
def _show(self):
super(NSLDAPProfile, self)._show()
if self.nameservice.nameservice != 'LDAP':
raise SkipException
if self.nameservice.dns:
self.intro = \
_("Specify the name of the LDAP profile to be used to "
"configure this system and the host name or IP address of "
"the server that contains the profile.")
self.title2 = _("Profile server host name or IP address:")
else:
self.intro = \
_("Specify the name of the LDAP profile to be used to "
"configure this system and the IP address of the "
"server that contains the profile.")
self.title2 = _("Profile server IP address:")
self.intro += _(" Enter the LDAP search base.")
y_loc = self._paint_opening()
maxtitlelen = max(textwidth(self.title), textwidth(self.title2),
textwidth(self.title3))
aligned_x_loc = maxtitlelen + INDENT + 1
cols = self.win_size_x - aligned_x_loc
self.center_win.add_text(self.title.rjust(maxtitlelen), y_loc, INDENT)
area = WindowArea(1, cols, y_loc, aligned_x_loc)
self.ldap_profile = EditField(area, window=self.center_win,
text=self.nameservice.ldap_profile,
error_win=self.main_win.error_line,
validate=inc_validate_nowhite_nospecial)
# in case of error, tell user what is being validated
self.ldap_profile.validate_kwargs['etext'] = _('profile name')
y_loc += 1
area = WindowArea(1, cols, y_loc, aligned_x_loc,
scrollable_columns=NameService.HOSTNAME_SCREEN_LEN + 1)
self.center_win.add_text(self.title2.rjust(maxtitlelen), y_loc, INDENT)
# create edit field, validating for host name or IP address depending
# on whether DNS was selected
self.ldap_ip = EditField(area, window=self.center_win,
text=self.nameservice.ldap_ip,
error_win=self.main_win.error_line,
validate=(incremental_validate_host
if self.nameservice.dns
else incremental_validate_ip))
# search base
y_loc += 1
self.center_win.add_text(self.title3.rjust(maxtitlelen), y_loc, INDENT)
area = WindowArea(1, cols, y_loc, aligned_x_loc,
scrollable_columns=MAXDNLEN + 1)
self.ldap_search_base = EditField(area, window=self.center_win,
text=self.nameservice.ldap_search_base,
error_win=self.main_win.error_line)
self.main_win.do_update()
self.center_win.activate_object(self.ldap_ip)
def _show(self):
''' show DNS search list '''
super(NSDNSSearch, self)._show()
# check dictionary of screens associated with name service selections
if not self.nameservice.dns:
raise SkipException
y_loc = self._paint_opening()
cols = min(MAXDOMAINLEN + 1,
self.win_size_x - textwidth(self.title) - INDENT - 1)
self.dns_search_list = []
find_1st_nonblank = None
find_last_nonblank = -1
LOGGER.info(self.nameservice.dns_search)
for i in range(MAXDNSSEARCH):
self.center_win.add_text(text=self.title,
start_y=y_loc,
start_x=INDENT)
area = WindowArea(1, cols, y_loc,
textwidth(self.title) + INDENT + 1)
y_loc += 1
if i < len(self.nameservice.dns_search) and \
self.nameservice.dns_search[i] is not None:
text = self.nameservice.dns_search[i]
else:
text = ''
# find first blank field or last non-blank field
if text:
find_last_nonblank = i
elif find_1st_nonblank is None:
find_1st_nonblank = i
edf = EditField(area,
window=self.center_win,
text=text,
validate=incremental_validate_domain,
error_win=self.main_win.error_line)
self.dns_search_list += [edf]
self.main_win.do_update()
# position cursor on first blank or after last field
if find_1st_nonblank is None:
idx = min(find_last_nonblank + 1, MAXDNSSEARCH - 1)
else:
idx = find_1st_nonblank
self.center_win.activate_object(self.dns_search_list[idx])
def make_field(self,
label,
description,
y_loc,
max_y,
max_x,
description_start,
default_val,
is_ip=True,
selectable=True):
'''Create a list item with 'label', add an editable field with
'default_val', and add additional 'description' text following it
'''
self.list_area.y_loc = y_loc
list_item = ListItem(self.list_area,
text=label,
data_obj=label,
window=self.center_win,
add_obj=selectable)
if is_ip:
validate = incremental_validate_ip
else:
validate = None
edit_field = EditField(self.edit_area,
window=list_item,
text=default_val,
validate=validate,
error_win=self.main_win.error_line,
data_obj=label.rstrip(":"))
self.center_win.add_paragraph(description,
y_loc,
description_start,
max_y=(y_loc + max_y),
max_x=max_x)
return edit_field
class NetworkTypeScreen(BaseScreen):
'''
Let the user:
- Choose the hostname
- Select network type (Automatic, Manual, or None)
'''
HEADER_TEXT = _("Network")
PARAGRAPH = _("Enter a name for this computer that identifies it on "
"the network. It must be at least two characters. It "
"can contain letters, numbers, and minus signs (-).")
HOSTNAME_TEXT = _("Computer Name: ")
NET_TYPE_TEXT = _("Select how the wired ethernet network "
"connection is configured.")
AUTO_TEXT = _("Automatically")
AUTO_DETAIL = _("Automatically configure the connection")
MANUAL_TEXT = _("Manually")
MANUAL_DETAIL = _("Enter the information on the following screen")
NONE_TEXT = _("None")
NONE_DETAIL = _("Do not configure the network at this time")
NO_NICS_FOUND = _("No wired network interfaces found. Additional "
"device drivers may be needed.")
ALL_NICS_FROMGZ = _("No configurable network interfaces found. They are "
"all controlled from global zone.")
ITEM_OFFSET = 2
ITEM_MAX_WIDTH = 17
ITEM_DESC_OFFSET = ITEM_MAX_WIDTH + ITEM_OFFSET + 1
HOSTNAME_SCREEN_LEN = 25
HELP_DATA = (SCI_HELP + "/%s/network.txt", _("Network"))
def __init__(self, main_win, configure_network=False):
global LOGGER
if LOGGER is None:
LOGGER = logging.getLogger(INSTALL_LOGGER_NAME + ".sysconfig")
super(NetworkTypeScreen, self).__init__(main_win)
self.hostfield_offset = textwidth(NetworkTypeScreen.HOSTNAME_TEXT)
self.menu_item_desc_max = (self.win_size_x -
NetworkTypeScreen.ITEM_DESC_OFFSET)
self.net_type_dict = {}
self.sys_info = None
self.automatic = None
self.manual = None
self.none_option = None
self.hostname = None
self.nic_info = NetworkInfo()
# find_links() returns tuple containing
# * dictionary of configurable NICs
# * number of NICs mandated from global zone.
#
# Taking that information into account, initialize type
# of network configuration:
# * FROMGZ - One or more link found, but all found links are
# controlled from global zone.
# * None - otherwise
#
# Set 'have_nic' flag to True if there is at least one configurable
# link, otherwise set the flag to False.
#
self.ether_nics, self.fromgz_num = NetworkInfo.find_links()
self.nic_info.type = NetworkInfo.NONE
self.have_nic = True
if len(self.ether_nics) == 0:
self.have_nic = False
if self.fromgz_num > 0:
self.nic_info.type = NetworkInfo.FROMGZ
self.configure_network = configure_network
def _show(self):
'''Create an EditField for entering hostname, and list items
for each of the network types
'''
sc_profile = solaris_install.sysconfig.profile.from_engine()
if sc_profile.system is None:
sc_profile.system = SystemInfo()
self.sys_info = sc_profile.system
if sc_profile.nic is None:
sc_profile.nic = self.nic_info
y_loc = 1
y_loc += self.center_win.add_paragraph(NetworkTypeScreen.PARAGRAPH,
y_loc)
y_loc += 1
self.center_win.add_text(NetworkTypeScreen.HOSTNAME_TEXT, y_loc)
max_cols = self.win_size_x - self.hostfield_offset
cols = min(max_cols, NetworkTypeScreen.HOSTNAME_SCREEN_LEN)
scrollable_columns = SystemInfo.MAX_HOSTNAME_LEN + 1
hostname_area = WindowArea(1, cols, y_loc, self.hostfield_offset,
scrollable_columns=scrollable_columns)
self.hostname = EditField(hostname_area,
window=self.center_win,
text=self.sys_info.hostname,
validate=hostname_is_valid,
error_win=self.main_win.error_line)
self.hostname.item_key = None
# Display network configuration part of screen only if applicable.
if self.configure_network:
y_loc += 3
# If there are no configurable links, there is no point to let
# user select type of network configuration.
if not self.have_nic:
# Inform user that no network interfaces were found
# on the system.
# If this is the case of non-global zone with all links
# mandated from global zone, be more specific.
if self.nic_info.type == NetworkInfo.FROMGZ:
self.center_win.add_paragraph(
NetworkTypeScreen.ALL_NICS_FROMGZ, y_loc, 1)
else:
self.center_win.add_paragraph(
NetworkTypeScreen.NO_NICS_FOUND, y_loc, 1)
self.main_win.do_update()
activate = self.net_type_dict.get(self.nic_info.type,
self.hostname)
self.center_win.activate_object(activate)
return
self.main_win.do_update()
activate = self.net_type_dict.get(self.nic_info.type,
self.hostname)
self.center_win.activate_object(activate)
def on_change_screen(self):
'''Save hostname and selected network type on change screen'''
if self.configure_network and self.have_nic:
self.nic_info.type = self.center_win.get_active_object().item_key
if self.nic_info.type is None:
self.nic_info.type = NetworkInfo.NONE
LOGGER.info("Configuring NIC as: %s", self.nic_info.type)
self.sys_info.hostname = self.hostname.get_text()
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 _show(self):
'''Create an EditField for entering hostname, and list items
for each of the network types
'''
sc_profile = solaris_install.sysconfig.profile.from_engine()
if sc_profile.system is None:
sc_profile.system = SystemInfo()
self.sys_info = sc_profile.system
if sc_profile.nic is None:
sc_profile.nic = self.nic_info
y_loc = 1
y_loc += self.center_win.add_paragraph(NetworkTypeScreen.PARAGRAPH,
y_loc)
y_loc += 1
self.center_win.add_text(NetworkTypeScreen.HOSTNAME_TEXT, y_loc)
max_cols = self.win_size_x - self.hostfield_offset
cols = min(max_cols, NetworkTypeScreen.HOSTNAME_SCREEN_LEN)
scrollable_columns = SystemInfo.MAX_HOSTNAME_LEN + 1
hostname_area = WindowArea(1, cols, y_loc, self.hostfield_offset,
scrollable_columns=scrollable_columns)
self.hostname = EditField(hostname_area,
window=self.center_win,
text=self.sys_info.hostname,
validate=hostname_is_valid,
error_win=self.main_win.error_line)
self.hostname.item_key = None
# Display network configuration part of screen only if applicable.
if self.configure_network:
y_loc += 3
# If there are no configurable links, there is no point to let
# user select type of network configuration.
if not self.have_nic:
# Inform user that no network interfaces were found
# on the system.
# If this is the case of non-global zone with all links
# mandated from global zone, be more specific.
if self.nic_info.type == NetworkInfo.FROMGZ:
self.center_win.add_paragraph(
NetworkTypeScreen.ALL_NICS_FROMGZ, y_loc, 1)
else:
self.center_win.add_paragraph(
NetworkTypeScreen.NO_NICS_FOUND, y_loc, 1)
self.main_win.do_update()
activate = self.net_type_dict.get(self.nic_info.type,
self.hostname)
self.center_win.activate_object(activate)
return
self.main_win.do_update()
activate = self.net_type_dict.get(self.nic_info.type,
self.hostname)
self.center_win.activate_object(activate)
class UserScreen(BaseScreen):
'''Allow user to set:
- root password
- user real name
- user login
- user password
'''
HEADER_TEXT = _("Users")
INTRO_SHOW_USER = _("Define a root password for the system and user "
"account for yourself.")
INTRO_HIDE_USER = _("Define a root password for the system. Creation "
"of user account is disabled. See Help for "
"additional information.")
ROOT_TEXT = _("System Root Password")
ROOT_LABEL = _("Root password:"******"Confirm password:"******"Create a user account")
NAME_LABEL = _("Your real name:")
USERNAME_LABEL = _("Username:"******"User password:"******"/%s/users.txt", _("Users"))
PASS_SCREEN_LEN = 16 # also used as column width for user input
ITEM_OFFSET = 2
def __init__(self, main_win, show_user_account=None):
global LOGGER
if LOGGER is None:
LOGGER = logging.getLogger(INSTALL_LOGGER_NAME + ".sysconfig")
super(UserScreen, self).__init__(main_win)
self.max_text_len = (self.win_size_x - UserScreen.PASS_SCREEN_LEN -
UserScreen.ITEM_OFFSET) / 2
max_field = max(textwidth(UserScreen.ROOT_LABEL),
textwidth(UserScreen.CONFIRM_LABEL),
textwidth(UserScreen.NAME_LABEL),
textwidth(UserScreen.USERNAME_LABEL),
textwidth(UserScreen.USER_PASS_LABEL))
self.text_len = min(max_field + 1, self.max_text_len)
self.list_area = WindowArea(1, self.text_len, 0,
UserScreen.ITEM_OFFSET)
scrollable_columns = UserInfo.MAX_PASS_LEN + 1
self.edit_area = WindowArea(1,
UserScreen.PASS_SCREEN_LEN + 1,
0,
self.text_len,
scrollable_columns=scrollable_columns)
self.username_edit_area = WindowArea(
1,
UserScreen.PASS_SCREEN_LEN + 1,
0,
self.text_len,
scrollable_columns=UserInfo.MAX_USERNAME_LEN + 1)
err_x_loc = 2 * self.max_text_len - self.text_len
err_width = (self.text_len + UserScreen.PASS_SCREEN_LEN)
self.error_area = WindowArea(1, err_width, 0, err_x_loc)
self.root = None
self.user = None
self.root_pass_list = None
self.root_pass_edit = None
self.root_pass_err = None
self.root_confirm_err = None
self.root_confirm_list = None
self.root_confirm_edit = None
self.real_name_err = None
self.real_name_list = None
self.real_name_edit = None
self.username_err = None
self.username_list = None
self.username_edit = None
self.user_pass_err = None
self.user_pass_list = None
self.user_pass_edit = None
self.user_confirm_err = None
self.user_confirm_list = None
self.user_confirm_edit = None
#
# If show_user_account is True, complete Users screen will be
# displayed (root password edit fields as well as widgets related
# to creating initial user account). Otherwise, widgets for initial
# user account are hidden.
#
# If not initialized explicitly by caller (e.g. text installer),
# show_user_account is set to True only if all conditions needed
# for successful creation of user account are met.
#
# In particular, existence of parent of home ZFS dataset is checked,
# since if parent of home ZFS dataset was missing, then
# svc:/system/config-user smf service (responsible for configuring
# root and user accounts) would fail to create user account. As
# a result of that, the whole system would end up in maintenance mode.
#
self.show_user_account = show_user_account
if self.show_user_account is None:
self.show_user_account = self.home_zfs_parent_exists()
def _show(self):
'''Display the user name, real name, and password fields'''
sc_profile = solaris_install.sysconfig.profile.from_engine()
#
# Create UserInfo instances holding information about root and user
# accounts.
#
if sc_profile.users is None:
#
# Assume root is a normal account. It will be changed to a role
# if the user account is created.
#
root = UserInfo(login_name="root", is_role=False)
#
# Initialize attributes of user account which can't be configured
# on screens.
#
user = UserInfo(gid=10,
shell="/usr/bin/bash",
roles="root",
profiles="System Administrator",
sudoers="ALL=(ALL) ALL")
sc_profile.users = UserInfoContainer(root, user)
self.root = sc_profile.users.root
self.user = sc_profile.users.user
LOGGER.debug("Root: %s", self.root)
LOGGER.debug("User: %s", self.user)
root_set = (self.root.passlen != 0)
user_set = (self.user.passlen != 0)
y_loc = 1
if self.show_user_account:
intro_text = UserScreen.INTRO_SHOW_USER
else:
intro_text = UserScreen.INTRO_HIDE_USER
self.center_win.add_paragraph(intro_text, y_loc, 1, y_loc + 2,
self.win_size_x - 1)
y_loc += 3
self.center_win.add_text(UserScreen.ROOT_TEXT, y_loc, 1,
self.win_size_x - 1)
y_loc += 2
self.error_area.y_loc = y_loc
self.list_area.y_loc = y_loc
self.root_pass_err = ErrorWindow(self.error_area,
window=self.center_win)
self.root_pass_list = ListItem(self.list_area,
window=self.center_win,
text=UserScreen.ROOT_LABEL)
self.root_pass_edit = PasswordField(self.edit_area,
window=self.root_pass_list,
error_win=self.root_pass_err,
fill=root_set)
y_loc += 1
self.error_area.y_loc = y_loc
self.list_area.y_loc = y_loc
self.root_confirm_err = ErrorWindow(self.error_area,
window=self.center_win)
self.root_confirm_list = ListItem(self.list_area,
window=self.center_win,
text=UserScreen.CONFIRM_LABEL)
self.root_confirm_edit = PasswordField(self.edit_area,
window=self.root_confirm_list,
fill=root_set,
on_exit=pass_match,
error_win=self.root_confirm_err)
rc_edit_kwargs = {"linked_win": self.root_pass_edit}
self.root_confirm_edit.on_exit_kwargs = rc_edit_kwargs
# User account disabled, do not display related widgets.
if not self.show_user_account:
self.main_win.do_update()
self.center_win.activate_object(self.root_pass_list)
return
y_loc += 2
self.center_win.add_text(UserScreen.USER_TEXT, y_loc, 1,
self.win_size_x - 1)
y_loc += 2
self.list_area.y_loc = y_loc
self.error_area.y_loc = y_loc
self.real_name_err = ErrorWindow(self.error_area,
window=self.center_win)
self.real_name_list = ListItem(self.list_area,
window=self.center_win,
text=UserScreen.NAME_LABEL)
self.real_name_edit = EditField(self.edit_area,
window=self.real_name_list,
error_win=self.real_name_err,
text=self.user.real_name)
y_loc += 1
self.list_area.y_loc = y_loc
self.error_area.y_loc = y_loc
self.username_err = ErrorWindow(self.error_area,
window=self.center_win)
self.username_list = ListItem(self.list_area,
window=self.center_win,
text=UserScreen.USERNAME_LABEL)
self.username_edit = EditField(self.username_edit_area,
window=self.username_list,
validate=username_valid,
error_win=self.username_err,
on_exit=login_valid,
text=self.user.login_name)
y_loc += 1
self.list_area.y_loc = y_loc
self.error_area.y_loc = y_loc
self.user_pass_err = ErrorWindow(self.error_area,
window=self.center_win)
self.user_pass_list = ListItem(self.list_area,
window=self.center_win,
text=UserScreen.USER_PASS_LABEL)
self.user_pass_edit = PasswordField(self.edit_area,
window=self.user_pass_list,
error_win=self.user_pass_err,
fill=user_set)
y_loc += 1
self.list_area.y_loc = y_loc
self.error_area.y_loc = y_loc
self.user_confirm_err = ErrorWindow(self.error_area,
window=self.center_win)
self.user_confirm_list = ListItem(self.list_area,
window=self.center_win,
text=UserScreen.CONFIRM_LABEL)
self.user_confirm_edit = PasswordField(self.edit_area,
window=self.user_confirm_list,
on_exit=pass_match,
error_win=self.user_confirm_err,
fill=user_set)
uc_edit_kwargs = {"linked_win": self.user_pass_edit}
self.user_confirm_edit.on_exit_kwargs = uc_edit_kwargs
self.main_win.do_update()
self.center_win.activate_object(self.root_pass_list)
def on_change_screen(self):
'''Store entered information into data object cache.'''
if self.root_pass_edit.modified:
if self.root_pass_edit.compare(self.root_confirm_edit):
self.root.password = self.root_pass_edit.get_text()
else:
self.root.password = ""
if self.root.password is None:
self.root.password = ""
self.root_pass_edit.clear_text()
self.root_confirm_edit.clear_text()
#
# User account disabled, do not store related info into data object
# cache.
#
if not self.show_user_account:
return
self.user.real_name = self.real_name_edit.get_text()
self.user.login_name = self.username_edit.get_text()
# If user account is to be created, configure root account as a role.
self.root.is_role = bool(self.user.login_name)
if self.user_pass_edit.modified:
if self.user_pass_edit.compare(self.user_confirm_edit):
self.user.password = self.user_pass_edit.get_text()
else:
self.user.password = ""
if self.user.password is None:
self.user.password = ""
self.user_pass_edit.clear_text()
self.user_confirm_edit.clear_text()
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 home_zfs_parent_exists(self):
'''Return True if parent of to-be-created home ZFS dataset exists.
Otherwise, return False.
Home ZFS dataset is created in form of <root_pool>/export/home/<login>
with mountpoint /export/home/<login> inherited from parent dataset.
The check verifies that ZFS dataset with to-be-inherited /export/home
mountpoint exists.
'''
# obtain mountpoints for all existing ZFS datasets
cmd = [ZFS, "list", "-H", "-o", "mountpoint"]
try:
mountpoint_list = run(cmd, logger=LOGGER)
except CalledProcessError:
LOGGER.warn("Could not determine if parent of home ZFS dataset "
"exists.")
return False
if "/export/home" not in mountpoint_list.stdout.splitlines():
LOGGER.debug("Parent of home ZFS dataset does not exist, creation "
"of user account disabled.")
return False
LOGGER.debug("Parent of home ZFS dataset exists, creation of user "
"account enabled.")
return True
def _show(self):
""" create the screen to collect user input
"""
# look in the DOC for an Iscsi object
eng = InstallEngine.get_instance()
iscsi_obj = eng.doc.volatile.get_children(name=ISCSI_LABEL,
class_type=Iscsi)
# If there's no iscsi object in the DOC, skip this screen
if not iscsi_obj:
raise SkipException
else:
self.iscsi_obj = iscsi_obj[0]
LOGGER.debug("show Iscsi object: %s" % str(self.iscsi_obj))
y_loc = 1
self.center_win.add_paragraph(IscsiScreen.INTRO, start_y=y_loc)
# look to see if DHCP is providing information
if self.check_dhcp():
y_loc += 2
self.center_win.add_paragraph(IscsiScreen.FOUND_DHCP_LABEL,
start_y=y_loc)
# Target IP
y_loc += 2
# Mark this field required
self.center_win.window.addch(y_loc, 2, IscsiScreen.REQUIRED_MARK,
self.center_win.color_theme.inactive)
edit_start = textwidth(IscsiScreen.TARGET_IP_LABEL) + \
IscsiScreen.ITEM_OFFSET
ip_area = WindowArea(y_loc=y_loc, x_loc=1, lines=1,
columns=edit_start + IscsiScreen.MAX_IP_LEN + 1)
self.target_ip_list = ListItem(ip_area,
window=self.center_win,
text=IscsiScreen.TARGET_IP_LABEL)
self.target_ip_list.key_dict.update(self.add_keys)
self.default_edit.x_loc = edit_start
self.default_edit.columns = IscsiScreen.MAX_IP_LEN + 1
self.target_ip_edit = EditField(self.default_edit,
window=self.target_ip_list,
validate=incremental_validate_ip,
error_win=self.main_win.error_line)
self.target_ip_edit.key_dict.update(self.add_keys)
if self.target_ip is not None:
self.target_ip_edit.set_text(self.target_ip)
# Target Port
edit_start = ip_area.x_loc + \
textwidth(IscsiScreen.TARGET_PORT_LABEL) + \
IscsiScreen.ITEM_OFFSET
port_area = WindowArea(y_loc=y_loc,
x_loc=self.half_win_width + IscsiScreen.DEAD_ZONE,
lines=1, columns=edit_start + IscsiScreen.MAX_PORT_LEN + 1)
self.target_port_list = ListItem(port_area,
window=self.center_win,
text=IscsiScreen.TARGET_PORT_LABEL)
self.target_port_list.key_dict.update(self.add_keys)
self.right_edit.x_loc = edit_start
self.right_edit.columns = IscsiScreen.MAX_PORT_LEN + 1
self.target_port_edit = EditField(self.right_edit,
window=self.target_port_list,
validate=incremental_validate_digits,
error_win=self.main_win.error_line,
text=Iscsi.ISCSI_DEFAULT_PORT)
self.target_port_edit.key_dict.update(self.add_keys)
if self.target_port is not None:
self.target_port_edit.set_text(self.target_port)
# Target LUN
y_loc += 1
edit_start = textwidth(IscsiScreen.TARGET_LUN_LABEL) + \
IscsiScreen.ITEM_OFFSET
lun_area = WindowArea(y_loc=y_loc, x_loc=1, lines=1,
columns=edit_start + IscsiScreen.MAX_LUN_LEN + 1)
self.target_lun_list = ListItem(lun_area,
window=self.center_win,
text=IscsiScreen.TARGET_LUN_LABEL)
self.target_lun_list.key_dict.update(self.add_keys)
self.default_edit.x_loc = edit_start
self.default_edit.columns = IscsiScreen.MAX_LUN_LEN + 1
self.target_lun_edit = EditField(self.default_edit,
window=self.target_lun_list,
validate=incremental_validate_hex,
error_win=self.main_win.error_line)
self.target_lun_edit.key_dict.update(self.add_keys)
if self.target_lun is not None:
self.target_lun_edit.set_text(self.target_lun)
# Target Name
y_loc += 2
name_area = WindowArea(y_loc=y_loc, x_loc=1, lines=1,
columns=self.full_win_width)
name_area.y_loc = y_loc
target_name_list = ListItem(name_area, window=self.center_win,
text=IscsiScreen.TARGET_NAME_LABEL)
self.name_edit.x_loc = textwidth(IscsiScreen.TARGET_NAME_LABEL) + \
IscsiScreen.ITEM_OFFSET
self.name_edit.columns = self.full_win_width - \
textwidth(IscsiScreen.TARGET_NAME_LABEL) - \
IscsiScreen.ITEM_OFFSET
self.target_name_edit = EditField(self.name_edit,
window=target_name_list)
if self.target_name is not None:
self.target_name_edit.set_text(self.target_name)
# Horizontal line
y_loc += 1
self.center_win.window.hline(y_loc, 3, curses.ACS_HLINE,
self.full_win_width)
# Initiator Name
y_loc += 1
if self.is_iscsiboot:
# the system BIOS is configured for iSCSI boot. This means the
# user will be unable to change the initiator-name. Display the
# name, but don't allow it to be changed.
text = "%s %s" % \
(IscsiScreen.INITIATOR_NAME_LABEL, self.initiator_name)
self.center_win.add_text(text, start_y=y_loc, start_x=1)
y_loc += 1
self.center_win.add_text(IscsiScreen.ISCSI_BOOT_LABEL,
start_y=y_loc, start_x=1)
else:
# display the edit field as normal
name_area.y_loc = y_loc
initiator_name_list = ListItem(name_area, window=self.center_win,
text=IscsiScreen.INITIATOR_NAME_LABEL)
self.name_edit.x_loc = \
textwidth(IscsiScreen.INITIATOR_NAME_LABEL) + \
IscsiScreen.ITEM_OFFSET
self.name_edit.columns = self.full_win_width - \
textwidth(IscsiScreen.INITIATOR_NAME_LABEL) - \
IscsiScreen.ITEM_OFFSET
self.initiator_name_edit = EditField(self.name_edit,
window=initiator_name_list,
text=self.initiator_name)
y_loc += 2
self.center_win.add_text(IscsiScreen.USE_CHAP_LABEL, y_loc, 1)
# CHAP username
y_loc += 1
edit_start = textwidth(IscsiScreen.CHAP_NAME_LABEL) + \
IscsiScreen.ITEM_OFFSET
chapname_area = WindowArea(y_loc=y_loc, x_loc=15, lines=1,
columns=edit_start + IscsiScreen.CHAP_LEN)
chap_name_list = ListItem(chapname_area, window=self.center_win,
text=IscsiScreen.CHAP_NAME_LABEL)
self.chap_edit.x_loc = edit_start
self.chap_edit.columns = IscsiScreen.CHAP_LEN + 1
self.chap_edit.scrollable_columns = IscsiScreen.MAX_NAME_LEN + 1
self.chap_name_edit = EditField(self.chap_edit, window=chap_name_list)
if self.chap_name is not None:
self.chap_name_edit.set_text(self.chap_name)
# CHAP password
y_loc += 1
edit_start = textwidth(IscsiScreen.CHAP_PASSWORD_LABEL) + \
IscsiScreen.ITEM_OFFSET
chapname_area.y_loc = y_loc
chap_password_list = ListItem(chapname_area, window=self.center_win,
text=IscsiScreen.CHAP_PASSWORD_LABEL)
self.chap_edit.x_loc = textwidth(IscsiScreen.CHAP_PASSWORD_LABEL) + \
IscsiScreen.ITEM_OFFSET
self.chap_edit.scrollable_columns = None
self.chap_password_edit = PasswordField(self.chap_edit,
window=chap_password_list)
if self.chap_password is not None:
self.chap_password_edit.set_text(self.chap_password)
# Legend
y_loc += 2
self.center_win.window.addch(y_loc, 1, IscsiScreen.REQUIRED_MARK,
self.center_win.color_theme.inactive)
self.center_win.add_text(IscsiScreen.REQUIRED_FIELD_LABEL, y_loc, 1)
self.main_win.do_update()
self.center_win.activate_object()
class UserScreen(BaseScreen):
'''Allow user to set:
- root password
- user real name
- user login
- user password
'''
HEADER_TEXT = _("Users")
INTRO_SHOW_USER = _("Define a root password for the system and user "
"account for yourself.")
INTRO_HIDE_USER = _("Define a root password for the system. Creation "
"of user account is disabled. See Help for "
"additional information.")
ROOT_TEXT = _("System Root Password")
ROOT_LABEL = _("Root password:"******"Confirm password:"******"Create a user account")
NAME_LABEL = _("Your real name:")
USERNAME_LABEL = _("Username:"******"User password:"******"/%s/users.txt", _("Users"))
PASS_SCREEN_LEN = 16 # also used as column width for user input
ITEM_OFFSET = 2
def __init__(self, main_win, show_user_account=None):
global LOGGER
if LOGGER is None:
LOGGER = logging.getLogger(INSTALL_LOGGER_NAME + ".sysconfig")
super(UserScreen, self).__init__(main_win)
self.max_text_len = (self.win_size_x - UserScreen.PASS_SCREEN_LEN -
UserScreen.ITEM_OFFSET) / 2
max_field = max(textwidth(UserScreen.ROOT_LABEL),
textwidth(UserScreen.CONFIRM_LABEL),
textwidth(UserScreen.NAME_LABEL),
textwidth(UserScreen.USERNAME_LABEL),
textwidth(UserScreen.USER_PASS_LABEL))
self.text_len = min(max_field + 1, self.max_text_len)
self.list_area = WindowArea(1, self.text_len, 0,
UserScreen.ITEM_OFFSET)
scrollable_columns = UserInfo.MAX_PASS_LEN + 1
self.edit_area = WindowArea(1, UserScreen.PASS_SCREEN_LEN + 1,
0, self.text_len,
scrollable_columns=scrollable_columns)
self.username_edit_area = WindowArea(1, UserScreen.PASS_SCREEN_LEN + 1,
0, self.text_len,
scrollable_columns=UserInfo.MAX_USERNAME_LEN + 1)
err_x_loc = 2 * self.max_text_len - self.text_len
err_width = (self.text_len + UserScreen.PASS_SCREEN_LEN)
self.error_area = WindowArea(1, err_width, 0, err_x_loc)
self.root = None
self.user = None
self.root_pass_list = None
self.root_pass_edit = None
self.root_pass_err = None
self.root_confirm_err = None
self.root_confirm_list = None
self.root_confirm_edit = None
self.real_name_err = None
self.real_name_list = None
self.real_name_edit = None
self.username_err = None
self.username_list = None
self.username_edit = None
self.user_pass_err = None
self.user_pass_list = None
self.user_pass_edit = None
self.user_confirm_err = None
self.user_confirm_list = None
self.user_confirm_edit = None
#
# If show_user_account is True, complete Users screen will be
# displayed (root password edit fields as well as widgets related
# to creating initial user account). Otherwise, widgets for initial
# user account are hidden.
#
# If not initialized explicitly by caller (e.g. text installer),
# show_user_account is set to True only if all conditions needed
# for successful creation of user account are met.
#
# In particular, existence of parent of home ZFS dataset is checked,
# since if parent of home ZFS dataset was missing, then
# svc:/system/config-user smf service (responsible for configuring
# root and user accounts) would fail to create user account. As
# a result of that, the whole system would end up in maintenance mode.
#
self.show_user_account = show_user_account
if self.show_user_account is None:
self.show_user_account = self.home_zfs_parent_exists()
def _show(self):
'''Display the user name, real name, and password fields'''
sc_profile = solaris_install.sysconfig.profile.from_engine()
#
# Create UserInfo instances holding information about root and user
# accounts.
#
if sc_profile.users is None:
#
# Assume root is a normal account. It will be changed to a role
# if the user account is created.
#
root = UserInfo(login_name="root", is_role=False)
#
# Initialize attributes of user account which can't be configured
# on screens.
#
user = UserInfo(gid=10, shell="/usr/bin/bash", roles="root",
profiles="System Administrator",
sudoers="ALL=(ALL) ALL")
sc_profile.users = UserInfoContainer(root, user)
self.root = sc_profile.users.root
self.user = sc_profile.users.user
LOGGER.debug("Root: %s", self.root)
LOGGER.debug("User: %s", self.user)
root_set = (self.root.passlen != 0)
user_set = (self.user.passlen != 0)
y_loc = 1
if self.show_user_account:
intro_text = UserScreen.INTRO_SHOW_USER
else:
intro_text = UserScreen.INTRO_HIDE_USER
self.center_win.add_paragraph(intro_text, y_loc, 1,
y_loc + 2, self.win_size_x - 1)
y_loc += 3
self.center_win.add_text(UserScreen.ROOT_TEXT, y_loc, 1,
self.win_size_x - 1)
y_loc += 2
self.error_area.y_loc = y_loc
self.list_area.y_loc = y_loc
self.root_pass_err = ErrorWindow(self.error_area,
window=self.center_win)
self.root_pass_list = ListItem(self.list_area, window=self.center_win,
text=UserScreen.ROOT_LABEL)
self.root_pass_edit = PasswordField(self.edit_area,
window=self.root_pass_list,
error_win=self.root_pass_err,
fill=root_set)
y_loc += 1
self.error_area.y_loc = y_loc
self.list_area.y_loc = y_loc
self.root_confirm_err = ErrorWindow(self.error_area,
window=self.center_win)
self.root_confirm_list = ListItem(self.list_area,
window=self.center_win,
text=UserScreen.CONFIRM_LABEL)
self.root_confirm_edit = PasswordField(self.edit_area,
window=self.root_confirm_list,
fill=root_set,
on_exit=pass_match,
error_win=self.root_confirm_err)
rc_edit_kwargs = {"linked_win": self.root_pass_edit}
self.root_confirm_edit.on_exit_kwargs = rc_edit_kwargs
# User account disabled, do not display related widgets.
if not self.show_user_account:
self.main_win.do_update()
self.center_win.activate_object(self.root_pass_list)
return
y_loc += 2
self.center_win.add_text(UserScreen.USER_TEXT, y_loc, 1,
self.win_size_x - 1)
y_loc += 2
self.list_area.y_loc = y_loc
self.error_area.y_loc = y_loc
self.real_name_err = ErrorWindow(self.error_area,
window=self.center_win)
self.real_name_list = ListItem(self.list_area, window=self.center_win,
text=UserScreen.NAME_LABEL)
self.real_name_edit = EditField(self.edit_area,
window=self.real_name_list,
error_win=self.real_name_err,
text=self.user.real_name)
y_loc += 1
self.list_area.y_loc = y_loc
self.error_area.y_loc = y_loc
self.username_err = ErrorWindow(self.error_area,
window=self.center_win)
self.username_list = ListItem(self.list_area,
window=self.center_win,
text=UserScreen.USERNAME_LABEL)
self.username_edit = EditField(self.username_edit_area,
window=self.username_list,
validate=username_valid,
error_win=self.username_err,
on_exit=login_valid,
text=self.user.login_name)
y_loc += 1
self.list_area.y_loc = y_loc
self.error_area.y_loc = y_loc
self.user_pass_err = ErrorWindow(self.error_area,
window=self.center_win)
self.user_pass_list = ListItem(self.list_area, window=self.center_win,
text=UserScreen.USER_PASS_LABEL)
self.user_pass_edit = PasswordField(self.edit_area,
window=self.user_pass_list,
error_win=self.user_pass_err,
fill=user_set)
y_loc += 1
self.list_area.y_loc = y_loc
self.error_area.y_loc = y_loc
self.user_confirm_err = ErrorWindow(self.error_area,
window=self.center_win)
self.user_confirm_list = ListItem(self.list_area,
window=self.center_win,
text=UserScreen.CONFIRM_LABEL)
self.user_confirm_edit = PasswordField(self.edit_area,
window=self.user_confirm_list,
on_exit=pass_match,
error_win=self.user_confirm_err,
fill=user_set)
uc_edit_kwargs = {"linked_win": self.user_pass_edit}
self.user_confirm_edit.on_exit_kwargs = uc_edit_kwargs
self.main_win.do_update()
self.center_win.activate_object(self.root_pass_list)
def on_change_screen(self):
'''Store entered information into data object cache.'''
if self.root_pass_edit.modified:
if self.root_pass_edit.compare(self.root_confirm_edit):
self.root.password = self.root_pass_edit.get_text()
else:
self.root.password = ""
if self.root.password is None:
self.root.password = ""
self.root_pass_edit.clear_text()
self.root_confirm_edit.clear_text()
#
# User account disabled, do not store related info into data object
# cache.
#
if not self.show_user_account:
return
self.user.real_name = self.real_name_edit.get_text()
self.user.login_name = self.username_edit.get_text()
# If user account is to be created, configure root account as a role.
self.root.is_role = bool(self.user.login_name)
if self.user_pass_edit.modified:
if self.user_pass_edit.compare(self.user_confirm_edit):
self.user.password = self.user_pass_edit.get_text()
else:
self.user.password = ""
if self.user.password is None:
self.user.password = ""
self.user_pass_edit.clear_text()
self.user_confirm_edit.clear_text()
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 home_zfs_parent_exists(self):
'''Return True if parent of to-be-created home ZFS dataset exists.
Otherwise, return False.
Home ZFS dataset is created in form of <root_pool>/export/home/<login>
with mountpoint /export/home/<login> inherited from parent dataset.
The check verifies that ZFS dataset with to-be-inherited /export/home
mountpoint exists.
'''
# obtain mountpoints for all existing ZFS datasets
cmd = [ZFS, "list", "-H", "-o", "mountpoint"]
try:
mountpoint_list = run(cmd, logger=LOGGER)
except CalledProcessError:
LOGGER.warn("Could not determine if parent of home ZFS dataset "
"exists.")
return False
if "/export/home" not in mountpoint_list.stdout.splitlines():
LOGGER.debug("Parent of home ZFS dataset does not exist, creation "
"of user account disabled.")
return False
LOGGER.debug("Parent of home ZFS dataset exists, creation of user "
"account enabled.")
return True
class NetworkTypeScreen(BaseScreen):
'''
Let the user:
- Choose the hostname
- Select network type (Automatic, Manual, or None)
'''
HEADER_TEXT = _("Network")
PARAGRAPH = _("Enter a name for this computer that identifies it on "
"the network. It must be at least two characters. It "
"can contain letters, numbers, and minus signs (-).")
HOSTNAME_TEXT = _("Computer Name: ")
NET_TYPE_TEXT = _("Select how the wired ethernet network "
"connection is configured.")
AUTO_TEXT = _("Automatically")
AUTO_DETAIL = _("Automatically configure the connection")
MANUAL_TEXT = _("Manually")
MANUAL_DETAIL = _("Enter the information on the following screen")
NONE_TEXT = _("None")
NONE_DETAIL = _("Do not configure the network at this time")
NO_NICS_FOUND = _("No wired network interfaces found. Additional "
"device drivers may be needed.")
ALL_NICS_FROMGZ = _("No configurable network interfaces found. They are "
"all controlled from global zone.")
ITEM_OFFSET = 2
ITEM_MAX_WIDTH = 17
ITEM_DESC_OFFSET = ITEM_MAX_WIDTH + ITEM_OFFSET + 1
HOSTNAME_SCREEN_LEN = 25
HELP_DATA = (SCI_HELP + "/%s/network.txt", _("Network"))
def __init__(self, main_win, configure_network=False):
global LOGGER
if LOGGER is None:
LOGGER = logging.getLogger(INSTALL_LOGGER_NAME + ".sysconfig")
super(NetworkTypeScreen, self).__init__(main_win)
self.hostfield_offset = textwidth(NetworkTypeScreen.HOSTNAME_TEXT)
self.menu_item_desc_max = (self.win_size_x -
NetworkTypeScreen.ITEM_DESC_OFFSET)
self.net_type_dict = {}
self.sys_info = None
self.automatic = None
self.manual = None
self.none_option = None
self.hostname = None
self.nic_info = NetworkInfo()
# find_links() returns tuple containing
# * dictionary of configurable NICs
# * number of NICs mandated from global zone.
#
# Taking that information into account, initialize type
# of network configuration:
# * FROMGZ - One or more link found, but all found links are
# controlled from global zone.
# * None - otherwise
#
# Set 'have_nic' flag to True if there is at least one configurable
# link, otherwise set the flag to False.
#
self.ether_nics, self.fromgz_num = NetworkInfo.find_links()
self.nic_info.type = NetworkInfo.NONE
self.have_nic = True
if len(self.ether_nics) == 0:
self.have_nic = False
if self.fromgz_num > 0:
self.nic_info.type = NetworkInfo.FROMGZ
self.configure_network = configure_network
def _show(self):
'''Create an EditField for entering hostname, and list items
for each of the network types
'''
sc_profile = solaris_install.sysconfig.profile.from_engine()
if sc_profile.system is None:
sc_profile.system = SystemInfo()
self.sys_info = sc_profile.system
if sc_profile.nic is None:
sc_profile.nic = self.nic_info
y_loc = 1
y_loc += self.center_win.add_paragraph(NetworkTypeScreen.PARAGRAPH,
y_loc)
y_loc += 1
self.center_win.add_text(NetworkTypeScreen.HOSTNAME_TEXT, y_loc)
max_cols = self.win_size_x - self.hostfield_offset
cols = min(max_cols, NetworkTypeScreen.HOSTNAME_SCREEN_LEN)
scrollable_columns = SystemInfo.MAX_HOSTNAME_LEN + 1
hostname_area = WindowArea(1,
cols,
y_loc,
self.hostfield_offset,
scrollable_columns=scrollable_columns)
self.hostname = EditField(hostname_area,
window=self.center_win,
text=self.sys_info.hostname,
validate=hostname_is_valid,
error_win=self.main_win.error_line)
self.hostname.item_key = None
# Display network configuration part of screen only if applicable.
if self.configure_network:
y_loc += 3
# If there are no configurable links, there is no point to let
# user select type of network configuration.
if not self.have_nic:
# Inform user that no network interfaces were found
# on the system.
# If this is the case of non-global zone with all links
# mandated from global zone, be more specific.
if self.nic_info.type == NetworkInfo.FROMGZ:
self.center_win.add_paragraph(
NetworkTypeScreen.ALL_NICS_FROMGZ, y_loc, 1)
else:
self.center_win.add_paragraph(
NetworkTypeScreen.NO_NICS_FOUND, y_loc, 1)
self.main_win.do_update()
activate = self.net_type_dict.get(self.nic_info.type,
self.hostname)
self.center_win.activate_object(activate)
return
self.main_win.do_update()
activate = self.net_type_dict.get(self.nic_info.type, self.hostname)
self.center_win.activate_object(activate)
def on_change_screen(self):
'''Save hostname and selected network type on change screen'''
if self.configure_network and self.have_nic:
self.nic_info.type = self.center_win.get_active_object().item_key
if self.nic_info.type is None:
self.nic_info.type = NetworkInfo.NONE
LOGGER.info("Configuring NIC as: %s", self.nic_info.type)
self.sys_info.hostname = self.hostname.get_text()
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."))
class DateTimeScreen(BaseScreen):
'''
Allow user to select year, month, day, hour, and minute to be
used to set system clock.
'''
HEADER_TEXT = _("Date and Time")
YEAR_TEXT = _("Year:")
MONTH_TEXT = _("Month:")
DAY_TEXT = _("Day:")
HOUR_TEXT = _("Hour:")
MINUTE_TEXT = _("Minute:")
YEAR_FORMAT = _("(YYYY)")
PARAGRAPH = _("Edit the date and time as necessary.\n"
"The time is in 24 hour format.")
HELP_DATA = (SCI_HELP + "/%s/date_time.txt",
_("Date and Time"))
YEAR_DIGITS = 4
TWO_DIGITS = 2
YEAR_LEN = len(YEAR_TEXT)
MONTH_LEN = len(MONTH_TEXT)
DAY_LEN = len(DAY_TEXT)
HOUR_LEN = len(HOUR_TEXT)
MINUTE_LEN = len(MINUTE_TEXT)
MAX_LEN = max(YEAR_LEN, MONTH_LEN, DAY_LEN, HOUR_LEN, MINUTE_LEN) + 1
ITEM_OFFSET = 2
def __init__(self, main_win):
global LOGGER
if LOGGER is None:
LOGGER = logging.getLogger(INSTALL_LOGGER_NAME + ".sysconfig")
super(DateTimeScreen, self).__init__(main_win)
year_edit_width = DateTimeScreen.YEAR_DIGITS + 1
list_width = DateTimeScreen.MAX_LEN + year_edit_width
self.list_area = WindowArea(1, list_width, 0,
DateTimeScreen.ITEM_OFFSET)
self.year_edit_area = WindowArea(1, year_edit_width, 0,
DateTimeScreen.MAX_LEN + 1)
other_edit_width = DateTimeScreen.TWO_DIGITS + 1
other_edit_offset = (DateTimeScreen.MAX_LEN +
(DateTimeScreen.YEAR_DIGITS -
DateTimeScreen.TWO_DIGITS) + 1)
self.edit_area = WindowArea(1, other_edit_width, 0, other_edit_offset)
self.info_offset = (DateTimeScreen.ITEM_OFFSET +
self.list_area.columns + 1)
self.info_width = len(DateTimeScreen.YEAR_FORMAT)
err_offset = self.info_offset + self.info_width + 2
err_width = self.win_size_x - err_offset
self.err_area = WindowArea(1, err_width, 0, err_offset)
self.year_edit = None
self.year_err = None
self.year_list = None
self.month_edit = None
self.month_err = None
self.month_list = None
self.day_edit = None
self.day_err = None
self.day_list = None
self.hour_edit = None
self.hour_err = None
self.hour_list = None
self.minute_edit = None
self.minute_err = None
self.minute_list = None
self.year_is_valid = True
self.month_is_valid = True
self.date_range_loc = None
self.saved_year = None
self.saved_month = None
self.saved_day = None
self.saved_hour = None
self.saved_minute = None
self.saved_days_in_month = None
def _show(self):
'''
Prepare the editable fields for day, month, year, hour and minute
'''
y_loc = 1
y_loc += self.center_win.add_paragraph(DateTimeScreen.PARAGRAPH, y_loc)
sc_profile = solaris_install.sysconfig.profile.from_engine()
os.environ["TZ"] = sc_profile.system.tz_timezone
now = datetime.datetime.now()
LOGGER.log(LOG_LEVEL_INPUT, "Current date (year-month-day hour:minute)"
": %s-%s-%s %s:%s", now.year, now.month, now.day, now.hour,
now.minute)
# Only update saved values if this is first time on screen or
# if we have saved offset in profile (F2, return to screen)
#
update_vals = False
if self.saved_year is None:
update_vals = True
showtime = now
elif sc_profile.system.time_offset != 0:
showtime = now + sc_profile.system.time_offset
update_vals = True
sc_profile.system.time_offset = 0
if update_vals:
self.saved_year = str(showtime.year)
self.saved_month = str(showtime.month)
self.saved_day = str(showtime.day)
self.saved_hour = str(showtime.hour)
self.saved_minute = str(showtime.minute)
self.saved_days_in_month = calendar.monthrange(showtime.year,
showtime.month)[1]
LOGGER.debug("starting year month day hour minute:_%s_%s_%s_%s_%s",
self.saved_year, self.saved_month, self.saved_day,
self.saved_hour, self.saved_minute)
LOGGER.debug("starting days_in_month: %s", self.saved_days_in_month)
y_loc += 1
self.err_area.y_loc = y_loc
self.list_area.y_loc = y_loc
self.year_err = ErrorWindow(self.err_area, window=self.center_win,
centered=False)
self.year_list = ListItem(self.list_area,
window=self.center_win,
text=DateTimeScreen.YEAR_TEXT)
self.year_edit = EditField(self.year_edit_area, window=self.year_list,
validate=year_valid,
error_win=self.year_err,
on_exit=year_on_exit,
text=self.saved_year)
self.year_edit.clear_on_enter = True
self.center_win.add_text(DateTimeScreen.YEAR_FORMAT, y_loc,
self.info_offset)
y_loc += 1
self.err_area.y_loc = y_loc
self.list_area.y_loc = y_loc
self.month_err = ErrorWindow(self.err_area, window=self.center_win,
centered=False)
self.month_list = ListItem(self.list_area, window=self.center_win,
text=DateTimeScreen.MONTH_TEXT)
self.month_edit = EditField(self.edit_area, window=self.month_list,
validate=month_valid,
error_win=self.month_err,
on_exit=month_on_exit,
text=self.saved_month,
numeric_pad="0")
self.month_edit.clear_on_enter = True
self.month_edit.right_justify = True
self.center_win.add_text("(1-12)", y_loc, self.info_offset)
y_loc += 1
self.err_area.y_loc = y_loc
self.list_area.y_loc = y_loc
self.day_err = ErrorWindow(self.err_area, window=self.center_win,
centered=False)
self.day_list = ListItem(self.list_area,
window=self.center_win,
text=DateTimeScreen.DAY_TEXT)
self.day_edit = EditField(self.edit_area, window=self.day_list,
validate=day_valid,
error_win=self.day_err,
on_exit=day_on_exit,
text=self.saved_day,
numeric_pad="0")
self.day_edit.clear_on_enter = True
self.day_edit.right_justify = True
self.month_edit.validate_kwargs["date_time"] = self
self.month_edit.validate_kwargs["year_edit"] = self.year_edit
self.month_edit.validate_kwargs["day_edit"] = self.day_edit
self.year_edit.validate_kwargs["date_time"] = self
self.year_edit.validate_kwargs["month_edit"] = self.month_edit
self.year_edit.validate_kwargs["day_edit"] = self.day_edit
self.day_edit.validate_kwargs["date_time"] = self
self.day_edit.validate_kwargs["year_edit"] = self.year_edit
self.day_edit.validate_kwargs["month_edit"] = self.month_edit
self.date_range_loc = (y_loc, self.info_offset)
self.update_day_range(self.saved_days_in_month)
y_loc += 1
self.err_area.y_loc = y_loc
self.list_area.y_loc = y_loc
self.hour_err = ErrorWindow(self.err_area, window=self.center_win,
centered=False)
self.hour_list = ListItem(self.list_area, window=self.center_win,
text=DateTimeScreen.HOUR_TEXT)
self.hour_edit = EditField(self.edit_area, window=self.hour_list,
validate=hour_valid,
error_win=self.hour_err,
on_exit=hour_on_exit,
text=self.saved_hour,
numeric_pad="0")
self.hour_edit.clear_on_enter = True
self.hour_edit.right_justify = True
self.center_win.add_text("(0-23)", y_loc, self.info_offset)
y_loc += 1
self.err_area.y_loc = y_loc
self.list_area.y_loc = y_loc
self.minute_err = ErrorWindow(self.err_area, window=self.center_win,
centered=False)
self.minute_list = ListItem(self.list_area, window=self.center_win,
text=DateTimeScreen.MINUTE_TEXT)
self.minute_edit = EditField(self.edit_area,
window=self.minute_list,
validate=minute_valid,
error_win=self.minute_err,
on_exit=minute_on_exit,
text=self.saved_minute,
numeric_pad="0")
self.minute_edit.clear_on_enter = True
self.minute_edit.right_justify = True
self.center_win.add_text("(0-59)", y_loc, self.info_offset)
self.main_win.do_update()
self.center_win.activate_object(self.year_list)
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 update_day_range(self, maxday=31):
'''
Update the day range displayed. The max number of days can vary
depending on the month, so calling functions can update appropriately.
'''
self.center_win.add_text("(1-%d)" % maxday,
self.date_range_loc[0],
self.date_range_loc[1],
self.win_size_x - 3)
self.saved_days_in_month = maxday
def on_change_screen(self):
'''Save current user input for return to screen'''
self.saved_year = self.year_edit.get_text()
self.saved_month = self.month_edit.get_text()
self.saved_day = self.day_edit.get_text()
self.saved_hour = self.hour_edit.get_text()
self.saved_minute = self.minute_edit.get_text()
def on_continue(self):
'''Save time offset to profile'''
saved_time = datetime.datetime(int(self.year_edit.get_text()),
int(self.month_edit.get_text()),
int(self.day_edit.get_text()),
int(self.hour_edit.get_text()),
int(self.minute_edit.get_text()))
userdelta = saved_time - datetime.datetime.now()
LOGGER.debug("delta time=%s", userdelta)
sc_profile = solaris_install.sysconfig.profile.from_engine()
sc_profile.system.time_offset = userdelta
install_datetime = datetime.datetime.now() + userdelta
LOGGER.debug("date command would be: /usr/bin/date %s",
install_datetime.strftime("%m%d%H%M%y"))
class DateTimeScreen(BaseScreen):
'''
Allow user to select year, month, day, hour, and minute to be
used to set system clock.
'''
HEADER_TEXT = _("Date and Time")
YEAR_TEXT = _("Year:")
MONTH_TEXT = _("Month:")
DAY_TEXT = _("Day:")
HOUR_TEXT = _("Hour:")
MINUTE_TEXT = _("Minute:")
YEAR_FORMAT = _("(YYYY)")
PARAGRAPH = _("Edit the date and time as necessary.\n"
"The time is in 24 hour format.")
HELP_DATA = (SCI_HELP + "/%s/date_time.txt", _("Date and Time"))
YEAR_DIGITS = 4
TWO_DIGITS = 2
YEAR_LEN = len(YEAR_TEXT)
MONTH_LEN = len(MONTH_TEXT)
DAY_LEN = len(DAY_TEXT)
HOUR_LEN = len(HOUR_TEXT)
MINUTE_LEN = len(MINUTE_TEXT)
MAX_LEN = max(YEAR_LEN, MONTH_LEN, DAY_LEN, HOUR_LEN, MINUTE_LEN) + 1
ITEM_OFFSET = 2
def __init__(self, main_win):
global LOGGER
if LOGGER is None:
LOGGER = logging.getLogger(INSTALL_LOGGER_NAME + ".sysconfig")
super(DateTimeScreen, self).__init__(main_win)
year_edit_width = DateTimeScreen.YEAR_DIGITS + 1
list_width = DateTimeScreen.MAX_LEN + year_edit_width
self.list_area = WindowArea(1, list_width, 0,
DateTimeScreen.ITEM_OFFSET)
self.year_edit_area = WindowArea(1, year_edit_width, 0,
DateTimeScreen.MAX_LEN + 1)
other_edit_width = DateTimeScreen.TWO_DIGITS + 1
other_edit_offset = (
DateTimeScreen.MAX_LEN +
(DateTimeScreen.YEAR_DIGITS - DateTimeScreen.TWO_DIGITS) + 1)
self.edit_area = WindowArea(1, other_edit_width, 0, other_edit_offset)
self.info_offset = (DateTimeScreen.ITEM_OFFSET +
self.list_area.columns + 1)
self.info_width = len(DateTimeScreen.YEAR_FORMAT)
err_offset = self.info_offset + self.info_width + 2
err_width = self.win_size_x - err_offset
self.err_area = WindowArea(1, err_width, 0, err_offset)
self.year_edit = None
self.year_err = None
self.year_list = None
self.month_edit = None
self.month_err = None
self.month_list = None
self.day_edit = None
self.day_err = None
self.day_list = None
self.hour_edit = None
self.hour_err = None
self.hour_list = None
self.minute_edit = None
self.minute_err = None
self.minute_list = None
self.year_is_valid = True
self.month_is_valid = True
self.date_range_loc = None
self.saved_year = None
self.saved_month = None
self.saved_day = None
self.saved_hour = None
self.saved_minute = None
self.saved_days_in_month = None
def _show(self):
'''
Prepare the editable fields for day, month, year, hour and minute
'''
y_loc = 1
y_loc += self.center_win.add_paragraph(DateTimeScreen.PARAGRAPH, y_loc)
sc_profile = solaris_install.sysconfig.profile.from_engine()
os.environ["TZ"] = sc_profile.system.tz_timezone
now = datetime.datetime.now()
LOGGER.log(
LOG_LEVEL_INPUT, "Current date (year-month-day hour:minute)"
": %s-%s-%s %s:%s", now.year, now.month, now.day, now.hour,
now.minute)
# Only update saved values if this is first time on screen or
# if we have saved offset in profile (F2, return to screen)
#
update_vals = False
if self.saved_year is None:
update_vals = True
showtime = now
elif sc_profile.system.time_offset != 0:
showtime = now + sc_profile.system.time_offset
update_vals = True
sc_profile.system.time_offset = 0
if update_vals:
self.saved_year = str(showtime.year)
self.saved_month = str(showtime.month)
self.saved_day = str(showtime.day)
self.saved_hour = str(showtime.hour)
self.saved_minute = str(showtime.minute)
self.saved_days_in_month = calendar.monthrange(
showtime.year, showtime.month)[1]
LOGGER.debug("starting year month day hour minute:_%s_%s_%s_%s_%s",
self.saved_year, self.saved_month, self.saved_day,
self.saved_hour, self.saved_minute)
LOGGER.debug("starting days_in_month: %s", self.saved_days_in_month)
y_loc += 1
self.err_area.y_loc = y_loc
self.list_area.y_loc = y_loc
self.year_err = ErrorWindow(self.err_area,
window=self.center_win,
centered=False)
self.year_list = ListItem(self.list_area,
window=self.center_win,
text=DateTimeScreen.YEAR_TEXT)
self.year_edit = EditField(self.year_edit_area,
window=self.year_list,
validate=year_valid,
error_win=self.year_err,
on_exit=year_on_exit,
text=self.saved_year)
self.year_edit.clear_on_enter = True
self.center_win.add_text(DateTimeScreen.YEAR_FORMAT, y_loc,
self.info_offset)
y_loc += 1
self.err_area.y_loc = y_loc
self.list_area.y_loc = y_loc
self.month_err = ErrorWindow(self.err_area,
window=self.center_win,
centered=False)
self.month_list = ListItem(self.list_area,
window=self.center_win,
text=DateTimeScreen.MONTH_TEXT)
self.month_edit = EditField(self.edit_area,
window=self.month_list,
validate=month_valid,
error_win=self.month_err,
on_exit=month_on_exit,
text=self.saved_month,
numeric_pad="0")
self.month_edit.clear_on_enter = True
self.month_edit.right_justify = True
self.center_win.add_text("(1-12)", y_loc, self.info_offset)
y_loc += 1
self.err_area.y_loc = y_loc
self.list_area.y_loc = y_loc
self.day_err = ErrorWindow(self.err_area,
window=self.center_win,
centered=False)
self.day_list = ListItem(self.list_area,
window=self.center_win,
text=DateTimeScreen.DAY_TEXT)
self.day_edit = EditField(self.edit_area,
window=self.day_list,
validate=day_valid,
error_win=self.day_err,
on_exit=day_on_exit,
text=self.saved_day,
numeric_pad="0")
self.day_edit.clear_on_enter = True
self.day_edit.right_justify = True
self.month_edit.validate_kwargs["date_time"] = self
self.month_edit.validate_kwargs["year_edit"] = self.year_edit
self.month_edit.validate_kwargs["day_edit"] = self.day_edit
self.year_edit.validate_kwargs["date_time"] = self
self.year_edit.validate_kwargs["month_edit"] = self.month_edit
self.year_edit.validate_kwargs["day_edit"] = self.day_edit
self.day_edit.validate_kwargs["date_time"] = self
self.day_edit.validate_kwargs["year_edit"] = self.year_edit
self.day_edit.validate_kwargs["month_edit"] = self.month_edit
self.date_range_loc = (y_loc, self.info_offset)
self.update_day_range(self.saved_days_in_month)
y_loc += 1
self.err_area.y_loc = y_loc
self.list_area.y_loc = y_loc
self.hour_err = ErrorWindow(self.err_area,
window=self.center_win,
centered=False)
self.hour_list = ListItem(self.list_area,
window=self.center_win,
text=DateTimeScreen.HOUR_TEXT)
self.hour_edit = EditField(self.edit_area,
window=self.hour_list,
validate=hour_valid,
error_win=self.hour_err,
on_exit=hour_on_exit,
text=self.saved_hour,
numeric_pad="0")
self.hour_edit.clear_on_enter = True
self.hour_edit.right_justify = True
self.center_win.add_text("(0-23)", y_loc, self.info_offset)
y_loc += 1
self.err_area.y_loc = y_loc
self.list_area.y_loc = y_loc
self.minute_err = ErrorWindow(self.err_area,
window=self.center_win,
centered=False)
self.minute_list = ListItem(self.list_area,
window=self.center_win,
text=DateTimeScreen.MINUTE_TEXT)
self.minute_edit = EditField(self.edit_area,
window=self.minute_list,
validate=minute_valid,
error_win=self.minute_err,
on_exit=minute_on_exit,
text=self.saved_minute,
numeric_pad="0")
self.minute_edit.clear_on_enter = True
self.minute_edit.right_justify = True
self.center_win.add_text("(0-59)", y_loc, self.info_offset)
self.main_win.do_update()
self.center_win.activate_object(self.year_list)
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 update_day_range(self, maxday=31):
'''
Update the day range displayed. The max number of days can vary
depending on the month, so calling functions can update appropriately.
'''
self.center_win.add_text("(1-%d)" % maxday, self.date_range_loc[0],
self.date_range_loc[1], self.win_size_x - 3)
self.saved_days_in_month = maxday
def on_change_screen(self):
'''Save current user input for return to screen'''
self.saved_year = self.year_edit.get_text()
self.saved_month = self.month_edit.get_text()
self.saved_day = self.day_edit.get_text()
self.saved_hour = self.hour_edit.get_text()
self.saved_minute = self.minute_edit.get_text()
def on_continue(self):
'''Save time offset to profile'''
saved_time = datetime.datetime(int(self.year_edit.get_text()),
int(self.month_edit.get_text()),
int(self.day_edit.get_text()),
int(self.hour_edit.get_text()),
int(self.minute_edit.get_text()))
userdelta = saved_time - datetime.datetime.now()
LOGGER.debug("delta time=%s", userdelta)
sc_profile = solaris_install.sysconfig.profile.from_engine()
sc_profile.system.time_offset = userdelta
install_datetime = datetime.datetime.now() + userdelta
LOGGER.debug("date command would be: /usr/bin/date %s",
install_datetime.strftime("%m%d%H%M%y"))
class ValidSample(BaseScreen):
HEADER_TEXT = "Validation - Sample"
def __init__(self, main_win):
super(ValidSample, self).__init__(main_win)
# Boilerplate; for storing references to the created ListItems,
# EditFields, and ErrorWindows
self.char_list = None
self.char_field = None
self.char2_list = None
self.char2_field = None
self.char2_err = None
self.focus_list = None
self.focus_field = None
self.focus_err = None
def _show(self):
# WindowArea boilerplate
list_area = WindowArea(lines=1, columns=40, y_loc=1, x_loc=1)
edit_area = WindowArea(lines=1, columns=20, y_loc=0, x_loc=15)
# EditFields support per-character validation by passing in
# a callback function as the "validate" keyword argument. The function
# is called after each keypress with a single parameter, the EditField
# in question (from which one can grab the current text). If the
# current value is valid, the function should do nothing. If invalid,
# a UIMessage exception should be raised.
# For the sake of 'flow', the validation functions for this sample
# will be defined inline; in general, they should be defined elsewhere
# in the file. Finally, remember that, since these functions are
# called after each keystroke, they need to be able to handle partially
# correct values as well. For example, "2", "25", "255", "255.",
# "255.2", "255.25", ..., "255.255.255.0" all would need to be accepted
# by a netmask validation function.
def digits_only(edit_field):
text = edit_field.get_text()
if text and not text.isdigit():
raise UIMessage("Only digits allowed!")
list_area.y_loc = 1
self.char_list = ListItem(list_area, window=self.center_win,
text="validate:")
self.char_edit = EditField(edit_area,
window=self.char_list,
validate=digits_only,
error_win=self.main_win.error_line)
# The error_win parameter is required to make anything meaningful
# display to the user; it should be a reference to an ErrorWindow
# object in which to display the message. (self.main_win.error_line
# is used here as filler; a more appropriate example follows)
list_area.y_loc = 2
# There's nothing too special about creating an ErrorWindow;
# it's much like a ListItem or EditField:
error_area = WindowArea(lines=1, columns=30, y_loc=2, x_loc=40)
self.char2_err = ErrorWindow(error_area, self.center_win)
self.char2_list = ListItem(list_area, window=self.center_win,
text="validate(2):")
self.char2_edit = EditField(edit_area,
window=self.char2_list,
validate=digits_only,
error_win=self.char2_err)
# An EditField can also be checked for validity on loss of focus,
# by passing a function to the "on_exit" argument
# (though care must be taken to also check validity when changing
# screens; screen changes don't trigger loss-of-focus checks in the
# same way)
# The following EditField illustrates such a thing. (An on_exit
# function would be an appropriate place to ensure that a user
# entered "255.255.255.0" for a netmask, and not just "255.")
list_area.y_loc = 3
error_area.y_loc = 3
self.focus_err = ErrorWindow(error_area, self.center_win)
self.focus_list = ListItem(list_area, window=self.center_win,
text="on_exit:")
self.focus_edit = EditField(edit_area,
window=self.focus_list,
on_exit=digits_only,
error_win=self.focus_err)
self.center_win.activate_object()
def validate(self):
# As a final (and perhaps, most important) form of validation, when
# a subclass of BaseScreen attempts to move *forward* to the next
# screen, it will call its "validate()" function, if any. Like the
# callback functions for EditFields, this function should raise a
# UIMessage if there are any conditions which fail validation.
#
# validate() is not called if the user decides to go backwards; the
# user is never locked out of reversing their direction
#
# Note: validate() is always called prior to "on_continue()"; thus,
# any code in the on_continue function, if defined, can be certain
# that the values for this screen are valid.
# For this sample, the first two fields will be required to have
# identical text.
if self.char_edit.get_text() != self.char2_edit.get_text():
raise UIMessage("First 2 fields must have identical text!")
def _show(self):
# WindowArea boilerplate
list_area = WindowArea(lines=1, columns=40, y_loc=1, x_loc=1)
edit_area = WindowArea(lines=1, columns=20, y_loc=0, x_loc=15)
# EditFields support per-character validation by passing in
# a callback function as the "validate" keyword argument. The function
# is called after each keypress with a single parameter, the EditField
# in question (from which one can grab the current text). If the
# current value is valid, the function should do nothing. If invalid,
# a UIMessage exception should be raised.
# For the sake of 'flow', the validation functions for this sample
# will be defined inline; in general, they should be defined elsewhere
# in the file. Finally, remember that, since these functions are
# called after each keystroke, they need to be able to handle partially
# correct values as well. For example, "2", "25", "255", "255.",
# "255.2", "255.25", ..., "255.255.255.0" all would need to be accepted
# by a netmask validation function.
def digits_only(edit_field):
text = edit_field.get_text()
if text and not text.isdigit():
raise UIMessage("Only digits allowed!")
list_area.y_loc = 1
self.char_list = ListItem(list_area, window=self.center_win,
text="validate:")
self.char_edit = EditField(edit_area,
window=self.char_list,
validate=digits_only,
error_win=self.main_win.error_line)
# The error_win parameter is required to make anything meaningful
# display to the user; it should be a reference to an ErrorWindow
# object in which to display the message. (self.main_win.error_line
# is used here as filler; a more appropriate example follows)
list_area.y_loc = 2
# There's nothing too special about creating an ErrorWindow;
# it's much like a ListItem or EditField:
error_area = WindowArea(lines=1, columns=30, y_loc=2, x_loc=40)
self.char2_err = ErrorWindow(error_area, self.center_win)
self.char2_list = ListItem(list_area, window=self.center_win,
text="validate(2):")
self.char2_edit = EditField(edit_area,
window=self.char2_list,
validate=digits_only,
error_win=self.char2_err)
# An EditField can also be checked for validity on loss of focus,
# by passing a function to the "on_exit" argument
# (though care must be taken to also check validity when changing
# screens; screen changes don't trigger loss-of-focus checks in the
# same way)
# The following EditField illustrates such a thing. (An on_exit
# function would be an appropriate place to ensure that a user
# entered "255.255.255.0" for a netmask, and not just "255.")
list_area.y_loc = 3
error_area.y_loc = 3
self.focus_err = ErrorWindow(error_area, self.center_win)
self.focus_list = ListItem(list_area, window=self.center_win,
text="on_exit:")
self.focus_edit = EditField(edit_area,
window=self.focus_list,
on_exit=digits_only,
error_win=self.focus_err)
self.center_win.activate_object()
def _show(self):
# WindowArea boilerplate
list_area = WindowArea(lines=1, columns=40, y_loc=1, x_loc=1)
edit_area = WindowArea(lines=1, columns=20, y_loc=0, x_loc=15)
# EditFields support per-character validation by passing in
# a callback function as the "validate" keyword argument. The function
# is called after each keypress with a single parameter, the EditField
# in question (from which one can grab the current text). If the
# current value is valid, the function should do nothing. If invalid,
# a UIMessage exception should be raised.
# For the sake of 'flow', the validation functions for this sample
# will be defined inline; in general, they should be defined elsewhere
# in the file. Finally, remember that, since these functions are
# called after each keystroke, they need to be able to handle partially
# correct values as well. For example, "2", "25", "255", "255.",
# "255.2", "255.25", ..., "255.255.255.0" all would need to be accepted
# by a netmask validation function.
def digits_only(edit_field):
text = edit_field.get_text()
if text and not text.isdigit():
raise UIMessage("Only digits allowed!")
list_area.y_loc = 1
self.char_list = ListItem(list_area, window=self.center_win,
text="validate:")
self.char_edit = EditField(edit_area,
window=self.char_list,
validate=digits_only,
error_win=self.main_win.error_line)
# The error_win parameter is required to make anything meaningful
# display to the user; it should be a reference to an ErrorWindow
# object in which to display the message. (self.main_win.error_line
# is used here as filler; a more appropriate example follows)
list_area.y_loc = 2
# There's nothing too special about creating an ErrorWindow;
# it's much like a ListItem or EditField:
error_area = WindowArea(lines=1, columns=30, y_loc=2, x_loc=40)
self.char2_err = ErrorWindow(error_area, self.center_win)
self.char2_list = ListItem(list_area, window=self.center_win,
text="validate(2):")
self.char2_edit = EditField(edit_area,
window=self.char2_list,
validate=digits_only,
error_win=self.char2_err)
# An EditField can also be checked for validity on loss of focus,
# by passing a function to the "on_exit" argument
# (though care must be taken to also check validity when changing
# screens; screen changes don't trigger loss-of-focus checks in the
# same way)
# The following EditField illustrates such a thing. (An on_exit
# function would be an appropriate place to ensure that a user
# entered "255.255.255.0" for a netmask, and not just "255.")
list_area.y_loc = 3
error_area.y_loc = 3
self.focus_err = ErrorWindow(error_area, self.center_win)
self.focus_list = ListItem(list_area, window=self.center_win,
text="on_exit:")
self.focus_edit = EditField(edit_area,
window=self.focus_list,
on_exit=digits_only,
error_win=self.focus_err)
self.center_win.activate_object()
class ValidSample(BaseScreen):
HEADER_TEXT = "Validation - Sample"
def __init__(self, main_win):
super(ValidSample, self).__init__(main_win)
# Boilerplate; for storing references to the created ListItems,
# EditFields, and ErrorWindows
self.char_list = None
self.char_field = None
self.char2_list = None
self.char2_field = None
self.char2_err = None
self.focus_list = None
self.focus_field = None
self.focus_err = None
def _show(self):
# WindowArea boilerplate
list_area = WindowArea(lines=1, columns=40, y_loc=1, x_loc=1)
edit_area = WindowArea(lines=1, columns=20, y_loc=0, x_loc=15)
# EditFields support per-character validation by passing in
# a callback function as the "validate" keyword argument. The function
# is called after each keypress with a single parameter, the EditField
# in question (from which one can grab the current text). If the
# current value is valid, the function should do nothing. If invalid,
# a UIMessage exception should be raised.
# For the sake of 'flow', the validation functions for this sample
# will be defined inline; in general, they should be defined elsewhere
# in the file. Finally, remember that, since these functions are
# called after each keystroke, they need to be able to handle partially
# correct values as well. For example, "2", "25", "255", "255.",
# "255.2", "255.25", ..., "255.255.255.0" all would need to be accepted
# by a netmask validation function.
def digits_only(edit_field):
text = edit_field.get_text()
if text and not text.isdigit():
raise UIMessage("Only digits allowed!")
list_area.y_loc = 1
self.char_list = ListItem(list_area, window=self.center_win,
text="validate:")
self.char_edit = EditField(edit_area,
window=self.char_list,
validate=digits_only,
error_win=self.main_win.error_line)
# The error_win parameter is required to make anything meaningful
# display to the user; it should be a reference to an ErrorWindow
# object in which to display the message. (self.main_win.error_line
# is used here as filler; a more appropriate example follows)
list_area.y_loc = 2
# There's nothing too special about creating an ErrorWindow;
# it's much like a ListItem or EditField:
error_area = WindowArea(lines=1, columns=30, y_loc=2, x_loc=40)
self.char2_err = ErrorWindow(error_area, self.center_win)
self.char2_list = ListItem(list_area, window=self.center_win,
text="validate(2):")
self.char2_edit = EditField(edit_area,
window=self.char2_list,
validate=digits_only,
error_win=self.char2_err)
# An EditField can also be checked for validity on loss of focus,
# by passing a function to the "on_exit" argument
# (though care must be taken to also check validity when changing
# screens; screen changes don't trigger loss-of-focus checks in the
# same way)
# The following EditField illustrates such a thing. (An on_exit
# function would be an appropriate place to ensure that a user
# entered "255.255.255.0" for a netmask, and not just "255.")
list_area.y_loc = 3
error_area.y_loc = 3
self.focus_err = ErrorWindow(error_area, self.center_win)
self.focus_list = ListItem(list_area, window=self.center_win,
text="on_exit:")
self.focus_edit = EditField(edit_area,
window=self.focus_list,
on_exit=digits_only,
error_win=self.focus_err)
self.center_win.activate_object()
def validate(self):
# As a final (and perhaps, most important) form of validation, when
# a subclass of BaseScreen attempts to move *forward* to the next
# screen, it will call its "validate()" function, if any. Like the
# callback functions for EditFields, this function should raise a
# UIMessage if there are any conditions which fail validation.
#
# validate() is not called if the user decides to go backwards; the
# user is never locked out of reversing their direction
#
# Note: validate() is always called prior to "on_continue()"; thus,
# any code in the on_continue function, if defined, can be certain
# that the values for this screen are valid.
# For this sample, the first two fields will be required to have
# identical text.
if self.char_edit.get_text() != self.char2_edit.get_text():
raise UIMessage("First 2 fields must have identical text!")
def _show(self):
'''Display the user name, real name, and password fields'''
sc_profile = solaris_install.sysconfig.profile.from_engine()
#
# Create UserInfo instances holding information about root and user
# accounts.
#
if sc_profile.users is None:
#
# Assume root is a normal account. It will be changed to a role
# if the user account is created.
#
root = UserInfo(login_name="root", is_role=False)
#
# Initialize attributes of user account which can't be configured
# on screens.
#
user = UserInfo(gid=10,
shell="/usr/bin/bash",
roles="root",
profiles="System Administrator",
sudoers="ALL=(ALL) ALL")
sc_profile.users = UserInfoContainer(root, user)
self.root = sc_profile.users.root
self.user = sc_profile.users.user
LOGGER.debug("Root: %s", self.root)
LOGGER.debug("User: %s", self.user)
root_set = (self.root.passlen != 0)
user_set = (self.user.passlen != 0)
y_loc = 1
if self.show_user_account:
intro_text = UserScreen.INTRO_SHOW_USER
else:
intro_text = UserScreen.INTRO_HIDE_USER
self.center_win.add_paragraph(intro_text, y_loc, 1, y_loc + 2,
self.win_size_x - 1)
y_loc += 3
self.center_win.add_text(UserScreen.ROOT_TEXT, y_loc, 1,
self.win_size_x - 1)
y_loc += 2
self.error_area.y_loc = y_loc
self.list_area.y_loc = y_loc
self.root_pass_err = ErrorWindow(self.error_area,
window=self.center_win)
self.root_pass_list = ListItem(self.list_area,
window=self.center_win,
text=UserScreen.ROOT_LABEL)
self.root_pass_edit = PasswordField(self.edit_area,
window=self.root_pass_list,
error_win=self.root_pass_err,
fill=root_set)
y_loc += 1
self.error_area.y_loc = y_loc
self.list_area.y_loc = y_loc
self.root_confirm_err = ErrorWindow(self.error_area,
window=self.center_win)
self.root_confirm_list = ListItem(self.list_area,
window=self.center_win,
text=UserScreen.CONFIRM_LABEL)
self.root_confirm_edit = PasswordField(self.edit_area,
window=self.root_confirm_list,
fill=root_set,
on_exit=pass_match,
error_win=self.root_confirm_err)
rc_edit_kwargs = {"linked_win": self.root_pass_edit}
self.root_confirm_edit.on_exit_kwargs = rc_edit_kwargs
# User account disabled, do not display related widgets.
if not self.show_user_account:
self.main_win.do_update()
self.center_win.activate_object(self.root_pass_list)
return
y_loc += 2
self.center_win.add_text(UserScreen.USER_TEXT, y_loc, 1,
self.win_size_x - 1)
y_loc += 2
self.list_area.y_loc = y_loc
self.error_area.y_loc = y_loc
self.real_name_err = ErrorWindow(self.error_area,
window=self.center_win)
self.real_name_list = ListItem(self.list_area,
window=self.center_win,
text=UserScreen.NAME_LABEL)
self.real_name_edit = EditField(self.edit_area,
window=self.real_name_list,
error_win=self.real_name_err,
text=self.user.real_name)
y_loc += 1
self.list_area.y_loc = y_loc
self.error_area.y_loc = y_loc
self.username_err = ErrorWindow(self.error_area,
window=self.center_win)
self.username_list = ListItem(self.list_area,
window=self.center_win,
text=UserScreen.USERNAME_LABEL)
self.username_edit = EditField(self.username_edit_area,
window=self.username_list,
validate=username_valid,
error_win=self.username_err,
on_exit=login_valid,
text=self.user.login_name)
y_loc += 1
self.list_area.y_loc = y_loc
self.error_area.y_loc = y_loc
self.user_pass_err = ErrorWindow(self.error_area,
window=self.center_win)
self.user_pass_list = ListItem(self.list_area,
window=self.center_win,
text=UserScreen.USER_PASS_LABEL)
self.user_pass_edit = PasswordField(self.edit_area,
window=self.user_pass_list,
error_win=self.user_pass_err,
fill=user_set)
y_loc += 1
self.list_area.y_loc = y_loc
self.error_area.y_loc = y_loc
self.user_confirm_err = ErrorWindow(self.error_area,
window=self.center_win)
self.user_confirm_list = ListItem(self.list_area,
window=self.center_win,
text=UserScreen.CONFIRM_LABEL)
self.user_confirm_edit = PasswordField(self.edit_area,
window=self.user_confirm_list,
on_exit=pass_match,
error_win=self.user_confirm_err,
fill=user_set)
uc_edit_kwargs = {"linked_win": self.user_pass_edit}
self.user_confirm_edit.on_exit_kwargs = uc_edit_kwargs
self.main_win.do_update()
self.center_win.activate_object(self.root_pass_list)
class NSLDAPProfile(NameService):
HEADER_TEXT = _("LDAP Profile")
HELP_DATA = (SCI_HELP + "/%s/ldap_profile.txt", HEADER_TEXT)
def __init__(self, main_win):
super(NSLDAPProfile, self).__init__(main_win)
self.title = _("Profile name:")
self.title3 = _("Search base:")
def _show(self):
super(NSLDAPProfile, self)._show()
if self.nameservice.nameservice != 'LDAP':
raise SkipException
if self.nameservice.dns:
self.intro = \
_("Specify the name of the LDAP profile to be used to "
"configure this system and the host name or IP address of "
"the server that contains the profile.")
self.title2 = _("Profile server host name or IP address:")
else:
self.intro = \
_("Specify the name of the LDAP profile to be used to "
"configure this system and the IP address of the "
"server that contains the profile.")
self.title2 = _("Profile server IP address:")
self.intro += _(" Enter the LDAP search base.")
y_loc = self._paint_opening()
maxtitlelen = max(textwidth(self.title), textwidth(self.title2),
textwidth(self.title3))
aligned_x_loc = maxtitlelen + INDENT + 1
cols = self.win_size_x - aligned_x_loc
self.center_win.add_text(self.title.rjust(maxtitlelen), y_loc, INDENT)
area = WindowArea(1, cols, y_loc, aligned_x_loc)
self.ldap_profile = EditField(area, window=self.center_win,
text=self.nameservice.ldap_profile,
error_win=self.main_win.error_line,
validate=inc_validate_nowhite_nospecial)
# in case of error, tell user what is being validated
self.ldap_profile.validate_kwargs['etext'] = _('profile name')
y_loc += 1
area = WindowArea(1, cols, y_loc, aligned_x_loc,
scrollable_columns=NameService.HOSTNAME_SCREEN_LEN + 1)
self.center_win.add_text(self.title2.rjust(maxtitlelen), y_loc, INDENT)
# create edit field, validating for host name or IP address depending
# on whether DNS was selected
self.ldap_ip = EditField(area, window=self.center_win,
text=self.nameservice.ldap_ip,
error_win=self.main_win.error_line,
validate=(incremental_validate_host
if self.nameservice.dns
else incremental_validate_ip))
# search base
y_loc += 1
self.center_win.add_text(self.title3.rjust(maxtitlelen), y_loc, INDENT)
area = WindowArea(1, cols, y_loc, aligned_x_loc,
scrollable_columns=MAXDNLEN + 1)
self.ldap_search_base = EditField(area, window=self.center_win,
text=self.nameservice.ldap_search_base,
error_win=self.main_win.error_line)
self.main_win.do_update()
self.center_win.activate_object(self.ldap_ip)
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 on_change_screen(self):
self.nameservice.ldap_profile = self.ldap_profile.get_text()
self.nameservice.ldap_ip = self.ldap_ip.get_text()
new_search_base = self.ldap_search_base.get_text()
if new_search_base != self.nameservice.ldap_search_base:
self.nameservice.ldap_search_base = new_search_base
# update DN with any changes in search_base from user
fixedbase = _ldap_domain_fixup(self.nameservice.ldap_pb_dn,
new_search_base)
if fixedbase:
self.nameservice.ldap_pb_dn = fixedbase
def _show(self):
'''
Prepare the editable fields for day, month, year, hour and minute
'''
y_loc = 1
y_loc += self.center_win.add_paragraph(DateTimeScreen.PARAGRAPH, y_loc)
sc_profile = solaris_install.sysconfig.profile.from_engine()
os.environ["TZ"] = sc_profile.system.tz_timezone
now = datetime.datetime.now()
LOGGER.log(LOG_LEVEL_INPUT, "Current date (year-month-day hour:minute)"
": %s-%s-%s %s:%s", now.year, now.month, now.day, now.hour,
now.minute)
# Only update saved values if this is first time on screen or
# if we have saved offset in profile (F2, return to screen)
#
update_vals = False
if self.saved_year is None:
update_vals = True
showtime = now
elif sc_profile.system.time_offset != 0:
showtime = now + sc_profile.system.time_offset
update_vals = True
sc_profile.system.time_offset = 0
if update_vals:
self.saved_year = str(showtime.year)
self.saved_month = str(showtime.month)
self.saved_day = str(showtime.day)
self.saved_hour = str(showtime.hour)
self.saved_minute = str(showtime.minute)
self.saved_days_in_month = calendar.monthrange(showtime.year,
showtime.month)[1]
LOGGER.debug("starting year month day hour minute:_%s_%s_%s_%s_%s",
self.saved_year, self.saved_month, self.saved_day,
self.saved_hour, self.saved_minute)
LOGGER.debug("starting days_in_month: %s", self.saved_days_in_month)
y_loc += 1
self.err_area.y_loc = y_loc
self.list_area.y_loc = y_loc
self.year_err = ErrorWindow(self.err_area, window=self.center_win,
centered=False)
self.year_list = ListItem(self.list_area,
window=self.center_win,
text=DateTimeScreen.YEAR_TEXT)
self.year_edit = EditField(self.year_edit_area, window=self.year_list,
validate=year_valid,
error_win=self.year_err,
on_exit=year_on_exit,
text=self.saved_year)
self.year_edit.clear_on_enter = True
self.center_win.add_text(DateTimeScreen.YEAR_FORMAT, y_loc,
self.info_offset)
y_loc += 1
self.err_area.y_loc = y_loc
self.list_area.y_loc = y_loc
self.month_err = ErrorWindow(self.err_area, window=self.center_win,
centered=False)
self.month_list = ListItem(self.list_area, window=self.center_win,
text=DateTimeScreen.MONTH_TEXT)
self.month_edit = EditField(self.edit_area, window=self.month_list,
validate=month_valid,
error_win=self.month_err,
on_exit=month_on_exit,
text=self.saved_month,
numeric_pad="0")
self.month_edit.clear_on_enter = True
self.month_edit.right_justify = True
self.center_win.add_text("(1-12)", y_loc, self.info_offset)
y_loc += 1
self.err_area.y_loc = y_loc
self.list_area.y_loc = y_loc
self.day_err = ErrorWindow(self.err_area, window=self.center_win,
centered=False)
self.day_list = ListItem(self.list_area,
window=self.center_win,
text=DateTimeScreen.DAY_TEXT)
self.day_edit = EditField(self.edit_area, window=self.day_list,
validate=day_valid,
error_win=self.day_err,
on_exit=day_on_exit,
text=self.saved_day,
numeric_pad="0")
self.day_edit.clear_on_enter = True
self.day_edit.right_justify = True
self.month_edit.validate_kwargs["date_time"] = self
self.month_edit.validate_kwargs["year_edit"] = self.year_edit
self.month_edit.validate_kwargs["day_edit"] = self.day_edit
self.year_edit.validate_kwargs["date_time"] = self
self.year_edit.validate_kwargs["month_edit"] = self.month_edit
self.year_edit.validate_kwargs["day_edit"] = self.day_edit
self.day_edit.validate_kwargs["date_time"] = self
self.day_edit.validate_kwargs["year_edit"] = self.year_edit
self.day_edit.validate_kwargs["month_edit"] = self.month_edit
self.date_range_loc = (y_loc, self.info_offset)
self.update_day_range(self.saved_days_in_month)
y_loc += 1
self.err_area.y_loc = y_loc
self.list_area.y_loc = y_loc
self.hour_err = ErrorWindow(self.err_area, window=self.center_win,
centered=False)
self.hour_list = ListItem(self.list_area, window=self.center_win,
text=DateTimeScreen.HOUR_TEXT)
self.hour_edit = EditField(self.edit_area, window=self.hour_list,
validate=hour_valid,
error_win=self.hour_err,
on_exit=hour_on_exit,
text=self.saved_hour,
numeric_pad="0")
self.hour_edit.clear_on_enter = True
self.hour_edit.right_justify = True
self.center_win.add_text("(0-23)", y_loc, self.info_offset)
y_loc += 1
self.err_area.y_loc = y_loc
self.list_area.y_loc = y_loc
self.minute_err = ErrorWindow(self.err_area, window=self.center_win,
centered=False)
self.minute_list = ListItem(self.list_area, window=self.center_win,
text=DateTimeScreen.MINUTE_TEXT)
self.minute_edit = EditField(self.edit_area,
window=self.minute_list,
validate=minute_valid,
error_win=self.minute_err,
on_exit=minute_on_exit,
text=self.saved_minute,
numeric_pad="0")
self.minute_edit.clear_on_enter = True
self.minute_edit.right_justify = True
self.center_win.add_text("(0-59)", y_loc, self.info_offset)
self.main_win.do_update()
self.center_win.activate_object(self.year_list)
def _show(self):
'''
Prepare the editable fields for day, month, year, hour and minute
'''
y_loc = 1
y_loc += self.center_win.add_paragraph(DateTimeScreen.PARAGRAPH, y_loc)
sc_profile = solaris_install.sysconfig.profile.from_engine()
os.environ["TZ"] = sc_profile.system.tz_timezone
now = datetime.datetime.now()
LOGGER.log(
LOG_LEVEL_INPUT, "Current date (year-month-day hour:minute)"
": %s-%s-%s %s:%s", now.year, now.month, now.day, now.hour,
now.minute)
# Only update saved values if this is first time on screen or
# if we have saved offset in profile (F2, return to screen)
#
update_vals = False
if self.saved_year is None:
update_vals = True
showtime = now
elif sc_profile.system.time_offset != 0:
showtime = now + sc_profile.system.time_offset
update_vals = True
sc_profile.system.time_offset = 0
if update_vals:
self.saved_year = str(showtime.year)
self.saved_month = str(showtime.month)
self.saved_day = str(showtime.day)
self.saved_hour = str(showtime.hour)
self.saved_minute = str(showtime.minute)
self.saved_days_in_month = calendar.monthrange(
showtime.year, showtime.month)[1]
LOGGER.debug("starting year month day hour minute:_%s_%s_%s_%s_%s",
self.saved_year, self.saved_month, self.saved_day,
self.saved_hour, self.saved_minute)
LOGGER.debug("starting days_in_month: %s", self.saved_days_in_month)
y_loc += 1
self.err_area.y_loc = y_loc
self.list_area.y_loc = y_loc
self.year_err = ErrorWindow(self.err_area,
window=self.center_win,
centered=False)
self.year_list = ListItem(self.list_area,
window=self.center_win,
text=DateTimeScreen.YEAR_TEXT)
self.year_edit = EditField(self.year_edit_area,
window=self.year_list,
validate=year_valid,
error_win=self.year_err,
on_exit=year_on_exit,
text=self.saved_year)
self.year_edit.clear_on_enter = True
self.center_win.add_text(DateTimeScreen.YEAR_FORMAT, y_loc,
self.info_offset)
y_loc += 1
self.err_area.y_loc = y_loc
self.list_area.y_loc = y_loc
self.month_err = ErrorWindow(self.err_area,
window=self.center_win,
centered=False)
self.month_list = ListItem(self.list_area,
window=self.center_win,
text=DateTimeScreen.MONTH_TEXT)
self.month_edit = EditField(self.edit_area,
window=self.month_list,
validate=month_valid,
error_win=self.month_err,
on_exit=month_on_exit,
text=self.saved_month,
numeric_pad="0")
self.month_edit.clear_on_enter = True
self.month_edit.right_justify = True
self.center_win.add_text("(1-12)", y_loc, self.info_offset)
y_loc += 1
self.err_area.y_loc = y_loc
self.list_area.y_loc = y_loc
self.day_err = ErrorWindow(self.err_area,
window=self.center_win,
centered=False)
self.day_list = ListItem(self.list_area,
window=self.center_win,
text=DateTimeScreen.DAY_TEXT)
self.day_edit = EditField(self.edit_area,
window=self.day_list,
validate=day_valid,
error_win=self.day_err,
on_exit=day_on_exit,
text=self.saved_day,
numeric_pad="0")
self.day_edit.clear_on_enter = True
self.day_edit.right_justify = True
self.month_edit.validate_kwargs["date_time"] = self
self.month_edit.validate_kwargs["year_edit"] = self.year_edit
self.month_edit.validate_kwargs["day_edit"] = self.day_edit
self.year_edit.validate_kwargs["date_time"] = self
self.year_edit.validate_kwargs["month_edit"] = self.month_edit
self.year_edit.validate_kwargs["day_edit"] = self.day_edit
self.day_edit.validate_kwargs["date_time"] = self
self.day_edit.validate_kwargs["year_edit"] = self.year_edit
self.day_edit.validate_kwargs["month_edit"] = self.month_edit
self.date_range_loc = (y_loc, self.info_offset)
self.update_day_range(self.saved_days_in_month)
y_loc += 1
self.err_area.y_loc = y_loc
self.list_area.y_loc = y_loc
self.hour_err = ErrorWindow(self.err_area,
window=self.center_win,
centered=False)
self.hour_list = ListItem(self.list_area,
window=self.center_win,
text=DateTimeScreen.HOUR_TEXT)
self.hour_edit = EditField(self.edit_area,
window=self.hour_list,
validate=hour_valid,
error_win=self.hour_err,
on_exit=hour_on_exit,
text=self.saved_hour,
numeric_pad="0")
self.hour_edit.clear_on_enter = True
self.hour_edit.right_justify = True
self.center_win.add_text("(0-23)", y_loc, self.info_offset)
y_loc += 1
self.err_area.y_loc = y_loc
self.list_area.y_loc = y_loc
self.minute_err = ErrorWindow(self.err_area,
window=self.center_win,
centered=False)
self.minute_list = ListItem(self.list_area,
window=self.center_win,
text=DateTimeScreen.MINUTE_TEXT)
self.minute_edit = EditField(self.edit_area,
window=self.minute_list,
validate=minute_valid,
error_win=self.minute_err,
on_exit=minute_on_exit,
text=self.saved_minute,
numeric_pad="0")
self.minute_edit.clear_on_enter = True
self.minute_edit.right_justify = True
self.center_win.add_text("(0-59)", y_loc, self.info_offset)
self.main_win.do_update()
self.center_win.activate_object(self.year_list)
def _show(self):
'''Create an EditField for entering hostname, and list items
for each of the network types
'''
sc_profile = solaris_install.sysconfig.profile.from_engine()
if sc_profile.system is None:
sc_profile.system = SystemInfo()
self.sys_info = sc_profile.system
if sc_profile.nic is None:
sc_profile.nic = self.nic_info
y_loc = 1
y_loc += self.center_win.add_paragraph(NetworkTypeScreen.PARAGRAPH,
y_loc)
y_loc += 1
self.center_win.add_text(NetworkTypeScreen.HOSTNAME_TEXT, y_loc)
max_cols = self.win_size_x - self.hostfield_offset
cols = min(max_cols, NetworkTypeScreen.HOSTNAME_SCREEN_LEN)
scrollable_columns = SystemInfo.MAX_HOSTNAME_LEN + 1
hostname_area = WindowArea(1,
cols,
y_loc,
self.hostfield_offset,
scrollable_columns=scrollable_columns)
self.hostname = EditField(hostname_area,
window=self.center_win,
text=self.sys_info.hostname,
validate=hostname_is_valid,
error_win=self.main_win.error_line)
self.hostname.item_key = None
# Display network configuration part of screen only if applicable.
if self.configure_network:
y_loc += 3
# If there are no configurable links, there is no point to let
# user select type of network configuration.
if not self.have_nic:
# Inform user that no network interfaces were found
# on the system.
# If this is the case of non-global zone with all links
# mandated from global zone, be more specific.
if self.nic_info.type == NetworkInfo.FROMGZ:
self.center_win.add_paragraph(
NetworkTypeScreen.ALL_NICS_FROMGZ, y_loc, 1)
else:
self.center_win.add_paragraph(
NetworkTypeScreen.NO_NICS_FOUND, y_loc, 1)
self.main_win.do_update()
activate = self.net_type_dict.get(self.nic_info.type,
self.hostname)
self.center_win.activate_object(activate)
return
self.main_win.do_update()
activate = self.net_type_dict.get(self.nic_info.type, self.hostname)
self.center_win.activate_object(activate)
class IscsiScreen(BaseScreen):
""" Allow the user to specify parameters for iSCSI LUNs
"""
HEADER_TEXT = _("iSCSI Discovery")
INTRO = _("The installer needs additional information for iSCSI LUN "
"discovery")
FOUND_DHCP_LABEL = _("DHCP has iSCSI parameters defined for this host")
TARGET_IP_LABEL = _("Target IP:")
TARGET_PORT_LABEL = _("Port:")
TARGET_LUN_LABEL = _("Target LUN:")
TARGET_NAME_LABEL = _("Target Name:")
INITIATOR_NAME_LABEL = _("Initiator Name:")
USE_CHAP_LABEL = _("Use CHAP:")
CHAP_NAME_LABEL = _("CHAP Name:")
CHAP_PASSWORD_LABEL = _("CHAP Password:"******"Required Field")
USE_CHAP_LABEL = _("If using CHAP for authentication")
MAPPING_LUN_LABEL = _("Mapping iSCSI LUN...")
MAPPING_TARGET_LABEL = _("Mapping iSCSI Target...")
ISCSI_BOOT_LABEL = _("iSCSI boot enabled - Initiator Name set in BIOS")
# error strings
MISSING_TARGET_IP = _("Target IP address not provided")
INVALID_TARGET_IP = _("Invalid Target IP address")
INVALID_INITIATOR_IQN = _("Invalid Initiator IQN string")
INVALID_TARGET_IQN = _("Invalid Target IQN string")
CHAP_USERNAME_MISSING = _("CHAP username not specified")
CHAP_PASSWORD_MISSING = _("CHAP password not specified")
CHAP_PASSWORD_TOO_SHORT = _("CHAP password must be between 12 and 16 "
"characters")
UNABLE_TO_MAP = _("Unable to map iSCSI LUN: ")
HELP_DATA = (TUI_HELP + "/%s/iscsi.txt", _("iSCSI"))
MAX_IP_LEN = 15
MAX_LUN_LEN = 4
MAX_PORT_LEN = 5
MAX_NAME_LEN = 223
CHAP_LEN = 16
ITEM_OFFSET = 2
DEAD_ZONE = 3
REQUIRED_MARK = EditField.ASTERISK_CHAR
def __init__(self, main_win):
""" screen object containing iSCSI criteria objects
"""
global LOGGER
LOGGER = logging.getLogger(INSTALL_LOGGER_NAME)
super(IscsiScreen, self).__init__(main_win)
self.target_ip = None
self.target_port = None
self.target_lun = None
self.target_name = None
self._initiator_name = None
self.chap_name = None
self.chap_password = None
self.full_win_width = self.win_size_x - IscsiScreen.DEAD_ZONE
self.half_win_width = (self.win_size_x - IscsiScreen.DEAD_ZONE) / 2
self.default_edit = WindowArea(y_loc=0, lines=1,
columns=IscsiScreen.CHAP_LEN)
self.right_edit = WindowArea(y_loc=0, lines=1,
columns=IscsiScreen.MAX_PORT_LEN)
self.name_edit = WindowArea(y_loc=0, lines=1,
scrollable_columns=IscsiScreen.MAX_NAME_LEN + 1)
self.chap_edit = WindowArea(y_loc=0, lines=1,
columns=IscsiScreen.CHAP_LEN)
self.target_ip_list = None
self.target_ip_edit = None
self.target_port_list = None
self.target_port_edit = None
self.target_lun_list = None
self.target_lun_edit = None
self.target_name_edit = None
self.initiator_name_edit = None
self.chap_name_edit = None
self.chap_password_edit = None
# key map dictionary for Target entries
self.add_keys = {curses.KEY_LEFT: self.on_arrow_key,
curses.KEY_RIGHT: self.on_arrow_key,
curses.KEY_DOWN: self.on_arrow_key,
curses.KEY_UP: self.on_arrow_key}
self.iscsi_obj = None
self.is_iscsiboot = is_iscsiboot()
def on_arrow_key(self, input_key):
""" override the default behavior of the arrow keys for specific
EditFields.
"""
# get the active object
active = self.center_win.get_active_object()
# only allow the right arrow to move from IP to Port
if input_key == curses.KEY_RIGHT and active is self.target_ip_list:
self.center_win.activate_object(self.target_port_list)
return None
# only allow the left arrow to move from Port to IP
elif input_key == curses.KEY_LEFT and active is self.target_port_list:
self.center_win.activate_object(self.target_ip_list)
return None
# override the default behavior for the up and down arrows to skip the
# Port field if moving from IP to LUN
elif input_key == curses.KEY_DOWN and active is self.target_ip_list:
self.center_win.activate_object(self.target_lun_list)
return None
elif input_key == curses.KEY_UP and active is self.target_lun_list:
self.center_win.activate_object(self.target_ip_list)
return None
return input_key
def check_dhcp(self):
""" query the DHCP server for the Rootpath string. If present, update
the proper attributes.
"""
dhcp_params = Iscsi.get_dhcp()
if dhcp_params is not None:
self.target_ip,
self.target_port,
self.target_lun,
self.target_name = dhcp_params
return True
return False
@property
def initiator_name(self):
""" property to return the initiator name
"""
if self._initiator_name is None:
cmd = [ISCSIADM, "list", "initiator-node"]
p = run(cmd)
for line in p.stdout.splitlines():
if line.startswith("Initiator node name:"):
self._initiator_name = line.split(": ")[1]
return self._initiator_name
@initiator_name.setter
def initiator_name(self, name):
""" property setter for _initiator_name
"""
self._initiator_name = name
def _show(self):
""" create the screen to collect user input
"""
# look in the DOC for an Iscsi object
eng = InstallEngine.get_instance()
iscsi_obj = eng.doc.volatile.get_children(name=ISCSI_LABEL,
class_type=Iscsi)
# If there's no iscsi object in the DOC, skip this screen
if not iscsi_obj:
raise SkipException
else:
self.iscsi_obj = iscsi_obj[0]
LOGGER.debug("show Iscsi object: %s" % str(self.iscsi_obj))
y_loc = 1
self.center_win.add_paragraph(IscsiScreen.INTRO, start_y=y_loc)
# look to see if DHCP is providing information
if self.check_dhcp():
y_loc += 2
self.center_win.add_paragraph(IscsiScreen.FOUND_DHCP_LABEL,
start_y=y_loc)
# Target IP
y_loc += 2
# Mark this field required
self.center_win.window.addch(y_loc, 2, IscsiScreen.REQUIRED_MARK,
self.center_win.color_theme.inactive)
edit_start = textwidth(IscsiScreen.TARGET_IP_LABEL) + \
IscsiScreen.ITEM_OFFSET
ip_area = WindowArea(y_loc=y_loc, x_loc=1, lines=1,
columns=edit_start + IscsiScreen.MAX_IP_LEN + 1)
self.target_ip_list = ListItem(ip_area,
window=self.center_win,
text=IscsiScreen.TARGET_IP_LABEL)
self.target_ip_list.key_dict.update(self.add_keys)
self.default_edit.x_loc = edit_start
self.default_edit.columns = IscsiScreen.MAX_IP_LEN + 1
self.target_ip_edit = EditField(self.default_edit,
window=self.target_ip_list,
validate=incremental_validate_ip,
error_win=self.main_win.error_line)
self.target_ip_edit.key_dict.update(self.add_keys)
if self.target_ip is not None:
self.target_ip_edit.set_text(self.target_ip)
# Target Port
edit_start = ip_area.x_loc + \
textwidth(IscsiScreen.TARGET_PORT_LABEL) + \
IscsiScreen.ITEM_OFFSET
port_area = WindowArea(y_loc=y_loc,
x_loc=self.half_win_width + IscsiScreen.DEAD_ZONE,
lines=1, columns=edit_start + IscsiScreen.MAX_PORT_LEN + 1)
self.target_port_list = ListItem(port_area,
window=self.center_win,
text=IscsiScreen.TARGET_PORT_LABEL)
self.target_port_list.key_dict.update(self.add_keys)
self.right_edit.x_loc = edit_start
self.right_edit.columns = IscsiScreen.MAX_PORT_LEN + 1
self.target_port_edit = EditField(self.right_edit,
window=self.target_port_list,
validate=incremental_validate_digits,
error_win=self.main_win.error_line,
text=Iscsi.ISCSI_DEFAULT_PORT)
self.target_port_edit.key_dict.update(self.add_keys)
if self.target_port is not None:
self.target_port_edit.set_text(self.target_port)
# Target LUN
y_loc += 1
edit_start = textwidth(IscsiScreen.TARGET_LUN_LABEL) + \
IscsiScreen.ITEM_OFFSET
lun_area = WindowArea(y_loc=y_loc, x_loc=1, lines=1,
columns=edit_start + IscsiScreen.MAX_LUN_LEN + 1)
self.target_lun_list = ListItem(lun_area,
window=self.center_win,
text=IscsiScreen.TARGET_LUN_LABEL)
self.target_lun_list.key_dict.update(self.add_keys)
self.default_edit.x_loc = edit_start
self.default_edit.columns = IscsiScreen.MAX_LUN_LEN + 1
self.target_lun_edit = EditField(self.default_edit,
window=self.target_lun_list,
validate=incremental_validate_hex,
error_win=self.main_win.error_line)
self.target_lun_edit.key_dict.update(self.add_keys)
if self.target_lun is not None:
self.target_lun_edit.set_text(self.target_lun)
# Target Name
y_loc += 2
name_area = WindowArea(y_loc=y_loc, x_loc=1, lines=1,
columns=self.full_win_width)
name_area.y_loc = y_loc
target_name_list = ListItem(name_area, window=self.center_win,
text=IscsiScreen.TARGET_NAME_LABEL)
self.name_edit.x_loc = textwidth(IscsiScreen.TARGET_NAME_LABEL) + \
IscsiScreen.ITEM_OFFSET
self.name_edit.columns = self.full_win_width - \
textwidth(IscsiScreen.TARGET_NAME_LABEL) - \
IscsiScreen.ITEM_OFFSET
self.target_name_edit = EditField(self.name_edit,
window=target_name_list)
if self.target_name is not None:
self.target_name_edit.set_text(self.target_name)
# Horizontal line
y_loc += 1
self.center_win.window.hline(y_loc, 3, curses.ACS_HLINE,
self.full_win_width)
# Initiator Name
y_loc += 1
if self.is_iscsiboot:
# the system BIOS is configured for iSCSI boot. This means the
# user will be unable to change the initiator-name. Display the
# name, but don't allow it to be changed.
text = "%s %s" % \
(IscsiScreen.INITIATOR_NAME_LABEL, self.initiator_name)
self.center_win.add_text(text, start_y=y_loc, start_x=1)
y_loc += 1
self.center_win.add_text(IscsiScreen.ISCSI_BOOT_LABEL,
start_y=y_loc, start_x=1)
else:
# display the edit field as normal
name_area.y_loc = y_loc
initiator_name_list = ListItem(name_area, window=self.center_win,
text=IscsiScreen.INITIATOR_NAME_LABEL)
self.name_edit.x_loc = \
textwidth(IscsiScreen.INITIATOR_NAME_LABEL) + \
IscsiScreen.ITEM_OFFSET
self.name_edit.columns = self.full_win_width - \
textwidth(IscsiScreen.INITIATOR_NAME_LABEL) - \
IscsiScreen.ITEM_OFFSET
self.initiator_name_edit = EditField(self.name_edit,
window=initiator_name_list,
text=self.initiator_name)
y_loc += 2
self.center_win.add_text(IscsiScreen.USE_CHAP_LABEL, y_loc, 1)
# CHAP username
y_loc += 1
edit_start = textwidth(IscsiScreen.CHAP_NAME_LABEL) + \
IscsiScreen.ITEM_OFFSET
chapname_area = WindowArea(y_loc=y_loc, x_loc=15, lines=1,
columns=edit_start + IscsiScreen.CHAP_LEN)
chap_name_list = ListItem(chapname_area, window=self.center_win,
text=IscsiScreen.CHAP_NAME_LABEL)
self.chap_edit.x_loc = edit_start
self.chap_edit.columns = IscsiScreen.CHAP_LEN + 1
self.chap_edit.scrollable_columns = IscsiScreen.MAX_NAME_LEN + 1
self.chap_name_edit = EditField(self.chap_edit, window=chap_name_list)
if self.chap_name is not None:
self.chap_name_edit.set_text(self.chap_name)
# CHAP password
y_loc += 1
edit_start = textwidth(IscsiScreen.CHAP_PASSWORD_LABEL) + \
IscsiScreen.ITEM_OFFSET
chapname_area.y_loc = y_loc
chap_password_list = ListItem(chapname_area, window=self.center_win,
text=IscsiScreen.CHAP_PASSWORD_LABEL)
self.chap_edit.x_loc = textwidth(IscsiScreen.CHAP_PASSWORD_LABEL) + \
IscsiScreen.ITEM_OFFSET
self.chap_edit.scrollable_columns = None
self.chap_password_edit = PasswordField(self.chap_edit,
window=chap_password_list)
if self.chap_password is not None:
self.chap_password_edit.set_text(self.chap_password)
# Legend
y_loc += 2
self.center_win.window.addch(y_loc, 1, IscsiScreen.REQUIRED_MARK,
self.center_win.color_theme.inactive)
self.center_win.add_text(IscsiScreen.REQUIRED_FIELD_LABEL, y_loc, 1)
self.main_win.do_update()
self.center_win.activate_object()
def on_change_screen(self):
""" save the user's choices in case they return to this screen
"""
self.target_ip = self.target_ip_edit.get_text()
self.target_port = self.target_port_edit.get_text()
self.target_lun = self.target_lun_edit.get_text()
self.target_name = self.target_name_edit.get_text()
if not self.is_iscsiboot:
self.initiator_name = self.initiator_name_edit.get_text()
self.chap_name = self.chap_name_edit.get_text()
self.chap_password = self.chap_password_edit.get_text()
def validate(self):
""" validate the iSCSI attributes before continuing to disk selection.
"""
target_ip = self.target_ip_edit.get_text()
target_lun = self.target_lun_edit.get_text()
target_port = self.target_port_edit.get_text()
target_name = self.target_name_edit.get_text()
if not self.is_iscsiboot:
initiator_name = self.initiator_name_edit.get_text()
chap_name = self.chap_name_edit.get_text()
chap_password = self.chap_password_edit.get_text()
# validate the target IP
if not target_ip:
raise UIMessage(IscsiScreen.MISSING_TARGET_IP)
else:
try:
IPAddress.convert_address(target_ip)
except ValueError as error:
raise UIMessage("%s: %s" % \
(IscsiScreen.INVALID_TARGET_IP, str(error)))
# validate the IQN strings (by default re.match only matches at the
# beginning of a string)
if not self.is_iscsiboot and initiator_name:
if IQN_RE.match(initiator_name) is None:
raise UIMessage(IscsiScreen.INVALID_INITIATOR_IQN)
if target_name:
if IQN_RE.match(target_name) is None:
raise UIMessage(IscsiScreen.INVALID_TARGET_IQN)
# validate that both CHAP username and password were specified (or not
# at all)
if chap_name and not chap_password:
raise UIMessage(IscsiScreen.CHAP_PASSWORD_MISSING)
if chap_password and not chap_name:
raise UIMessage(IscsiScreen.CHAP_USERNAME_MISSING)
# validate the CHAP password
if chap_password:
if not 12 <= len(chap_password) <= 16:
raise UIMessage(IscsiScreen.CHAP_PASSWORD_TOO_SHORT)
# Update the Iscsi DOC object
self.iscsi_obj.target_ip = target_ip
# force target_lun back to None if the user comes back and removes the
# LUN entry from the screen
if target_lun:
self.iscsi_obj.target_lun = target_lun
else:
self.iscsi_obj.target_lun = None
if target_name:
self.iscsi_obj.target_name = target_name
if target_port:
self.iscsi_obj.target_port = target_port
if not self.is_iscsiboot and initiator_name:
self.iscsi_obj.initiator_name = initiator_name
if chap_name:
self.iscsi_obj.chap_name = chap_name
if chap_password:
self.iscsi_obj.chap_password = chap_password
# attempt to connect to the LUN
if target_lun:
self.main_win.error_line.display_err(IscsiScreen.MAPPING_LUN_LABEL)
else:
self.main_win.error_line.display_err(
IscsiScreen.MAPPING_TARGET_LABEL)
try:
self.iscsi_obj.setup_iscsi()
LOGGER.debug("Iscsi object: %s" % str(self.iscsi_obj))
except (CalledProcessError, RuntimeError) as err:
# remove the iSCSI configuration since it's invalid
try:
self.iscsi_obj.teardown()
except CalledProcessError:
# ignore any errors
pass
raise UIMessage("%s %s" % (IscsiScreen.UNABLE_TO_MAP, str(err)))
class NSDomain(NameService):
HEADER_TEXT = _("Domain Name")
HELP_DATA = (SCI_HELP + "/%s/domain.txt", HEADER_TEXT)
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):
''' show domain '''
super(NSDomain, self)._show()
if not _has_name_service():
raise SkipException
if not self.nameservice.nameservice:
raise SkipException
y_loc = self._paint_opening()
cols = min(MAXDOMAINLEN + 1,
self.win_size_x - textwidth(self.title) - INDENT - 1)
self.center_win.add_text(self.title, y_loc, INDENT)
area = WindowArea(1, cols, y_loc, textwidth(self.title) + INDENT + 1,
scrollable_columns=MAXDOMAINLEN + 1)
self.domain = EditField(area, window=self.center_win,
text=self.nameservice.domain,
validate=incremental_validate_domain,
error_win=self.main_win.error_line)
self.main_win.do_update()
self.center_win.activate_object(self.domain)
def validate(self):
validate_domain(self.domain.get_text(), allow_empty=False)
def on_change_screen(self):
ns = self.nameservice
new_domain = self.domain.get_text()
if ns.domain != new_domain or \
(ns.nameservice == 'LDAP' and not ns.ldap_search_base):
ns.domain = new_domain
# default in LDAP-formatted values for domain
if self.nameservice.nameservice == 'LDAP':
ldapdom = _convert_to_ldap_domain(new_domain)
# default in search base from domain
if not ns.ldap_search_base or \
not ns.ldap_search_base.startswith(ldapdom):
ns.ldap_search_base = ldapdom
# base DN on search base
if ns.ldap_pb_dn:
# update DN with any changes in search_base from user
fixedbase = _ldap_domain_fixup(ns.ldap_pb_dn,
ns.ldap_search_base)
if fixedbase:
# user changed search base, update DN
ns.ldap_pb_dn = fixedbase
else:
# provide probable DN default
ns.ldap_pb_dn = 'cn=proxyagent,ou=profile,' + \
ns.ldap_search_base
def _show(self):
'''Display the user name, real name, and password fields'''
sc_profile = solaris_install.sysconfig.profile.from_engine()
#
# Create UserInfo instances holding information about root and user
# accounts.
#
if sc_profile.users is None:
#
# Assume root is a normal account. It will be changed to a role
# if the user account is created.
#
root = UserInfo(login_name="root", is_role=False)
#
# Initialize attributes of user account which can't be configured
# on screens.
#
user = UserInfo(gid=10, shell="/usr/bin/bash", roles="root",
profiles="System Administrator",
sudoers="ALL=(ALL) ALL")
sc_profile.users = UserInfoContainer(root, user)
self.root = sc_profile.users.root
self.user = sc_profile.users.user
LOGGER.debug("Root: %s", self.root)
LOGGER.debug("User: %s", self.user)
root_set = (self.root.passlen != 0)
user_set = (self.user.passlen != 0)
y_loc = 1
if self.show_user_account:
intro_text = UserScreen.INTRO_SHOW_USER
else:
intro_text = UserScreen.INTRO_HIDE_USER
self.center_win.add_paragraph(intro_text, y_loc, 1,
y_loc + 2, self.win_size_x - 1)
y_loc += 3
self.center_win.add_text(UserScreen.ROOT_TEXT, y_loc, 1,
self.win_size_x - 1)
y_loc += 2
self.error_area.y_loc = y_loc
self.list_area.y_loc = y_loc
self.root_pass_err = ErrorWindow(self.error_area,
window=self.center_win)
self.root_pass_list = ListItem(self.list_area, window=self.center_win,
text=UserScreen.ROOT_LABEL)
self.root_pass_edit = PasswordField(self.edit_area,
window=self.root_pass_list,
error_win=self.root_pass_err,
fill=root_set)
y_loc += 1
self.error_area.y_loc = y_loc
self.list_area.y_loc = y_loc
self.root_confirm_err = ErrorWindow(self.error_area,
window=self.center_win)
self.root_confirm_list = ListItem(self.list_area,
window=self.center_win,
text=UserScreen.CONFIRM_LABEL)
self.root_confirm_edit = PasswordField(self.edit_area,
window=self.root_confirm_list,
fill=root_set,
on_exit=pass_match,
error_win=self.root_confirm_err)
rc_edit_kwargs = {"linked_win": self.root_pass_edit}
self.root_confirm_edit.on_exit_kwargs = rc_edit_kwargs
# User account disabled, do not display related widgets.
if not self.show_user_account:
self.main_win.do_update()
self.center_win.activate_object(self.root_pass_list)
return
y_loc += 2
self.center_win.add_text(UserScreen.USER_TEXT, y_loc, 1,
self.win_size_x - 1)
y_loc += 2
self.list_area.y_loc = y_loc
self.error_area.y_loc = y_loc
self.real_name_err = ErrorWindow(self.error_area,
window=self.center_win)
self.real_name_list = ListItem(self.list_area, window=self.center_win,
text=UserScreen.NAME_LABEL)
self.real_name_edit = EditField(self.edit_area,
window=self.real_name_list,
error_win=self.real_name_err,
text=self.user.real_name)
y_loc += 1
self.list_area.y_loc = y_loc
self.error_area.y_loc = y_loc
self.username_err = ErrorWindow(self.error_area,
window=self.center_win)
self.username_list = ListItem(self.list_area,
window=self.center_win,
text=UserScreen.USERNAME_LABEL)
self.username_edit = EditField(self.username_edit_area,
window=self.username_list,
validate=username_valid,
error_win=self.username_err,
on_exit=login_valid,
text=self.user.login_name)
y_loc += 1
self.list_area.y_loc = y_loc
self.error_area.y_loc = y_loc
self.user_pass_err = ErrorWindow(self.error_area,
window=self.center_win)
self.user_pass_list = ListItem(self.list_area, window=self.center_win,
text=UserScreen.USER_PASS_LABEL)
self.user_pass_edit = PasswordField(self.edit_area,
window=self.user_pass_list,
error_win=self.user_pass_err,
fill=user_set)
y_loc += 1
self.list_area.y_loc = y_loc
self.error_area.y_loc = y_loc
self.user_confirm_err = ErrorWindow(self.error_area,
window=self.center_win)
self.user_confirm_list = ListItem(self.list_area,
window=self.center_win,
text=UserScreen.CONFIRM_LABEL)
self.user_confirm_edit = PasswordField(self.edit_area,
window=self.user_confirm_list,
on_exit=pass_match,
error_win=self.user_confirm_err,
fill=user_set)
uc_edit_kwargs = {"linked_win": self.user_pass_edit}
self.user_confirm_edit.on_exit_kwargs = uc_edit_kwargs
self.main_win.do_update()
self.center_win.activate_object(self.root_pass_list)