From 626bd21ec33f352e43da995bd10ce497b1070cdf Mon Sep 17 00:00:00 2001
From: "Samantha N. Bueno" <sbueno+anaconda@redhat.com>
Date: Tue, 25 Feb 2014 04:14:31 -0500
Subject: [PATCH 3/3] Add GUI and TUI logic to handle unformatted DASDs.
 (#1064423)

In both graphical and text, if a user selects unformatted DASDs
from the local disk store, they are formatted when the user opts
to proceed (either by clicking 'Done' in the GUI or 'c' to
continue in the TUI).

Following dasdfmt, storage initialization is run again in order
to properly add the new DASDs to the devicetree and seen by the
installer.

Resolves:rhbz#1064423
---
 pyanaconda/constants.py             |  1 +
 pyanaconda/ui/gui/spokes/storage.py | 78 ++++++++++++++++++++++++++++++++++++-
 pyanaconda/ui/tui/spokes/storage.py | 47 ++++++++++++++++++++--
 3 files changed, 121 insertions(+), 5 deletions(-)

diff --git a/pyanaconda/constants.py b/pyanaconda/constants.py
index cf8a8ea..8de29a9 100644
--- a/pyanaconda/constants.py
+++ b/pyanaconda/constants.py
@@ -131,6 +131,7 @@ THREAD_ISCSI_LOGIN = "AnaIscsiLoginThread"
 THREAD_GEOLOCATION_REFRESH = "AnaGeolocationRefreshThread"
 THREAD_DATE_TIME = "AnaDateTimeThread"
 THREAD_TIME_INIT = "AnaTimeInitThread"
+THREAD_DASDFMT = "AnaDasdfmtThread"
 
 # Geolocation constants
 
diff --git a/pyanaconda/ui/gui/spokes/storage.py b/pyanaconda/ui/gui/spokes/storage.py
index bdd48ef..0fa2269 100644
--- a/pyanaconda/ui/gui/spokes/storage.py
+++ b/pyanaconda/ui/gui/spokes/storage.py
@@ -50,17 +50,20 @@ from pyanaconda.ui.gui.spokes.lib.cart import SelectedDisksDialog
 from pyanaconda.ui.gui.spokes.lib.passphrase import PassphraseDialog
 from pyanaconda.ui.gui.spokes.lib.detailederror import DetailedErrorDialog
 from pyanaconda.ui.gui.spokes.lib.resize import ResizeDialog
+from pyanaconda.ui.gui.spokes.lib.dasdfmt import DasdFormatDialog
 from pyanaconda.ui.gui.categories.system import SystemCategory
-from pyanaconda.ui.gui.utils import enlightbox, gtk_call_once, gtk_action_wait
+from pyanaconda.ui.gui.utils import enlightbox, gtk_call_once, gtk_action_wait, ignoreEscape
 
 from pyanaconda.kickstart import doKickstartStorage, getAvailableDiskSpace
+from blivet import storageInitialize, arch
 from blivet.size import Size
 from blivet.devices import MultipathDevice
-from blivet.errors import StorageError
+from blivet.errors import StorageError, DasdFormatError
 from blivet.errors import SanityError
 from blivet.errors import SanityWarning
 from blivet.platform import platform
 from blivet.devicelibs import swap as swap_lib
+from blivet.devicelibs.dasd import make_unformatted_dasd_list, format_dasd
 from pyanaconda.threads import threadMgr, AnacondaThread
 from pyanaconda.product import productName
 from pyanaconda.flags import flags
@@ -292,6 +295,11 @@ class StorageSpoke(NormalSpoke, StorageChecker):
         self.autoPartType = None
         self.clearPartType = CLEARPART_TYPE_NONE
 
+        if self.data.zerombr.zerombr and arch.isS390():
+            # run dasdfmt on any unformatted DASDs automatically
+            threadMgr.add(AnacondaThread(name=constants.THREAD_DASDFMT,
+                            target=self.run_dasdfmt))
+
         self._previous_autopart = False
 
         self._last_clicked_overview = None
@@ -357,6 +365,10 @@ class StorageSpoke(NormalSpoke, StorageChecker):
     def _doExecute(self):
         self._ready = False
         hubQ.send_not_ready(self.__class__.__name__)
+        # ugly and stupid, but on the off-chance dasdfmt is running, we can't
+        # proceed further with this
+        while threadMgr.get(constants.THREAD_DASDFMT):
+            continue
         hubQ.send_message(self.__class__.__name__, _("Saving storage configuration..."))
         try:
             doKickstartStorage(self.storage, self.data, self.instclass)
@@ -409,6 +421,8 @@ class StorageSpoke(NormalSpoke, StorageChecker):
 
         if not self._confirmed:
             msg = _("Not configured")
+        elif threadMgr.get(constants.THREAD_DASDFMT):
+            msg = _("Formatting DASDs")
         elif flags.automatedInstall and not self.storage.rootDevice:
             return msg
         elif self.data.ignoredisk.onlyuse:
@@ -681,6 +695,38 @@ class StorageSpoke(NormalSpoke, StorageChecker):
             if not selected and name in self.selected_disks:
                 self.selected_disks.remove(name)
 
+    def run_dasdfmt(self):
+        """
+        Though the same function exists in pyanaconda.ui.gui.spokes.lib.dasdfmt,
+        this instance doesn't include any of the UI pieces and should only
+        really be getting called on ks installations with "zerombr".
+        """
+        # wait for the initial storage thread to complete before taking any new
+        # actions on storage devices
+        threadMgr.wait(constants.THREAD_STORAGE)
+
+        to_format = make_unformatted_dasd_list(self.selected_disks)
+        if not to_format:
+            # nothing to do here; bail
+            return
+
+        hubQ.send_message(self.__class__.__name__, _("Formatting DASDs"))
+        for disk in to_format:
+            try:
+                format_dasd(disk)
+            except DasdFormatError as err:
+                # Log errors if formatting fails, but don't halt the installer
+                log.error(str(err))
+                continue
+
+        # now re-initialize storage to pick up the newly formatted disks
+        protectedNames = [d.name for d in self.storage.protectedDevices]
+        storageInitialize(self.storage, self.data, protectedNames)
+
+        # I really hate doing this, but the way is the way; probably the most
+        # correct way to kajigger the storage spoke into becoming ready
+        self.execute()
+
     # signal handlers
     def on_summary_clicked(self, button):
         # show the selected disks dialog
@@ -769,6 +815,34 @@ class StorageSpoke(NormalSpoke, StorageChecker):
             NormalSpoke.on_back_clicked(self, button)
             return
 
+        if arch.isS390():
+            # check for unformatted DASDs and launch dasdfmt if any discovered
+            dasds = make_unformatted_dasd_list(self.selected_disks)
+            if len(dasds) > 0:
+                dialog = DasdFormatDialog(self.data, self.storage, dasds)
+                ignoreEscape(dialog.window)
+                rc = self.run_lightbox_dialog(dialog)
+                if rc == 1:
+                    # User hit OK on the dialog, indicating they stayed on the
+                    # dialog until formatting completed and now needs to go back
+                    # to the main storage spoke.
+                    dialog.window.destroy()
+                    # make sure we stay on the storage spoke and don't return to
+                    # the summary hub
+                    self.skipTo = "StorageSpoke"
+                    # we have to manaually call refresh so changes are picked up
+                    self.refresh()
+                elif rc == 2:
+                    # User clicked uri to return to hub.
+                    NormalSpoke.on_back_clicked(self, button)
+                    return
+                elif rc != 2:
+                    # User either hit cancel on the dialog or closed it via escape, so
+                    # there was no formatting done.
+                    # NOTE: rc == 2 means the user clicked on the link that takes them
+                    # back to the hub.
+                    return
+
         # Figure out if the existing disk labels will work on this platform
         # you need to have at least one of the platform's labels in order for
         # any of the free space to be useful.
diff --git a/pyanaconda/ui/tui/spokes/storage.py b/pyanaconda/ui/tui/spokes/storage.py
index b4d40f1..d1501f1 100644
--- a/pyanaconda/ui/tui/spokes/storage.py
+++ b/pyanaconda/ui/tui/spokes/storage.py
@@ -27,15 +27,17 @@ from pyanaconda.ui.tui.spokes import NormalTUISpoke
 from pyanaconda.ui.tui.simpleline import TextWidget, CheckboxWidget
 
 from pykickstart.constants import AUTOPART_TYPE_LVM, AUTOPART_TYPE_BTRFS, AUTOPART_TYPE_PLAIN
+from blivet import storageInitialize, arch
 from blivet.size import Size
-from blivet.errors import StorageError
+from blivet.errors import StorageError, DasdFormatError
 from blivet.errors import SanityError
 from blivet.errors import SanityWarning
 from blivet.devices import DASDDevice, FcoeDiskDevice, iScsiDiskDevice, MultipathDevice, ZFCPDiskDevice
+from blivet.devicelibs.dasd import format_dasd, make_unformatted_dasd_list
 from pyanaconda.flags import flags
 from pyanaconda.kickstart import doKickstartStorage
 from pyanaconda.threads import threadMgr, AnacondaThread
-from pyanaconda.constants import THREAD_STORAGE, THREAD_STORAGE_WATCHER
+from pyanaconda.constants import THREAD_STORAGE, THREAD_STORAGE_WATCHER, THREAD_DASDFMT
 from pyanaconda.i18n import _, P_, N_
 from pyanaconda.bootloader import BootLoaderError
 
@@ -75,6 +77,13 @@ class StorageSpoke(NormalTUISpoke):
         self.errors = []
         self.warnings = []
 
+        if self.data.zerombr.zerombr and arch.isS390():
+            # if zerombr is specified in a ks file and there are unformatted
+            # dasds, automatically format them
+            to_format = make_unformatted_dasd_list(self.selected_disks)
+            if to_format:
+                self.run_dasdfmt(to_format)
+
         if not flags.automatedInstall:
             # default to using autopart for interactive installs
             self.data.autopart.autopart = True
@@ -89,7 +98,7 @@ class StorageSpoke(NormalTUISpoke):
     def ready(self):
         # By default, the storage spoke is not ready.  We have to wait until
         # storageInitialize is done.
-        return self._ready and not threadMgr.get(THREAD_STORAGE_WATCHER)
+        return self._ready and not (threadMgr.get(THREAD_STORAGE_WATCHER) or threadMgr.get(THREAD_DASDFMT))
 
     @property
     def mandatory(self):
@@ -231,6 +240,15 @@ class StorageSpoke(NormalTUISpoke):
 
         if key == "c":
             if self.selected_disks:
+                # check selected disks to see if we have any unformatted DASDs
+                # if we're on s390x, since they need to be formatted before we
+                # can use them.
+                if arch.isS390():
+                    to_format = make_unformatted_dasd_list(self.selected_disks)
+                    if to_format:
+                        self.run_dasdfmt(to_format)
+                        return None
+
                 newspoke = AutoPartSpoke(self.app, self.data, self.storage,
                                          self.payload, self.instclass)
                 self.app.switch_screen_modal(newspoke)
@@ -247,6 +265,29 @@ class StorageSpoke(NormalTUISpoke):
         except (ValueError, KeyError, IndexError):
             return key
 
+    def run_dasdfmt(self, to_format):
+        """
+        This generates the list of DASDs requiring dasdfmt and runs dasdfmt
+        against them.
+        """
+        # if the storage thread is running, wait on it to complete before taking
+        # any further actions on devices; most likely to occur if user has
+        # zerombr in their ks file
+        threadMgr.wait(THREAD_STORAGE)
+
+        for disk in to_format:
+            try:
+                print(_("Formatting /dev/%s. This may take a moment." % disk))
+                format_dasd(disk)
+            except DasdFormatError as err:
+                # Log errors if formatting fails, but don't halt the installer
+                log.error(str(err))
+                continue
+
+        # when finished formatting we need to reinitialize storage
+        protectedNames = [d.name for d in self.storage.protectedDevices]
+        storageInitialize(self.storage, self.data, protectedNames)
+
     def apply(self):
         self.autopart = self.data.autopart.autopart
         self.data.ignoredisk.onlyuse = self.selected_disks[:]
-- 
1.8.3.1

