def start_recovery_failure(self, parent=None):
"""
This function will start the recovery failure view and should be invoked upon a failure to recover
:return: False if it was a failure, True if it was a successful recovery or starting mantid normally.
"""
if self.current_view is not None:
raise RuntimeError("Project Recovery: A view is already open")
# Reset whether model believes recovery has been started.
rows = self.model.rows
if len(rows) == 0:
return True
self.model = ProjectRecoveryModel(self.project_recovery, self)
self._set_checkpoint_tried_values_from_rows(rows)
try:
self.current_view = RecoveryFailureView(self, parent)
self.current_view.exec_()
except Exception as e:
if isinstance(e, KeyboardInterrupt):
raise
return False
# If start mantid normally has been clicked we want to cancel recovery attempts
if self.start_mantid_normally_called:
return True
# If run has failed and recovery is not running then start the recovery GUI
if self.model.has_failed_run:
return False
return True
def setUp(self):
self.pr = ProjectRecovery(multifileinterpreter=None)
# Make absolutely sure that the workbench-recovery directory is cleared.
if os.path.exists(self.pr.recovery_directory):
shutil.rmtree(self.pr.recovery_directory)
# Set up some checkpoints
self.setup_some_checkpoints()
self.pr._make_process_from_pid = mock.MagicMock()
self.pr._is_mantid_workbench_process = mock.MagicMock(
return_value=True)
self.prm = ProjectRecoveryModel(self.pr, mock.MagicMock())
def __init__(self, project_recovery, model=None):
self.model = model if model else ProjectRecoveryModel(project_recovery, self)
self.current_view = None
self.project_recovery = project_recovery
self.start_mantid_normally_called = False
self.allow_start_mantid_normally = True
self.open_selected_in_editor_selected = False
def setUp(self):
self.pr = ProjectRecovery(multifileinterpreter=None)
# Make absolutely sure that the workbench-recovery directory is cleared.
if os.path.exists(self.pr.recovery_directory):
shutil.rmtree(self.pr.recovery_directory)
# Set up some checkpoints
self.setup_some_checkpoints()
self.pr._make_process_from_pid = mock.MagicMock()
self.pr._is_mantid_workbench_process = mock.MagicMock(return_value=True)
self.prm = ProjectRecoveryModel(self.pr, mock.MagicMock())
class ProjectRecoveryModelTest(unittest.TestCase):
def setUp(self):
self.pr = ProjectRecovery(multifileinterpreter=None)
# Make absolutely sure that the workbench-recovery directory is cleared.
if os.path.exists(self.pr.recovery_directory):
shutil.rmtree(self.pr.recovery_directory)
# Set up some checkpoints
self.setup_some_checkpoints()
self.pr._make_process_from_pid = mock.MagicMock()
self.pr._is_mantid_workbench_process = mock.MagicMock(
return_value=True)
self.prm = ProjectRecoveryModel(self.pr, mock.MagicMock())
def tearDown(self):
# Make sure to clear the hostname layer between tests
ADS.clear()
if os.path.exists(self.pid):
shutil.rmtree(self.pid)
def setup_some_checkpoints(self):
self.pr._spin_off_another_time_thread = mock.MagicMock()
directory = self.pr.recovery_directory_hostname
# Add a numbered folder for the pid
self.pid = os.path.join(directory, "3000000")
if not os.path.exists(self.pid):
os.makedirs(self.pid)
self.pr._recovery_directory_pid = self.pid
# Add 5 workspaces
for ii in range(0, 5):
CreateSampleWorkspace(OutputWorkspace=str(ii))
self.pr.saver._spin_off_another_time_thread = mock.MagicMock()
self.pr.recovery_save()
def test_find_number_of_workspaces_in_directory(self):
# Expect 0 as just checkpoints
self.assertEqual(
self.prm.find_number_of_workspaces_in_directory(self.pid), 0)
self.assertTrue(os.path.exists(self.pid))
list_dir = os.listdir(self.pid)
list_dir.sort()
self.assertEqual(
self.prm.find_number_of_workspaces_in_directory(
os.path.join(self.pid, list_dir[0])), 5)
def test_get_row_as_string(self):
row = self.prm.rows[0]
self.assertEqual(self.prm.get_row(row[0]), row)
def test_get_row_as_int(self):
row = self.prm.rows[0]
self.assertEqual(self.prm.get_row(0), row)
def test_get_row_as_string_not_found(self):
row = ["", "", ""]
self.assertEqual(self.prm.get_row("asdadasdasd"), row)
def test_start_mantid_normally(self):
self.prm.start_mantid_normally()
self.assertEqual(self.prm.presenter.close_view.call_count, 1)
def test_recover_selected_checkpoint(self):
checkpoint = os.listdir(self.pid)[0]
self.prm._start_recovery_of_checkpoint = mock.MagicMock()
self.prm.recover_selected_checkpoint(checkpoint)
self.assertEqual(
1,
self.prm.presenter.change_start_mantid_to_cancel_label.call_count)
self.assertEqual(1, self.prm._start_recovery_of_checkpoint.call_count)
def test_open_selected_in_editor(self):
checkpoint = os.listdir(self.pid)[0]
self.prm.project_recovery.open_checkpoint_in_script_editor = mock.MagicMock(
)
self.prm.open_selected_in_editor(checkpoint)
self.assertEqual(
1, self.prm.project_recovery.open_checkpoint_in_script_editor.
call_count)
self.assertEqual(
self.prm.project_recovery.open_checkpoint_in_script_editor.
call_args, mock.call(os.path.join(self.pid, checkpoint)))
def test_decide_last_checkpoint(self):
CreateSampleWorkspace(OutputWorkspace="6")
self.pr.recovery_save()
checkpoints = os.listdir(self.pid)
checkpoints.sort()
last_checkpoint = self.prm.decide_last_checkpoint()
self.assertEqual(checkpoints[-1], os.path.basename(last_checkpoint))
def test_fill_rows(self):
# wait a second so that we can add a second checkpoint with a different name, because the checkpoints differ at
# most by a second.
time.sleep(1)
CreateSampleWorkspace(OutputWorkspace="6")
self.pr.recovery_save()
self.prm.fill_rows()
checkpoints = os.listdir(self.pid)
checkpoints.sort()
self.assertEqual(["", "", ""], self.prm.rows[2])
self.assertEqual([checkpoints[0].replace("T", " "), "5", "No"],
self.prm.rows[1])
self.assertEqual([checkpoints[1].replace("T", " "), "6", "No"],
self.prm.rows[0])
def test_get_number_of_checkpoints(self):
self.assertEqual(int(ConfigService.getString(NO_OF_CHECKPOINTS_KEY)),
self.prm.get_number_of_checkpoints())
def test_update_checkpoint_tried(self):
checkpoints = os.listdir(self.pid)
self.assertEqual(self.prm.rows[0][2], "No")
self.prm._update_checkpoint_tried(
os.path.join(self.pid, checkpoints[0]))
self.assertEqual(self.prm.rows[0][2], "Yes")
class ProjectRecoveryPresenter(object):
def __init__(self, project_recovery, model=None):
self.model = model if model else ProjectRecoveryModel(
project_recovery, self)
self.current_view = None
self.project_recovery = project_recovery
self.start_mantid_normally_called = False
self.allow_start_mantid_normally = True
self.open_selected_in_editor_selected = False
def start_recovery_view(self, parent=None):
"""
This function will start the recovery view and should be invoked if a recovery needs to be attempted
:return: False if it was a failure, True if it was a successful recovery or starting mantid normally.
"""
# Only start this view if there is nothing as current_view
if self.current_view is not None:
raise RuntimeError("Project Recovery: A view is already open")
try:
self.current_view = ProjectRecoveryWidgetView(self, parent)
self.current_view.exec_()
except Exception as e:
if isinstance(e, KeyboardInterrupt):
raise
return False
# If start mantid normally has been clicked we want to cancel recovery attempts
if self.start_mantid_normally_called:
return True
# If run has failed and recovery is not running then start the recovery GUI
if self.model.has_failed_run:
return False
return True
def start_recovery_failure(self, parent=None):
"""
This function will start the recovery failure view and should be invoked upon a failure to recover
:return: False if it was a failure, True if it was a successful recovery or starting mantid normally.
"""
if self.current_view is not None:
raise RuntimeError("Project Recovery: A view is already open")
# Reset whether model believes recovery has been started.
rows = self.model.rows
if len(rows) == 0:
return True
self.model = ProjectRecoveryModel(self.project_recovery, self)
self._set_checkpoint_tried_values_from_rows(rows)
try:
self.current_view = RecoveryFailureView(self, parent)
self.current_view.exec_()
except Exception as e:
if isinstance(e, KeyboardInterrupt):
raise
return False
# If start mantid normally has been clicked we want to cancel recovery attempts
if self.start_mantid_normally_called:
return True
# If run has failed and recovery is not running then start the recovery GUI
if self.model.has_failed_run:
return False
return True
def _set_checkpoint_tried_values_from_rows(self, rows):
"""
Communicate to the model that a row has been tried and make sure it updates
:param rows: List of List of Strings; The row representation
"""
for ii in range(0, self.get_number_of_checkpoints()):
self.model.rows[ii][2] = rows[ii][2]
def get_row(self, index):
"""
Return the row at the given index
:param index: int; given index
:return: List of Strings; The row representation
"""
row = self.model.get_row(index)
if row == []:
return ["", "", ""]
else:
return row
def recover_last(self):
"""
Recover the last checkpoint that was saved
:return: None: If recovery is already running
"""
if self.model.is_recovery_running:
return
checkpoint_to_recover = self.model.decide_last_checkpoint()
self.model.recover_selected_checkpoint(checkpoint_to_recover)
def open_last_in_editor(self):
"""
Open the last checkpoint in editor
:return: None; If recovery is already running
"""
if self.model.is_recovery_running:
return
checkpoint_to_recover = self.model.decide_last_checkpoint()
self.model.open_selected_in_editor(checkpoint_to_recover)
def start_mantid_normally(self):
"""
Start mantid normally
:return: None; If you starting normally has been disallowed and the current_view is None.
"""
# If mantid has started a recovery this will be False, thus meaning it is the "Cancel" button which will in turn
# abort the script and then "Start mantid normally"
if not self.allow_start_mantid_normally:
# If current_view is none then we can't run the following code so return, it could clear up checkpoints that
# shouldn't be cleared
if self.current_view is None:
return
else:
self.current_view.emit_abort_script()
self.start_mantid_normally_called = True
self.model.start_mantid_normally()
def recover_selected_checkpoint(self, selected):
"""
Recover the passed checkpoint
:param selected: String; The representation of the checkpoint name/folder to be recovered
:return: None; If recovery is already running
"""
if self.model.is_recovery_running:
return
self.model.recover_selected_checkpoint(selected)
def open_selected_checkpoint_in_editor(self, selected):
"""
Open the selected checkpoint
:param selected: String; The representation of the checkpoint name/folder to be recovered
:return: None; If recovery is already running
"""
if self.model.is_recovery_running:
return
self.open_selected_in_editor_selected = True
self.model.open_selected_in_editor(selected)
def close_view(self):
"""
Will close the currently open view
"""
if self.current_view is not None:
self.current_view.setVisible(False)
self.current_view = None
def connect_progress_bar_to_recovery_view(self):
"""
Connects the progress bar to the multifileinterpreter via the project recovery object
"""
self.current_view.connect_progress_bar()
def change_start_mantid_to_cancel_label(self):
"""
Changes the Start Mantid Normally button to Cancel Recovery
"""
self.allow_start_mantid_normally = False
self.current_view.change_start_mantid_button("Cancel Recovery")
def set_up_progress_bar(self, max_value):
"""
Sets up the progress bar by setting the max value of the progress value passed
:param max_value: Int; The max value of the View's progress bar
"""
self.current_view.set_progress_bar_maximum(max_value)
def get_number_of_checkpoints(self):
"""
Gets the number of checkpoints that need to be displayed
:return: Int; The number of checkpoints
"""
return self.model.get_number_of_checkpoints()
class ProjectRecoveryModelTest(unittest.TestCase):
def setUp(self):
self.pr = ProjectRecovery(multifileinterpreter=None)
# Make absolutely sure that the workbench-recovery directory is cleared.
if os.path.exists(self.pr.recovery_directory):
shutil.rmtree(self.pr.recovery_directory)
# Set up some checkpoints
self.setup_some_checkpoints()
self.pr._make_process_from_pid = mock.MagicMock()
self.pr._is_mantid_workbench_process = mock.MagicMock(return_value=True)
self.prm = ProjectRecoveryModel(self.pr, mock.MagicMock())
def tearDown(self):
# Make sure to clear the hostname layer between tests
ADS.clear()
if os.path.exists(self.pid):
shutil.rmtree(self.pid)
def setup_some_checkpoints(self):
self.pr._spin_off_another_time_thread = mock.MagicMock()
directory = self.pr.recovery_directory_hostname
# Add a numbered folder for the pid
self.pid = os.path.join(directory, "3000000")
if not os.path.exists(self.pid):
os.makedirs(self.pid)
self.pr._recovery_directory_pid = self.pid
# Add 5 workspaces
for ii in range(0, 5):
CreateSampleWorkspace(OutputWorkspace=str(ii))
self.pr.saver._spin_off_another_time_thread = mock.MagicMock()
self.pr.recovery_save()
def test_find_number_of_workspaces_in_directory(self):
# Expect 0 as just checkpoints
self.assertEqual(self.prm.find_number_of_workspaces_in_directory(self.pid), 0)
self.assertTrue(os.path.exists(self.pid))
list_dir = os.listdir(self.pid)
list_dir.sort()
self.assertEqual(self.prm.find_number_of_workspaces_in_directory(os.path.join(self.pid, list_dir[0])), 5)
def test_get_row_as_string(self):
row = self.prm.rows[0]
self.assertEqual(self.prm.get_row(row[0]), row)
def test_get_row_as_int(self):
row = self.prm.rows[0]
self.assertEqual(self.prm.get_row(0), row)
def test_get_row_as_string_not_found(self):
row = ["", "", ""]
self.assertEqual(self.prm.get_row("asdadasdasd"), row)
def test_start_mantid_normally(self):
self.prm.start_mantid_normally()
self.assertEqual(self.prm.presenter.close_view.call_count, 1)
def test_recover_selected_checkpoint(self):
checkpoint = os.listdir(self.pid)[0]
self.prm._start_recovery_of_checkpoint = mock.MagicMock()
self.prm.recover_selected_checkpoint(checkpoint)
self.assertEqual(1, self.prm.presenter.change_start_mantid_to_cancel_label.call_count)
self.assertEqual(1, self.prm._start_recovery_of_checkpoint.call_count)
def test_open_selected_in_editor(self):
checkpoint = os.listdir(self.pid)[0]
self.prm.project_recovery.open_checkpoint_in_script_editor = mock.MagicMock()
self.prm.open_selected_in_editor(checkpoint)
self.assertEqual(1, self.prm.project_recovery.open_checkpoint_in_script_editor.call_count)
self.assertEqual(self.prm.project_recovery.open_checkpoint_in_script_editor.call_args,
mock.call(os.path.join(self.pid, checkpoint)))
def test_decide_last_checkpoint(self):
CreateSampleWorkspace(OutputWorkspace="6")
self.pr.recovery_save()
checkpoints = os.listdir(self.pid)
checkpoints.sort()
last_checkpoint = self.prm.decide_last_checkpoint()
self.assertEqual(checkpoints[-1], os.path.basename(last_checkpoint))
def test_fill_rows(self):
# wait a second so that we can add a second checkpoint with a different name, because the checkpoints differ at
# most by a second.
time.sleep(1)
CreateSampleWorkspace(OutputWorkspace="6")
self.pr.recovery_save()
self.prm.fill_rows()
checkpoints = os.listdir(self.pid)
checkpoints.sort()
self.assertEqual(["", "", ""], self.prm.rows[2])
self.assertEqual([checkpoints[0].replace("T", " "), "5", "No"], self.prm.rows[1])
self.assertEqual([checkpoints[1].replace("T", " "), "6", "No"], self.prm.rows[0])
def test_get_number_of_checkpoints(self):
self.assertEqual(int(ConfigService.getString(NO_OF_CHECKPOINTS_KEY)),
self.prm.get_number_of_checkpoints())
def test_update_checkpoint_tried(self):
checkpoints = os.listdir(self.pid)
self.assertEqual(self.prm.rows[0][2], "No")
self.prm._update_checkpoint_tried(os.path.join(self.pid, checkpoints[0]))
self.assertEqual(self.prm.rows[0][2], "Yes")