def add_folders(self, paths):
paths_to_add = []
for path in paths:
basename = os.path.basename(os.path.normpath(path))
if not os.path.isdir(path):
error(
self,
'Cannot add "{}".'.format(basename),
"{} only supports uploading and syncing folders,"
" and not individual files.".format(APP_NAME),
)
elif self.gateway.magic_folder_exists(basename):
error(
self,
"Folder already exists",
'You already belong to a folder named "{}" on {}. Please '
"rename it and try again.".format(basename,
self.gateway.name),
)
else:
paths_to_add.append(path)
if paths_to_add:
self.hide_drop_label()
tasks = []
for path in paths_to_add:
tasks.append(self.add_folder(path))
d = DeferredList(tasks)
d.addCallback(self.maybe_restart_gateway)
def start_gateways(self):
nodedirs = get_nodedirs(config_dir)
if nodedirs:
minimize_preference = get_preference('startup', 'minimize')
if not minimize_preference or minimize_preference == 'false':
self.gui.show_main_window()
yield self.select_executable()
tor_available = yield get_tor(reactor)
logging.debug("Starting Tahoe-LAFS gateway(s)...")
for nodedir in nodedirs:
gateway = Tahoe(nodedir, executable=self.executable)
tcp = gateway.config_get('connections', 'tcp')
if tcp == 'tor' and not tor_available:
msg.error(
self.gui.main_window, "Error Connecting To Tor Daemon",
'The "{}" connection is configured to use Tor, '
'however, no running tor daemon was found.\n\n'
'This connection will be disabled until you launch '
'Tor again.'.format(gateway.name))
self.gateways.append(gateway)
d = gateway.start()
d.addCallback(gateway.ensure_folder_links)
self.gui.populate(self.gateways)
else:
self.gui.show_welcome_dialog()
yield self.select_executable()
def confirm_export(self, path):
if os.path.isfile(path):
info(self, "Export successful",
"Recovery Key successfully exported to {}".format(path))
else:
error(self, "Error exporting Recovery Key",
"Destination file not found after export: {}".format(path))
def load_from_file(self, path):
try:
with open(path, 'rb') as f:
content = f.read()
except Exception as e: # pylint: disable=broad-except
error(self, type(e).__name__, str(e))
return
self.parse_content(content)
def _load_from_file(self, path):
logging.debug("Loading %s...", self.filepath)
try:
with open(path, "rb") as f:
content = f.read()
except Exception as e: # pylint: disable=broad-except
error(self, type(e).__name__, str(e))
return
self._parse_content(content)
def _on_decryption_succeeded(self, plaintext):
logging.debug("Decryption of %s succeeded", self.filepath)
self.crypter_thread.quit()
try:
settings = json.loads(plaintext.decode("utf-8"))
except (UnicodeDecodeError, json.decoder.JSONDecodeError) as e:
error(self, type(e).__name__, str(e))
return
self.done.emit(settings)
self.crypter_thread.wait()
def get_folder_invite(self, folder):
member_id = b58encode(os.urandom(8))
try:
code = yield self.gateway.magic_folder_invite(folder, member_id)
except TahoeError as err:
code = None
self.wormhole.close()
error(self, "Invite Error", str(err))
self.close()
return folder, member_id, code
def _export_plaintext_recovery(self, gateway):
dest, _ = QFileDialog.getSaveFileName(
self.parent, "Select a destination",
os.path.join(os.path.expanduser('~'),
gateway.name + ' Recovery Key.json'))
if not dest:
return
try:
gateway.export(dest, include_rootcap=True)
except Exception as e: # pylint: disable=broad-except
error(self.parent, "Error exporting Recovery Key", str(e))
return
self.done.emit(dest)
def download_folder(self, folder_name, dest):
try:
yield self.gateway.restore_magic_folder(folder_name, dest)
except Exception as e: # pylint: disable=broad-except
error(
self,
'Error downloading folder "{}"'.format(folder_name),
'An exception was raised when downloading the "{}" folder:\n\n'
'{}: {}'.format(folder_name, type(e).__name__, str(e))
)
return
self._restart_required = True
logging.debug(
'Successfully joined folder "%s"; scheduled restart', folder_name)
def unlink_folder(self, folder_name):
try:
yield self.gateway.unlink_magic_folder_from_rootcap(folder_name)
except Exception as e: # pylint: disable=broad-except
logging.error("%s: %s", type(e).__name__, str(e))
error(
self, 'Error unlinking folder "{}"'.format(folder_name),
'An exception was raised when unlinking the "{}" folder:\n\n'
'{}: {}\n\nPlease try again later.'.format(
folder_name,
type(e).__name__, str(e)))
return
self.model().remove_folder(folder_name)
self._rescan_required = True
logging.debug('Successfully unlinked folder "%s"; scheduled rescan',
folder_name)
def export_to_file(self):
dest, _ = QFileDialog.getSaveFileName(
self, "Select a destination",
os.path.join(os.path.expanduser('~'),
APP_NAME + ' Debug Information.txt'))
if not dest:
return
try:
with atomic_write(dest, mode='w', overwrite=True) as f:
f.write(self.plaintextedit.toPlainText())
except Exception as e: # pylint: disable=broad-except
logging.error("%s: %s", type(e).__name__, str(e))
error(
self,
"Error exporting debug information",
str(e),
)
return
self.close()
def add_folder(self, path):
path = os.path.realpath(path)
self.model().add_folder(path)
folder_name = os.path.basename(path)
try:
yield self.gateway.create_magic_folder(path)
except Exception as e: # pylint: disable=broad-except
logging.error("%s: %s", type(e).__name__, str(e))
error(
self, 'Error adding folder "{}"'.format(folder_name),
'An exception was raised when adding the "{}" folder:\n\n'
'{}: {}\n\nPlease try again later.'.format(
folder_name,
type(e).__name__, str(e)))
self.model().remove_folder(folder_name)
return
self._restart_required = True
logging.debug('Successfully added folder "%s"; scheduled restart',
folder_name)
def remove_folder(self, folder_name, unlink=False):
try:
yield self.gateway.remove_magic_folder(folder_name)
except Exception as e: # pylint: disable=broad-except
error(
self,
'Error removing folder "{}"'.format(folder_name),
'An exception was raised when removing the "{}" folder:\n\n'
'{}: {}\n\nPlease try again later.'.format(
folder_name, type(e).__name__, str(e)
)
)
return
self.model().remove_folder(folder_name)
self._restart_required = True
logging.debug(
'Successfully removed folder "%s"; scheduled restart', folder_name)
if unlink:
yield self.unlink_folder(folder_name)
def start_gateways(self):
nodedirs = get_nodedirs(config_dir)
if nodedirs:
minimize_preference = get_preference("startup", "minimize")
if not minimize_preference or minimize_preference == "false":
self.gui.show_main_window()
yield self.select_executable()
tor_available = yield get_tor(reactor)
logging.debug("Starting Tahoe-LAFS gateway(s)...")
for nodedir in nodedirs:
gateway = Tahoe(nodedir, executable=self.executable)
tcp = gateway.config_get("connections", "tcp")
if tcp == "tor" and not tor_available:
logging.error("No running tor daemon found")
msg.error(
self.gui.main_window,
"Error Connecting To Tor Daemon",
'The "{}" connection is configured to use Tor, '
"however, no running tor daemon was found.\n\n"
"This connection will be disabled until you launch "
"Tor again.".format(gateway.name),
)
self.gateways.append(gateway)
d = gateway.start()
d.addCallback(gateway.ensure_folder_links)
self.gui.populate(self.gateways)
else:
self.gui.show_welcome_dialog()
yield self.select_executable()
try:
yield self.get_tahoe_version()
except Exception as e: # pylint: disable=broad-except
logging.critical("Error getting Tahoe-LAFS version")
msg.critical(
"Error getting Tahoe-LAFS version",
"{}: {}".format(type(e).__name__, str(e)),
)
reactor.stop()
def show_failure(self, failure):
error(
self,
str(failure.type.__name__),
str(failure.value)
)
def on_decryption_failed(self, msg):
self.crypter_thread.quit()
error(self, "Decryption failed", msg)
self.crypter_thread.wait()
def show_failure(self, failure):
logging.error("%s: %s", str(failure.type.__name__), str(failure.value))
error(self, str(failure.type.__name__), str(failure.value))
def _on_encryption_failed(self, message):
self.crypter_thread.quit()
error(self.parent, "Error encrypting data", message)
self.crypter_thread.wait()
