def __init__(self, root_state_dir, api_port, api_key, error_handler):
QObject.__init__(self, None)
self._logger = logging.getLogger(self.__class__.__name__)
self.root_state_dir = root_state_dir
self.core_process = None
self.api_port = api_port
self.api_key = api_key
self.events_manager = EventRequestManager(self.api_port, self.api_key,
error_handler)
self.upgrade_manager = None
self.core_args = None
self.core_env = None
self.core_started = False
self.core_running = False
self.core_connected = False
self.shutting_down = False
self.core_finished = False
self.quitting_app = False
self.should_quit_app_on_core_finished = False
self.use_existing_core = True
self.last_core_stdout_output: str = ''
self.last_core_stderr_output: str = ''
connect(self.events_manager.tribler_started, self.on_core_connected)
app = QApplication.instance()
if app is not None:
# app can be None in tests where Qt application is not created
connect(app.aboutToQuit, self.on_about_to_quit)
def __init__(self, api_port, api_key, error_handler):
QObject.__init__(self, None)
self._logger = logging.getLogger(self.__class__.__name__)
self.base_path = get_base_path()
if not is_frozen():
self.base_path = os.path.join(get_base_path(), "..")
self.core_process = None
self.api_port = api_port
self.api_key = api_key
self.events_manager = EventRequestManager(self.api_port, self.api_key,
error_handler)
self.shutting_down = False
self.should_stop_on_shutdown = False
self.use_existing_core = True
self.is_core_running = False
self.core_traceback = None
self.core_traceback_timestamp = 0
self.check_state_timer = QTimer()
self.check_state_timer.setSingleShot(True)
connect(self.check_state_timer.timeout, self.check_core_ready)
def __init__(self, api_port, api_key):
QObject.__init__(self, None)
self.base_path = get_base_path()
if not is_frozen():
self.base_path = os.path.join(get_base_path(), "..")
self.core_process = None
self.api_port = api_port
self.api_key = api_key
self.events_manager = EventRequestManager(self.api_port, self.api_key)
self.shutting_down = False
self.should_stop_on_shutdown = False
self.use_existing_core = True
self.is_core_running = False
self.core_traceback = None
self.check_state_timer = QTimer()
class CoreManager(QObject):
"""
The CoreManager is responsible for managing the Tribler core (starting/stopping). When we are running the GUI tests,
a fake API will be started.
"""
tribler_stopped = pyqtSignal()
core_state_update = pyqtSignal(str)
def __init__(self, api_port, api_key, error_handler):
QObject.__init__(self, None)
self._logger = logging.getLogger(self.__class__.__name__)
self.base_path = get_base_path()
if not is_frozen():
self.base_path = os.path.join(get_base_path(), "..")
self.core_process = None
self.api_port = api_port
self.api_key = api_key
self.events_manager = EventRequestManager(self.api_port, self.api_key,
error_handler)
self.shutting_down = False
self.should_stop_on_shutdown = False
self.use_existing_core = True
self.is_core_running = False
self.core_traceback = None
self.core_traceback_timestamp = 0
self.check_state_timer = QTimer()
self.check_state_timer.setSingleShot(True)
connect(self.check_state_timer.timeout, self.check_core_ready)
def on_core_read_ready(self):
raw_output = bytes(self.core_process.readAll())
decoded_output = raw_output.decode(errors="replace")
if b'Traceback' in raw_output:
self.core_traceback = decoded_output
self.core_traceback_timestamp = int(round(time.time() * 1000))
print(decoded_output.strip()) # noqa: T001
def on_core_finished(self, exit_code, exit_status):
if self.shutting_down and self.should_stop_on_shutdown:
self.on_finished()
elif not self.shutting_down and exit_code != 0:
# Stop the event manager loop if it is running
if self.events_manager.connect_timer and self.events_manager.connect_timer.isActive(
):
self.events_manager.connect_timer.stop()
exception_msg = (
f"The Tribler core has unexpectedly finished "
f"with exit code {exit_code} and status: {exit_status}!")
if self.core_traceback:
exception_msg += "\n\n%s\n(Timestamp: %d, traceback timestamp: %d)" % (
self.core_traceback,
int(round(time.time() * 1000)),
self.core_traceback_timestamp,
)
raise RuntimeError(exception_msg)
def start(self, core_args=None, core_env=None):
"""
First test whether we already have a Tribler process listening on port <CORE_API_PORT>.
If so, use that one and don't start a new, fresh session.
"""
def on_request_error(_):
self.use_existing_core = False
self.start_tribler_core(core_args=core_args, core_env=core_env)
self.events_manager.connect()
connect(self.events_manager.reply.error, on_request_error)
# This is a hack to determine if we have notify the user to wait for the directory fork to finish
_, _, src_dir, tgt_dir = should_fork_state_directory(
get_root_state_directory(), version_id)
if src_dir is not None:
# There is going to be a directory fork, so we extend the core connection timeout and notify the user
self.events_manager.remaining_connection_attempts = 1200
self.events_manager.change_loading_text.emit(
"Copying data from previous Tribler version, please wait")
def start_tribler_core(self, core_args=None, core_env=None):
if not START_FAKE_API:
if not core_env:
core_env = QProcessEnvironment.systemEnvironment()
core_env.insert("CORE_PROCESS", "1")
core_env.insert("CORE_BASE_PATH", self.base_path)
core_env.insert("CORE_API_PORT", f"{self.api_port}")
core_env.insert("CORE_API_KEY", self.api_key.decode('utf-8'))
if not core_args:
core_args = sys.argv
self.core_process = QProcess()
self.core_process.setProcessEnvironment(core_env)
self.core_process.setReadChannel(QProcess.StandardOutput)
self.core_process.setProcessChannelMode(QProcess.MergedChannels)
connect(self.core_process.readyRead, self.on_core_read_ready)
connect(self.core_process.finished, self.on_core_finished)
self.core_process.start(sys.executable, core_args)
self.check_core_ready()
def check_core_ready(self):
TriblerNetworkRequest("state",
self.on_received_state,
capture_core_errors=False,
priority=QNetworkRequest.HighPriority)
def on_received_state(self, state):
if not state or 'state' not in state or state['state'] not in [
'STARTED', 'EXCEPTION'
]:
self.check_state_timer.start(50)
return
self.core_state_update.emit(state['readable_state'])
if state['state'] == 'STARTED':
self.events_manager.connect(reschedule_on_err=False)
self.is_core_running = True
elif state['state'] == 'EXCEPTION':
raise RuntimeError(state['last_exception'])
def stop(self, stop_app_on_shutdown=True):
if self.core_process or self.is_core_running:
self.events_manager.shutting_down = True
TriblerNetworkRequest("shutdown",
lambda _: None,
method="PUT",
priority=QNetworkRequest.HighPriority)
if stop_app_on_shutdown:
self.should_stop_on_shutdown = True
def on_finished(self):
self.tribler_stopped.emit()
if self.shutting_down:
QApplication.quit()
class CoreManager(QObject):
"""
The CoreManager is responsible for managing the Tribler core (starting/stopping). When we are running the GUI tests,
a fake API will be started.
"""
def __init__(self, root_state_dir, api_port, api_key, error_handler):
QObject.__init__(self, None)
self._logger = logging.getLogger(self.__class__.__name__)
self.root_state_dir = root_state_dir
self.core_process = None
self.api_port = api_port
self.api_key = api_key
self.events_manager = EventRequestManager(self.api_port, self.api_key,
error_handler)
self.upgrade_manager = None
self.core_args = None
self.core_env = None
self.core_started = False
self.core_running = False
self.core_connected = False
self.shutting_down = False
self.core_finished = False
self.quitting_app = False
self.should_quit_app_on_core_finished = False
self.use_existing_core = True
self.last_core_stdout_output: str = ''
self.last_core_stderr_output: str = ''
connect(self.events_manager.tribler_started, self.on_core_connected)
app = QApplication.instance()
if app is not None:
# app can be None in tests where Qt application is not created
connect(app.aboutToQuit, self.on_about_to_quit)
def on_about_to_quit(self):
self.quitting_app = True
def on_core_connected(self, _):
if not self.core_finished:
self.core_connected = True
def start(self,
core_args=None,
core_env=None,
upgrade_manager=None,
run_core=True):
"""
First test whether we already have a Tribler process listening on port <CORE_API_PORT>.
If so, use that one and don't start a new, fresh Core.
"""
# Connect to the events manager
self.events_manager.connect()
if run_core:
self.core_args = core_args
self.core_env = core_env
self.upgrade_manager = upgrade_manager
connect(self.events_manager.reply.error,
self.on_event_manager_initial_error)
def on_event_manager_initial_error(self, _):
if self.upgrade_manager:
# Start Tribler Upgrader. When it finishes, start Tribler Core
connect(self.upgrade_manager.upgrader_finished,
self.start_tribler_core)
self.upgrade_manager.start()
else:
self.start_tribler_core()
def start_tribler_core(self):
self.use_existing_core = False
core_env = self.core_env
if not core_env:
core_env = QProcessEnvironment.systemEnvironment()
core_env.insert("CORE_API_PORT", f"{self.api_port}")
core_env.insert("CORE_API_KEY", self.api_key)
core_env.insert("TSTATEDIR", str(self.root_state_dir))
core_args = self.core_args
if not core_args:
core_args = sys.argv + ['--core']
self.core_process = QProcess()
self.core_process.setProcessEnvironment(core_env)
self.core_process.setProcessChannelMode(QProcess.SeparateChannels)
connect(self.core_process.started, self.on_core_started)
connect(self.core_process.readyReadStandardOutput,
self.on_core_stdout_read_ready)
connect(self.core_process.readyReadStandardError,
self.on_core_stderr_read_ready)
connect(self.core_process.finished, self.on_core_finished)
self.core_process.start(sys.executable, core_args)
def on_core_started(self):
self.core_started = True
self.core_running = True
def on_core_stdout_read_ready(self):
if self.quitting_app:
# Reading at this stage can lead to the error "wrapped C/C++ object of type QProcess has been deleted"
return
raw_output = bytes(self.core_process.readAllStandardOutput())
self.last_core_stdout_output = raw_output.decode("utf-8").strip()
try:
print(
self.last_core_stdout_output) # print core output # noqa: T001
except OSError:
# Possible reason - cannot write to stdout as it was already closed during the application shutdown
pass
def on_core_stderr_read_ready(self):
if self.quitting_app:
# Reading at this stage can lead to the error "wrapped C/C++ object of type QProcess has been deleted"
return
raw_output = bytes(self.core_process.readAllStandardError())
self.last_core_stderr_output = raw_output.decode("utf-8").strip()
try:
print(self.last_core_stderr_output,
file=sys.stderr) # print core output # noqa: T001
except OSError:
# Possible reason - cannot write to stdout as it was already closed during the application shutdown
pass
def stop(self, quit_app_on_core_finished=True):
if quit_app_on_core_finished:
self.should_quit_app_on_core_finished = True
if self.shutting_down:
return
self.shutting_down = True
self._logger.info("Stopping Core manager")
if self.core_process or self.core_connected:
self._logger.info("Sending shutdown request to Tribler Core")
self.events_manager.shutting_down = True
TriblerNetworkRequest("shutdown",
lambda _: None,
method="PUT",
priority=QNetworkRequest.HighPriority)
def on_core_finished(self, exit_code, exit_status):
self.core_running = False
self.core_finished = True
if self.shutting_down:
if self.should_quit_app_on_core_finished:
self.quit_application()
else:
error_message = (
f"The Tribler core has unexpectedly finished with exit code {exit_code} and status: {exit_status}!\n"
f"Last core output: \n {self.last_core_stderr_output or self.last_core_stdout_output}"
)
self._logger.warning(error_message)
# Stop the event manager loop if it is running
if self.events_manager.connect_timer and self.events_manager.connect_timer.isActive(
):
self.events_manager.connect_timer.stop()
raise CoreCrashedError(error_message)
def quit_application(self):
if not self.quitting_app:
self.quitting_app = True
QApplication.quit()
class CoreManager(QObject):
"""
The CoreManager is responsible for managing the Tribler core (starting/stopping). When we are running the GUI tests,
a fake API will be started.
"""
tribler_stopped = pyqtSignal()
core_state_update = pyqtSignal(str)
def __init__(self, api_port, api_key):
QObject.__init__(self, None)
self.base_path = get_base_path()
if not is_frozen():
self.base_path = os.path.join(get_base_path(), "..")
self.core_process = None
self.api_port = api_port
self.api_key = api_key
self.events_manager = EventRequestManager(self.api_port, self.api_key)
self.shutting_down = False
self.should_stop_on_shutdown = False
self.use_existing_core = True
self.is_core_running = False
self.core_traceback = None
self.check_state_timer = QTimer()
def on_core_read_ready(self):
raw_output = bytes(self.core_process.readAll())
decoded_output = raw_output.decode(errors="replace")
if b'Traceback' in raw_output:
self.core_traceback = decoded_output
print(decoded_output.strip())
def on_core_finished(self, exit_code, exit_status):
if self.shutting_down and self.should_stop_on_shutdown:
self.on_finished()
elif not self.shutting_down and exit_code != 0:
# Stop the event manager loop if it is running
if self.events_manager.connect_timer and self.events_manager.connect_timer.isActive(
):
self.events_manager.connect_timer.stop()
exception_msg = "The Tribler core has unexpectedly finished with exit code %s and status: %s!" % \
(exit_code, exit_status)
if self.core_traceback:
exception_msg += "\n\n%s" % self.core_traceback
raise RuntimeError(exception_msg)
def start(self, core_args=None, core_env=None):
"""
First test whether we already have a Tribler process listening on port 8085. If so, use that one and don't
start a new, fresh session.
"""
def on_request_error(_):
self.use_existing_core = False
self.start_tribler_core(core_args=core_args, core_env=core_env)
self.events_manager.connect()
self.events_manager.reply.error.connect(on_request_error)
def start_tribler_core(self, core_args=None, core_env=None):
if not START_FAKE_API:
if not core_env:
core_env = QProcessEnvironment.systemEnvironment()
core_env.insert("CORE_PROCESS", "1")
core_env.insert("CORE_BASE_PATH", self.base_path)
core_env.insert("CORE_API_PORT", "%s" % self.api_port)
core_env.insert("CORE_API_KEY", self.api_key.decode('utf-8'))
if not core_args:
core_args = sys.argv
self.core_process = QProcess()
self.core_process.setProcessEnvironment(core_env)
self.core_process.setReadChannel(QProcess.StandardOutput)
self.core_process.setProcessChannelMode(QProcess.MergedChannels)
self.core_process.readyRead.connect(self.on_core_read_ready)
self.core_process.finished.connect(self.on_core_finished)
self.core_process.start(sys.executable, core_args)
self.check_core_ready()
def check_core_ready(self):
TriblerNetworkRequest("state",
self.on_received_state,
capture_errors=False,
priority=QNetworkRequest.HighPriority)
def on_received_state(self, state):
if not state or 'state' not in state or state['state'] not in [
'STARTED', 'EXCEPTION'
]:
self.check_state_timer = QTimer()
self.check_state_timer.setSingleShot(True)
self.check_state_timer.timeout.connect(self.check_core_ready)
self.check_state_timer.start(50)
return
self.core_state_update.emit(state['readable_state'])
if state['state'] == 'STARTED':
self.events_manager.connect(reschedule_on_err=False)
self.is_core_running = True
elif state['state'] == 'EXCEPTION':
raise RuntimeError(state['last_exception'])
def stop(self, stop_app_on_shutdown=True):
if self.core_process or self.is_core_running:
self.events_manager.shutting_down = True
TriblerNetworkRequest("shutdown",
lambda _: None,
method="PUT",
priority=QNetworkRequest.HighPriority)
if stop_app_on_shutdown:
self.should_stop_on_shutdown = True
def on_finished(self):
self.tribler_stopped.emit()
if self.shutting_down:
QApplication.quit()
class CoreManager(QObject):
"""
The CoreManager is responsible for managing the Tribler core (starting/stopping). When we are running the GUI tests,
a fake API will be started.
"""
tribler_stopped = pyqtSignal()
core_state_update = pyqtSignal(str)
def __init__(self, api_port, api_key, error_handler):
QObject.__init__(self, None)
self._logger = logging.getLogger(self.__class__.__name__)
self.base_path = get_base_path()
if not is_frozen():
self.base_path = os.path.join(get_base_path(), "..")
root_state_dir = get_root_state_directory()
self.version_history = VersionHistory(root_state_dir)
self.core_process = None
self.api_port = api_port
self.api_key = api_key
self.events_manager = EventRequestManager(self.api_port, self.api_key,
error_handler)
self.shutting_down = False
self.should_stop_on_shutdown = False
self.use_existing_core = True
self.is_core_running = False
self.core_traceback = None
self.core_traceback_timestamp = 0
self.check_state_timer = QTimer()
self.check_state_timer.setSingleShot(True)
connect(self.check_state_timer.timeout, self.check_core_ready)
def on_core_read_ready(self):
raw_output = bytes(self.core_process.readAll())
decoded_output = raw_output.decode(errors="replace")
if b'Traceback' in raw_output:
self.core_traceback = decoded_output
self.core_traceback_timestamp = int(round(time.time() * 1000))
print(decoded_output.strip()) # noqa: T001
def on_core_finished(self, exit_code, exit_status):
if self.shutting_down and self.should_stop_on_shutdown:
self.on_finished()
elif not self.shutting_down and exit_code != 0:
# Stop the event manager loop if it is running
if self.events_manager.connect_timer and self.events_manager.connect_timer.isActive(
):
self.events_manager.connect_timer.stop()
exception_msg = (
f"The Tribler core has unexpectedly finished "
f"with exit code {exit_code} and status: {exit_status}!")
if self.core_traceback:
exception_msg += "\n\n%s\n(Timestamp: %d, traceback timestamp: %d)" % (
self.core_traceback,
int(round(time.time() * 1000)),
self.core_traceback_timestamp,
)
raise RuntimeError(exception_msg)
def start(self, core_args=None, core_env=None):
"""
First test whether we already have a Tribler process listening on port <CORE_API_PORT>.
If so, use that one and don't start a new, fresh session.
"""
def on_request_error(_):
self.use_existing_core = False
self.start_tribler_core(core_args=core_args, core_env=core_env)
versions_to_delete = self.should_cleanup_old_versions()
if versions_to_delete:
for version in versions_to_delete:
version.delete_state()
# Connect to the events manager only after the cleanup is done
self.events_manager.connect()
connect(self.events_manager.reply.error, on_request_error)
# Determine if we have notify the user to wait for the directory fork to finish
if self.version_history.code_version.should_be_copied:
# There is going to be a directory fork, so we extend the core connection timeout and notify the user
self.events_manager.remaining_connection_attempts = 1200
self.events_manager.change_loading_text.emit(
"Copying data from previous Tribler version, please wait")
def should_cleanup_old_versions(self) -> List[TriblerVersion]:
# Skip old version check popup when running fake core, eg. during GUI tests
# or during deployment tests since it blocks the tests with a popup dialog
if START_FAKE_API or SKIP_VERSION_CLEANUP:
return []
if self.version_history.last_run_version == self.version_history.code_version:
return []
disposable_versions = self.version_history.get_disposable_versions(
skip_versions=2)
if not disposable_versions:
return []
storage_info = ""
claimable_storage = 0
for version in disposable_versions:
state_size = version.calc_state_size()
claimable_storage += state_size
storage_info += f"{version.version_str} \t {format_size(state_size)}\n"
# Show a question to the user asking if the user wants to remove the old data.
title = "Delete state directories for old versions?"
message_body = tr(
"Press 'Yes' to remove state directories for older versions of Tribler "
"and reclaim %s of storage space. "
"Tribler used those directories during upgrades from previous versions. "
"Now those directories can be safely deleted. \n\n"
"If unsure, press 'No'. "
"You will be able to remove those directories from the Settings->Data page later."
) % format_size(claimable_storage)
user_choice = self._show_question_box(title,
message_body,
storage_info,
default_button=QMessageBox.Yes)
if user_choice == QMessageBox.Yes:
return disposable_versions
return []
def _show_question_box(self,
title,
body,
additional_text,
default_button=None):
message_box = QMessageBox()
message_box.setIcon(QMessageBox.Question)
message_box.setWindowTitle(title)
message_box.setText(body)
message_box.setInformativeText(additional_text)
message_box.setStandardButtons(QMessageBox.No | QMessageBox.Yes)
if default_button:
message_box.setDefaultButton(default_button)
return message_box.exec_()
def start_tribler_core(self, core_args=None, core_env=None):
if not START_FAKE_API:
if not core_env:
core_env = QProcessEnvironment.systemEnvironment()
core_env.insert("CORE_PROCESS", "1")
core_env.insert("CORE_BASE_PATH", self.base_path)
core_env.insert("CORE_API_PORT", f"{self.api_port}")
core_env.insert("CORE_API_KEY", self.api_key.decode('utf-8'))
if not core_args:
core_args = sys.argv
self.core_process = QProcess()
self.core_process.setProcessEnvironment(core_env)
self.core_process.setReadChannel(QProcess.StandardOutput)
self.core_process.setProcessChannelMode(QProcess.MergedChannels)
connect(self.core_process.readyRead, self.on_core_read_ready)
connect(self.core_process.finished, self.on_core_finished)
self.core_process.start(sys.executable, core_args)
self.check_core_ready()
def check_core_ready(self):
TriblerNetworkRequest("state",
self.on_received_state,
capture_core_errors=False,
priority=QNetworkRequest.HighPriority)
def on_received_state(self, state):
if not state or 'state' not in state or state['state'] not in [
'STARTED', 'EXCEPTION'
]:
self.check_state_timer.start(50)
return
self.core_state_update.emit(state['readable_state'])
if state['state'] == 'STARTED':
self.events_manager.connect(reschedule_on_err=False)
self.is_core_running = True
elif state['state'] == 'EXCEPTION':
raise RuntimeError(state['last_exception'])
def stop(self, stop_app_on_shutdown=True):
if self.core_process or self.is_core_running:
self.events_manager.shutting_down = True
TriblerNetworkRequest("shutdown",
lambda _: None,
method="PUT",
priority=QNetworkRequest.HighPriority)
if stop_app_on_shutdown:
self.should_stop_on_shutdown = True
def on_finished(self):
self.tribler_stopped.emit()
if self.shutting_down:
QApplication.quit()