def __init__(self, app, data, storage, payload, instclass):
super(SummaryHub, self).__init__(app, data, storage, payload, instclass)
if not flags.dirInstall:
self._checker = FileSystemSpaceChecker(storage, payload)
else:
self._checker = DirInstallSpaceChecker(storage, payload)
def __init__(self, data, storage, payload, instclass):
super().__init__(data, storage, payload, instclass)
self.title = N_("Installation")
if not conf.target.is_directory:
self._checker = FileSystemSpaceChecker(storage, payload)
else:
self._checker = DirInstallSpaceChecker(storage, payload)
def __init__(self, data, storage, payload, instclass):
super().__init__(data, storage, payload, instclass)
self.title = N_("Installation")
if not flags.dirInstall:
self._checker = FileSystemSpaceChecker(storage, payload)
else:
self._checker = DirInstallSpaceChecker(storage, payload)
def __init__(self, data, storage, payload):
super().__init__(data, storage, payload)
self.title = N_("Installation")
if not conf.target.is_directory:
self._checker = FileSystemSpaceChecker(payload)
else:
self._checker = DirInstallSpaceChecker(payload)
def __init__(self, app, data, storage, payload, instclass):
super(SummaryHub, self).__init__(app, data, storage, payload,
instclass)
if not flags.dirInstall:
self._checker = FileSystemSpaceChecker(storage, payload)
else:
self._checker = DirInstallSpaceChecker(storage, payload)
def __init__(self, data, storage, payload):
"""Create a new Hub instance.
The arguments this base class accepts defines the API that Hubs
have to work with. A Hub does not get free reign over everything
in the anaconda class, as that would be a big mess. Instead, a
Hub may count on the following:
ksdata -- An instance of a pykickstart Handler object. The
Hub uses this to populate its UI with defaults
and to pass results back after it has run.
storage -- An instance of storage.Storage. This is useful for
determining what storage devices are present and how
they are configured.
payload -- An instance of a payload.Payload subclass. This
is useful for displaying and selecting packages to
install, and in carrying out the actual installation.
"""
super().__init__(data, storage, payload)
self._show_details_callback = None
if not conf.target.is_directory:
self._checker = FileSystemSpaceChecker(payload)
else:
self._checker = DirInstallSpaceChecker(payload)
# Add a continue-clicked handler
self.window.connect("continue-clicked", self._on_continue_clicked)
# Add an info-bar-clicked handler
self.window.connect("info-bar-clicked", self._on_info_bar_clicked)
def __init__(self, data, storage, payload, instclass):
"""Create a new Hub instance.
The arguments this base class accepts defines the API that Hubs
have to work with. A Hub does not get free reign over everything
in the anaconda class, as that would be a big mess. Instead, a
Hub may count on the following:
ksdata -- An instance of a pykickstart Handler object. The
Hub uses this to populate its UI with defaults
and to pass results back after it has run.
storage -- An instance of storage.Storage. This is useful for
determining what storage devices are present and how
they are configured.
payload -- An instance of a packaging.Payload subclass. This
is useful for displaying and selecting packages to
install, and in carrying out the actual installation.
instclass -- An instance of a BaseInstallClass subclass. This
is useful for determining distribution-specific
installation information like default package
selections and default partitioning.
"""
super(SummaryHub, self).__init__(data, storage, payload, instclass)
if not flags.dirInstall:
self._checker = FileSystemSpaceChecker(storage, payload)
else:
self._checker = DirInstallSpaceChecker(storage, payload)
class SummaryHub(TUIHub):
"""
.. inheritance-diagram:: SummaryHub
:parts: 3
"""
helpFile = "SummaryHub.txt"
def __init__(self, data, storage, payload, instclass):
super().__init__(data, storage, payload, instclass)
self.title = N_("Installation")
if not conf.target.is_directory:
self._checker = FileSystemSpaceChecker(storage, payload)
else:
self._checker = DirInstallSpaceChecker(storage, payload)
def setup(self, args="anaconda"):
environment = args
should_schedule = TUIHub.setup(self, environment)
if not should_schedule:
return False
if flags.automatedInstall:
sys.stdout.write(_("Starting automated install"))
sys.stdout.flush()
spokes = self._spokes.values()
while not all(spoke.ready for spoke in spokes):
# Catch any asynchronous events (like storage crashing)
loop = App.get_event_loop()
loop.process_signals()
sys.stdout.write('.')
sys.stdout.flush()
time.sleep(1)
print('')
for spoke in spokes:
if spoke.changed:
spoke.execute()
return True
# override the prompt so that we can skip user input on kickstarts
# where all the data is in hand. If not in hand, do the actual prompt.
def prompt(self, args=None):
incomplete_spokes = [spoke for spoke in self._spokes.values()
if spoke.mandatory and not spoke.completed]
# Kickstart space check failure either stops the automated install or
# raises an error when using cmdline mode.
#
# For non-cmdline, prompt for input but continue to treat it as an
# automated install. The spokes (in particular software selection,
# which expects an environment for interactive install) will continue
# to behave the same, so the user can hit 'b' at the prompt and ignore
# the warning.
if flags.automatedInstall and not incomplete_spokes:
# Check the available space.
if flags.ksprompt and self._checker and not self._checker.check():
# Space is not ok.
print(self._checker.error_message)
log.error(self._checker.error_message)
# Unset the checker so everything passes next time.
self._checker = None
# TRANSLATORS: 'b' to begin installation
print(_("Enter '%s' to ignore the warning and attempt to install anyway.") %
# TRANSLATORS: 'b' to begin installation
C_("TUI|Spoke Navigation", "b")
)
else:
# Space is ok and spokes are complete, continue.
self.close()
return None
# cmdline mode and incomplete spokes raises and error
if not flags.ksprompt and incomplete_spokes:
errtxt = _("The following mandatory spokes are not completed:") + \
"\n" + "\n".join(spoke.title for spoke in incomplete_spokes)
log.error("CmdlineError: %s", errtxt)
raise CmdlineError(errtxt)
# if we ever need to halt the flow of a ks install to prompt users for
# input, flip off the automatedInstall flag -- this way installation
# does not automatically proceed once all spokes are complete, and a
# user must confirm they want to begin installation
if incomplete_spokes:
flags.automatedInstall = False
# override the default prompt since we want to offer the 'b' to begin
# installation option here
prompt = super().prompt(args)
# this screen cannot be closed
prompt.remove_option(Prompt.CONTINUE)
# TRANSLATORS: 'b' to begin installation
prompt.add_option(C_("TUI|Spoke Navigation", "b"), _("to begin installation"))
return prompt
def input(self, args, key):
"""Handle user input. Numbers are used to show a spoke, the rest is passed
to the higher level for processing."""
if self._container.process_user_input(key):
return InputState.PROCESSED
else:
# If we get a continue, check for unfinished spokes. If unfinished
# don't continue
# TRANSLATORS: 'b' to begin installation
if key == C_('TUI|Spoke Navigation', 'b'):
for spoke in self._spokes.values():
if not spoke.completed and spoke.mandatory:
print(_("Please complete all spokes before continuing"))
return InputState.DISCARDED
# do a bit of final sanity checking, making sure pkg selection
# size < available fs space
if self._checker and not self._checker.check():
print(self._checker.error_message)
return InputState.DISCARDED
return InputState.PROCESSED_AND_CLOSE
# TRANSLATORS: 'c' to continue
elif key == C_('TUI|Spoke Navigation', 'c'):
# Kind of a hack, but we want to ignore if anyone presses 'c'
# which is the global TUI key to close the current screen
return InputState.DISCARDED
else:
return super().input(args, key)
class SummaryHub(TUIHub):
title = N_("Installation")
def __init__(self, app, data, storage, payload, instclass):
super(SummaryHub, self).__init__(app, data, storage, payload,
instclass)
if not flags.dirInstall:
self._checker = FileSystemSpaceChecker(storage, payload)
else:
self._checker = DirInstallSpaceChecker(storage, payload)
def setup(self, environment="anaconda"):
should_schedule = TUIHub.setup(self, environment=environment)
if not should_schedule:
return False
if flags.automatedInstall:
sys.stdout.write(_("Starting automated install"))
sys.stdout.flush()
spokes = self._keys.values()
while not all(spoke.ready for spoke in spokes):
# Catch any asyncronous events (like storage crashing)
self._app.process_events()
sys.stdout.write('.')
sys.stdout.flush()
time.sleep(1)
print('')
for spoke in spokes:
if spoke.changed:
spoke.execute()
return True
# override the prompt so that we can skip user input on kickstarts
# where all the data is in hand. If not in hand, do the actual prompt.
def prompt(self, args=None):
incompleteSpokes = [
spoke for spoke in self._keys.values()
if spoke.mandatory and not spoke.completed
]
# Kickstart space check failure either stops the automated install or
# raises an error when using cmdline mode.
#
# For non-cmdline, prompt for input but continue to treat it as an
# automated install. The spokes (in particular software selection,
# which expects an environment for interactive install) will continue
# to behave the same, so the user can hit 'b' at the prompt and ignore
# the warning.
if flags.automatedInstall and self._checker and not self._checker.check(
):
print(self._checker.error_message)
log.error(self._checker.error_message)
# Unset the checker so everything passes next time
self._checker = None
if not flags.ksprompt:
return None
else:
# TRANSLATORS: 'b' to begin installation
print(
_("Enter '%s' to ignore the warning and attempt to install anyway."
) %
# TRANSLATORS: 'b' to begin installation
C_("TUI|Spoke Navigation", "b"))
elif flags.automatedInstall and not incompleteSpokes:
# Space is ok and spokes are complete, continue
self.close()
return None
# cmdline mode and incomplete spokes raises and error
if not flags.ksprompt and incompleteSpokes:
errtxt = _("The following mandatory spokes are not completed:") + \
"\n" + "\n".join(spoke.title for spoke in incompleteSpokes)
log.error("CmdlineError: %s", errtxt)
raise CmdlineError(errtxt)
# if we ever need to halt the flow of a ks install to prompt users for
# input, flip off the automatedInstall flag -- this way installation
# does not automatically proceed once all spokes are complete, and a
# user must confirm they want to begin installation
if incompleteSpokes:
flags.automatedInstall = False
# override the default prompt since we want to offer the 'b' to begin
# installation option here
return _(
" Please make your choice from above ['%(quit)s' to quit | '%(begin)s' to begin installation |\n '%(refresh)s' to refresh]: "
) % {
# TRANSLATORS: 'q' to quit
'quit': C_('TUI|Spoke Navigation', 'q'),
# TRANSLATORS: 'b' to begin installation
'begin': C_('TUI|Spoke Navigation', 'b'),
# TRANSLATORS: 'r' to refresh
'refresh': C_('TUI|Spoke Navigation', 'r')
}
def input(self, args, key):
"""Handle user input. Numbers are used to show a spoke, the rest is passed
to the higher level for processing."""
try:
number = int(key)
self.app.switch_screen_with_return(self._keys[number])
return None
except (ValueError, KeyError):
# If we get a continue, check for unfinished spokes. If unfinished
# don't continue
# TRANSLATORS: 'b' to begin installation
if key == C_('TUI|Spoke Navigation', 'b'):
for spoke in self._spokes.values():
if not spoke.completed and spoke.mandatory:
print(
_("Please complete all spokes before continuing"))
return False
# do a bit of final sanity checking, making sure pkg selection
# size < available fs space
if self._checker and not self._checker.check():
print(self._checker.error_message)
return False
if self.app._screens:
self.app.close_screen()
return True
# TRANSLATORS: 'c' to continue
elif key == C_('TUI|Spoke Navigation', 'c'):
# Kind of a hack, but we want to ignore if anyone presses 'c'
# which is the global TUI key to close the current screen
return False
else:
return super(SummaryHub, self).input(args, key)
class SummaryHub(TUIHub):
"""
.. inheritance-diagram:: SummaryHub
:parts: 3
"""
helpFile = "SummaryHub.txt"
def __init__(self, data, storage, payload, instclass):
super().__init__(data, storage, payload, instclass)
self.title = N_("Installation")
if not conf.target.is_directory:
self._checker = FileSystemSpaceChecker(storage, payload)
else:
self._checker = DirInstallSpaceChecker(storage, payload)
def setup(self, args="anaconda"):
environment = args
should_schedule = TUIHub.setup(self, environment)
if not should_schedule:
return False
if flags.automatedInstall:
sys.stdout.write(_("Starting automated install"))
sys.stdout.flush()
spokes = self._spokes.values()
while not all(spoke.ready for spoke in spokes):
# Catch any asynchronous events (like storage crashing)
loop = App.get_event_loop()
loop.process_signals()
sys.stdout.write('.')
sys.stdout.flush()
time.sleep(1)
print('')
for spoke in spokes:
if spoke.changed:
spoke.execute()
return True
# override the prompt so that we can skip user input on kickstarts
# where all the data is in hand. If not in hand, do the actual prompt.
def prompt(self, args=None):
incomplete_spokes = [
spoke for spoke in self._spokes.values()
if spoke.mandatory and not spoke.completed
]
# Kickstart space check failure either stops the automated install or
# raises an error when using cmdline mode.
#
# For non-cmdline, prompt for input but continue to treat it as an
# automated install. The spokes (in particular software selection,
# which expects an environment for interactive install) will continue
# to behave the same, so the user can hit 'b' at the prompt and ignore
# the warning.
if flags.automatedInstall and not incomplete_spokes:
# Check the available space.
if flags.ksprompt and self._checker and not self._checker.check():
# Space is not ok.
print(self._checker.error_message)
log.error(self._checker.error_message)
# Unset the checker so everything passes next time.
self._checker = None
# TRANSLATORS: 'b' to begin installation
print(
_("Enter '%s' to ignore the warning and attempt to install anyway."
) %
# TRANSLATORS: 'b' to begin installation
C_("TUI|Spoke Navigation", "b"))
else:
# Space is ok and spokes are complete, continue.
self.close()
return None
# cmdline mode and incomplete spokes raises and error
if not flags.ksprompt and incomplete_spokes:
errtxt = _("The following mandatory spokes are not completed:") + \
"\n" + "\n".join(spoke.title for spoke in incomplete_spokes)
log.error("CmdlineError: %s", errtxt)
raise CmdlineError(errtxt)
# if we ever need to halt the flow of a ks install to prompt users for
# input, flip off the automatedInstall flag -- this way installation
# does not automatically proceed once all spokes are complete, and a
# user must confirm they want to begin installation
if incomplete_spokes:
flags.automatedInstall = False
# override the default prompt since we want to offer the 'b' to begin
# installation option here
prompt = super().prompt(args)
# this screen cannot be closed
prompt.remove_option(Prompt.CONTINUE)
# TRANSLATORS: 'b' to begin installation
prompt.add_option(C_("TUI|Spoke Navigation", "b"),
_("to begin installation"))
return prompt
def input(self, args, key):
"""Handle user input. Numbers are used to show a spoke, the rest is passed
to the higher level for processing."""
if self._container.process_user_input(key):
return InputState.PROCESSED
else:
# If we get a continue, check for unfinished spokes. If unfinished
# don't continue
# TRANSLATORS: 'b' to begin installation
if key == C_('TUI|Spoke Navigation', 'b'):
for spoke in self._spokes.values():
if not spoke.completed and spoke.mandatory:
print(
_("Please complete all spokes before continuing"))
return InputState.DISCARDED
# do a bit of final sanity checking, making sure pkg selection
# size < available fs space
if self._checker and not self._checker.check():
print(self._checker.error_message)
return InputState.DISCARDED
return InputState.PROCESSED_AND_CLOSE
# TRANSLATORS: 'c' to continue
elif key == C_('TUI|Spoke Navigation', 'c'):
# Kind of a hack, but we want to ignore if anyone presses 'c'
# which is the global TUI key to close the current screen
return InputState.DISCARDED
else:
return super().input(args, key)
class SummaryHub(TUIHub):
title = N_("Installation")
def __init__(self, app, data, storage, payload, instclass):
super(SummaryHub, self).__init__(app, data, storage, payload,
instclass)
if not flags.dirInstall:
self._checker = FileSystemSpaceChecker(storage, payload)
else:
self._checker = DirInstallSpaceChecker(storage, payload)
def setup(self, environment="anaconda"):
should_schedule = TUIHub.setup(self, environment=environment)
if not should_schedule:
return False
if flags.automatedInstall:
sys.stdout.write(_("Starting automated install"))
sys.stdout.flush()
spokes = self._keys.values()
while not all(spoke.ready for spoke in spokes):
sys.stdout.write('.')
sys.stdout.flush()
time.sleep(1)
print('')
for spoke in spokes:
if spoke.changed:
spoke.execute()
return True
# override the prompt so that we can skip user input on kickstarts
# where all the data is in hand. If not in hand, do the actual prompt.
def prompt(self, args=None):
incompleteSpokes = [
spoke for spoke in self._keys.values()
if spoke.mandatory and not spoke.completed
]
# do a bit of final sanity checking, make sure pkg selection
# size < available fs space
if flags.automatedInstall:
if self._checker and not self._checker.check():
print(self._checker.error_message)
if not incompleteSpokes:
self.close()
return None
if flags.ksprompt:
for spoke in incompleteSpokes:
log.info("kickstart installation stopped for info: %s",
spoke.title)
else:
errtxt = _("The following mandatory spokes are not completed:") + \
"\n" + "\n".join(spoke.title for spoke in incompleteSpokes)
log.error("CmdlineError: %s", errtxt)
raise CmdlineError(errtxt)
# override the default prompt since we want to offer the 'b' to begin
# installation option here
return _(
" Please make your choice from above ['q' to quit | 'b' to begin installation |\n 'r' to refresh]: "
)
def input(self, args, key):
"""Handle user input. Numbers are used to show a spoke, the rest is passed
to the higher level for processing."""
try:
number = int(key)
self.app.switch_screen_with_return(self._keys[number])
return None
except (ValueError, KeyError):
# If we get a continue, check for unfinished spokes. If unfinished
# don't continue
# TRANSLATORS: 'b' to begin installation
if key == C_('TUI|Spoke Navigation', 'b'):
for spoke in self._spokes.values():
if not spoke.completed and spoke.mandatory:
print(
_("Please complete all spokes before continuing"))
return False
# do a bit of final sanity checking, making sure pkg selection
# size < available fs space
if self._checker and not self._checker.check():
print(self._checker.error_message)
return False
if self.app._screens:
self.app.close_screen()
return True
# TRANSLATORS: 'c' to continue
elif key == C_('TUI|Spoke Navigation', 'c'):
# Kind of a hack, but we want to ignore if anyone presses 'c'
# which is the global TUI key to close the current screen
return False
else:
super(SummaryHub, self).input(args, key)
class SummaryHub(TUIHub):
"""
.. inheritance-diagram:: SummaryHub
:parts: 3
"""
title = N_("Installation")
def __init__(self, app, data, storage, payload, instclass):
super(SummaryHub, self).__init__(app, data, storage, payload, instclass)
if not flags.dirInstall:
self._checker = FileSystemSpaceChecker(storage, payload)
else:
self._checker = DirInstallSpaceChecker(storage, payload)
def setup(self, environment="anaconda"):
should_schedule = TUIHub.setup(self, environment=environment)
if not should_schedule:
return False
if flags.automatedInstall:
sys.stdout.write(_("Starting automated install"))
sys.stdout.flush()
spokes = self._keys.values()
while not all(spoke.ready for spoke in spokes):
sys.stdout.write('.')
sys.stdout.flush()
time.sleep(1)
print('')
for spoke in spokes:
if spoke.changed:
spoke.execute()
return True
# override the prompt so that we can skip user input on kickstarts
# where all the data is in hand. If not in hand, do the actual prompt.
def prompt(self, args=None):
incompleteSpokes = [spoke for spoke in self._keys.values()
if spoke.mandatory and not spoke.completed]
# do a bit of final sanity checking, make sure pkg selection
# size < available fs space
if flags.automatedInstall:
if self._checker and not self._checker.check():
print(self._checker.error_message)
if not incompleteSpokes:
self.close()
return None
if flags.ksprompt:
for spoke in incompleteSpokes:
log.info("kickstart installation stopped for info: %s", spoke.title)
else:
errtxt = _("The following mandatory spokes are not completed:") + \
"\n" + "\n".join(spoke.title for spoke in incompleteSpokes)
log.error("CmdlineError: %s", errtxt)
raise CmdlineError(errtxt)
# if we ever need to halt the flow of a ks install to prompt users for
# input, flip off the automatedInstall flag -- this way installation
# does not automatically proceed once all spokes are complete, and a
# user must confirm they want to begin installation
flags.automatedInstall = False
# override the default prompt since we want to offer the 'b' to begin
# installation option here
return _(" Please make your choice from above ['%(quit)s' to quit | '%(begin)s' to begin installation |\n '%(refresh)s' to refresh]: ") % {
# TRANSLATORS: 'q' to quit
'quit': C_('TUI|Spoke Navigation', 'q'),
# TRANSLATORS: 'b' to begin installation
'begin': C_('TUI|Spoke Navigation', 'b'),
# TRANSLATORS: 'r' to refresh
'refresh': C_('TUI|Spoke Navigation', 'r')
}
def input(self, args, key):
"""Handle user input. Numbers are used to show a spoke, the rest is passed
to the higher level for processing."""
try:
number = int(key)
self.app.switch_screen_with_return(self._keys[number])
return None
except (ValueError, KeyError):
# If we get a continue, check for unfinished spokes. If unfinished
# don't continue
# TRANSLATORS: 'b' to begin installation
if key == C_('TUI|Spoke Navigation', 'b'):
for spoke in self._spokes.values():
if not spoke.completed and spoke.mandatory:
print(_("Please complete all spokes before continuing"))
return False
# do a bit of final sanity checking, making sure pkg selection
# size < available fs space
if self._checker and not self._checker.check():
print(self._checker.error_message)
return False
if self.app._screens:
self.app.close_screen()
return True
# TRANSLATORS: 'c' to continue
elif key == C_('TUI|Spoke Navigation', 'c'):
# Kind of a hack, but we want to ignore if anyone presses 'c'
# which is the global TUI key to close the current screen
return False
else:
return super(SummaryHub, self).input(args, key)
