def get_tahoe_version(self):
tahoe = Tahoe(None, executable=self.executable)
version = yield tahoe.command(["--version"])
if version:
self.tahoe_version = version.split("\n")[0]
if self.tahoe_version.startswith("tahoe-lafs: "):
self.tahoe_version = self.tahoe_version.lstrip("tahoe-lafs: ")
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 get_tahoe_version(self):
tahoe = Tahoe(None, executable=self.executable)
version = yield tahoe.command(['--version'])
if version:
self.tahoe_version = version.split('\n')[0]
if self.tahoe_version.startswith('tahoe-lafs: '):
self.tahoe_version = self.tahoe_version.lstrip('tahoe-lafs: ')
def test__create_magic_folder_write_yaml(monkeypatch, tmpdir_factory):
client = Tahoe(str(tmpdir_factory.mktemp("nodedir")))
privatedir = os.path.join(client.nodedir, "private")
os.makedirs(privatedir)
monkeypatch.setattr("gridsync.tahoe.Tahoe.mkdir", lambda _: "URI:DIR2:aaa")
monkeypatch.setattr(
"gridsync.tahoe.Tahoe.get_json",
lambda x, y: ["dirnode", {
"ro_uri": "URI:DIR2-RO:bbb"
}],
)
monkeypatch.setattr("gridsync.tahoe.Tahoe.link", MagicMock())
folder_path = str(tmpdir_factory.mktemp("TestFolder"))
yield client._create_magic_folder(folder_path, "testalias", 123)
with open(os.path.join(privatedir, "magic_folders.yaml")) as f:
yaml_data = yaml.safe_load(f)
assert yaml_data == {
"magic-folders": {
os.path.basename(folder_path): {
"directory": folder_path,
"collective_dircap": "URI:DIR2-RO:bbb",
"upload_dircap": "URI:DIR2:aaa",
"poll_interval": 123,
}
}
}
def test_add_storage_servers_no_add_missing_furl(tmpdir):
nodedir = str(tmpdir.mkdir('TestGrid'))
os.makedirs(os.path.join(nodedir, 'private'))
client = Tahoe(nodedir)
storage_servers = {'node-1': {'nickname': 'One'}}
client.add_storage_servers(storage_servers)
assert client.get_storage_servers() == {}
def test_add_storage_servers_no_add_missing_furl(tmpdir):
nodedir = str(tmpdir.mkdir("TestGrid"))
os.makedirs(os.path.join(nodedir, "private"))
client = Tahoe(nodedir)
storage_servers = {"node-1": {"nickname": "One"}}
client.add_storage_servers(storage_servers)
assert client.get_storage_servers() == {}
def test__create_magic_folder_write_yaml(monkeypatch, tmpdir_factory):
client = Tahoe(str(tmpdir_factory.mktemp('nodedir')))
privatedir = os.path.join(client.nodedir, 'private')
os.makedirs(privatedir)
monkeypatch.setattr('gridsync.tahoe.Tahoe.mkdir', lambda _: 'URI:DIR2:aaa')
monkeypatch.setattr(
'gridsync.tahoe.Tahoe.get_json',
lambda x, y: ["dirnode", {
"ro_uri": "URI:DIR2-RO:bbb"
}])
monkeypatch.setattr('gridsync.tahoe.Tahoe.link', MagicMock())
folder_path = str(tmpdir_factory.mktemp('TestFolder'))
yield client._create_magic_folder(folder_path, 'testalias', 123)
with open(os.path.join(privatedir, 'magic_folders.yaml')) as f:
yaml_data = yaml.safe_load(f)
assert yaml_data == {
'magic-folders': {
os.path.basename(folder_path): {
'directory': folder_path,
'collective_dircap': 'URI:DIR2-RO:bbb',
'upload_dircap': 'URI:DIR2:aaa',
'poll_interval': 123,
}
}
}
def join_grid(self, settings):
nickname = settings['nickname']
if self.use_tor:
msg = "Connecting to {} via Tor...".format(nickname)
else:
msg = "Connecting to {}...".format(nickname)
self.update_progress.emit(msg)
icon_path = None
if nickname == 'Least Authority S4':
icon_path = resource('leastauthority.com.icon')
self.got_icon.emit(icon_path)
elif 'icon_base64' in settings:
icon_path = os.path.join(config_dir, '.icon.tmp')
self.decode_icon(settings['icon_base64'], icon_path)
elif 'icon_url' in settings:
# A temporary(?) measure to get around the performance issues
# observed when transferring a base64-encoded icon through Least
# Authority's wormhole server. Hopefully this will go away.. See:
# https://github.com/LeastAuthority/leastauthority.com/issues/539
log.debug("Fetching service icon from %s...", settings['icon_url'])
icon_path = os.path.join(config_dir, '.icon.tmp')
try:
# It's probably not worth cancelling or holding-up the setup
# process if fetching/writing the icon fails (particularly
# if doing so would require the user to get a new invite code)
# so just log a warning for now if something goes wrong...
yield self.fetch_icon(settings['icon_url'], icon_path)
except Exception as e: # pylint: disable=broad-except
log.warning("Error fetching service icon: %s", str(e))
executable = yield select_executable()
nodedir = os.path.join(config_dir, nickname)
self.gateway = Tahoe(nodedir, executable=executable)
yield self.gateway.create_client(**settings)
newscap = settings.get('newscap')
if newscap:
with open(os.path.join(nodedir, 'private', 'newscap'), 'w') as f:
f.write(newscap)
if icon_path:
try:
shutil.copy(icon_path, os.path.join(nodedir, 'icon'))
except OSError as err:
log.warning("Error copying icon file: %s", str(err))
if 'icon_url' in settings:
try:
with open(os.path.join(nodedir, 'icon.url'), 'w') as f:
f.write(settings['icon_url'])
except OSError as err:
log.warning("Error writing icon url to file: %s", str(err))
self.update_progress.emit(msg)
yield self.gateway.start()
self.client_started.emit(self.gateway)
self.update_progress.emit(msg)
yield self.gateway.await_ready()
def test_upgrade_legacy_config(tmpdir_factory):
client = Tahoe(str(tmpdir_factory.mktemp('tahoe-legacy')))
os.makedirs(os.path.join(client.nodedir, 'private'))
subclient_nodedir = os.path.join(client.magic_folders_dir, 'LegacyFolder')
privatedir = os.path.join(subclient_nodedir, 'private')
os.makedirs(privatedir)
with open(os.path.join(privatedir, 'collective_dircap'), 'w') as f:
f.write('URI:COLLECTIVE_DIRCAP')
with open(os.path.join(privatedir, 'magic_folder_dircap'), 'w') as f:
f.write('URI:MAGIC_FOLDER_DIRCAP')
db_path = os.path.join(privatedir, 'magicfolderdb.sqlite')
with open(db_path, 'a'):
os.utime(db_path, None)
subclient = Tahoe(subclient_nodedir)
subclient.config_set('magic_folder', 'local.directory', '/LegacyFolder')
subclient.config_set('magic_folder', 'poll_interval', '10')
yield client.upgrade_legacy_config()
yaml_path = os.path.join(client.nodedir, 'private', 'magic_folders.yaml')
with open(yaml_path) as f:
data = yaml.safe_load(f)
folder_data = data['magic-folders']['LegacyFolder']
assert folder_data['collective_dircap'] == 'URI:COLLECTIVE_DIRCAP'
assert folder_data['upload_dircap'] == 'URI:MAGIC_FOLDER_DIRCAP'
assert folder_data['directory'] == '/LegacyFolder'
assert folder_data['poll_interval'] == '10'
assert os.path.exists(
os.path.join(client.nodedir, 'private',
'magicfolder_LegacyFolder.sqlite'))
assert os.path.exists(client.magic_folders_dir + '.backup')
assert not os.path.exists(client.magic_folders_dir)
def test_upgrade_legacy_config(tmpdir_factory):
client = Tahoe(str(tmpdir_factory.mktemp("tahoe-legacy")))
os.makedirs(os.path.join(client.nodedir, "private"))
subclient_nodedir = os.path.join(client.magic_folders_dir, "LegacyFolder")
privatedir = os.path.join(subclient_nodedir, "private")
os.makedirs(privatedir)
with open(os.path.join(privatedir, "collective_dircap"), "w") as f:
f.write("URI:COLLECTIVE_DIRCAP")
with open(os.path.join(privatedir, "magic_folder_dircap"), "w") as f:
f.write("URI:MAGIC_FOLDER_DIRCAP")
db_path = os.path.join(privatedir, "magicfolderdb.sqlite")
with open(db_path, "a"):
os.utime(db_path, None)
subclient = Tahoe(subclient_nodedir)
subclient.config_set("magic_folder", "local.directory", "/LegacyFolder")
subclient.config_set("magic_folder", "poll_interval", "10")
yield client.upgrade_legacy_config()
yaml_path = os.path.join(client.nodedir, "private", "magic_folders.yaml")
with open(yaml_path) as f:
data = yaml.safe_load(f)
folder_data = data["magic-folders"]["LegacyFolder"]
assert folder_data["collective_dircap"] == "URI:COLLECTIVE_DIRCAP"
assert folder_data["upload_dircap"] == "URI:MAGIC_FOLDER_DIRCAP"
assert folder_data["directory"] == "/LegacyFolder"
assert folder_data["poll_interval"] == "10"
assert os.path.exists(
os.path.join(client.nodedir, "private",
"magicfolder_LegacyFolder.sqlite"))
assert os.path.exists(client.magic_folders_dir + ".backup")
assert not os.path.exists(client.magic_folders_dir)
def test_tahoe_start_use_tor_false(monkeypatch, tmpdir_factory):
client = Tahoe(str(tmpdir_factory.mktemp('tahoe-start')))
privatedir = os.path.join(client.nodedir, 'private')
os.makedirs(privatedir)
with open(os.path.join(client.nodedir, 'node.url'), 'w') as f:
f.write('http://127.0.0.1:65536')
with open(os.path.join(privatedir, 'api_auth_token'), 'w') as f:
f.write('1234567890')
client.config_set('client', 'shares.happy', '99999')
monkeypatch.setattr('gridsync.tahoe.Tahoe.command', lambda x, y, z: 9999)
yield client.start()
assert not client.use_tor
def test_add_storage_servers(tmpdir):
nodedir = str(tmpdir.mkdir('TestGrid'))
os.makedirs(os.path.join(nodedir, 'private'))
client = Tahoe(nodedir)
storage_servers = {
'node-1': {
'anonymous-storage-FURL': 'pb://test',
'nickname': 'One'
}
}
client.add_storage_servers(storage_servers)
assert client.get_storage_servers() == storage_servers
def test_add_storage_servers(tmpdir):
nodedir = str(tmpdir.mkdir("TestGrid"))
os.makedirs(os.path.join(nodedir, "private"))
client = Tahoe(nodedir)
storage_servers = {
"node-1": {
"anonymous-storage-FURL": "pb://test",
"nickname": "One"
}
}
client.add_storage_servers(storage_servers)
assert client.get_storage_servers() == storage_servers
def test_create_magic_folder_call_command_magic_folder_join_and_create_alias(
admin_dircap, num_add_alias_calls, monkeypatch, tmpdir_factory):
client = Tahoe(str(tmpdir_factory.mktemp('nodedir')))
monkeypatch.setattr('gridsync.tahoe.Tahoe.await_ready', MagicMock())
monkeypatch.setattr('gridsync.tahoe.Tahoe.load_magic_folders', MagicMock())
monkeypatch.setattr('gridsync.tahoe.Tahoe.link_magic_folder_to_rootcap',
MagicMock())
monkeypatch.setattr('gridsync.tahoe.Tahoe.command', MagicMock())
m = MagicMock()
monkeypatch.setattr('gridsync.tahoe.Tahoe.add_alias', m)
folder_path = str(tmpdir_factory.mktemp('TestFolder'))
yield client.create_magic_folder(folder_path, 'CAP1:CAP2', admin_dircap)
assert m.call_count == num_add_alias_calls
def initialize_gateways(self):
logging.debug("Initializing Tahoe-LAFS gateway(s)...")
logging.debug(self.settings)
for gateway in self.settings:
try:
t = Tahoe(gateway, self.settings[gateway]['tahoe.cfg'])
except KeyError:
t = Tahoe(gateway)
self.gateways.append(t)
for section, contents in self.settings[gateway].items():
if section == 'sync':
for local_dir, dircap in contents.items():
self.add_sync_folder(local_dir, dircap, t)
def test__create_magic_folder_add_alias(monkeypatch, tmpdir_factory):
client = Tahoe(str(tmpdir_factory.mktemp('nodedir')))
privatedir = os.path.join(client.nodedir, 'private')
os.makedirs(privatedir)
monkeypatch.setattr('gridsync.tahoe.Tahoe.mkdir', lambda _: 'URI:DIR2:aaa')
monkeypatch.setattr(
'gridsync.tahoe.Tahoe.get_json',
lambda x, y: ["dirnode", {
"ro_uri": "URI:DIR2-RO:bbb"
}])
monkeypatch.setattr('gridsync.tahoe.Tahoe.link', MagicMock())
folder_path = str(tmpdir_factory.mktemp('TestFolder'))
yield client._create_magic_folder(folder_path, 'testalias', 123)
assert client.get_alias('testalias') == 'URI:DIR2:aaa'
def tahoe(tmpdir_factory):
client = Tahoe(str(tmpdir_factory.mktemp('tahoe')), executable='tahoe_exe')
with open(os.path.join(client.nodedir, 'tahoe.cfg'), 'w') as f:
f.write('[node]\nnickname = default')
with open(os.path.join(client.nodedir, 'icon.url'), 'w') as f:
f.write('test_url')
private_dir = os.path.join(client.nodedir, 'private')
os.mkdir(private_dir)
with open(os.path.join(private_dir, 'aliases'), 'w') as f:
f.write('test_alias: test_cap')
with open(os.path.join(private_dir, 'magic_folders.yaml'), 'w') as f:
f.write("magic-folders:\n test_folder: {directory: test_dir}")
client.nodeurl = 'http://127.0.0.1:65536/'
return client
def test__create_magic_folder_add_alias(monkeypatch, tmpdir_factory):
client = Tahoe(str(tmpdir_factory.mktemp("nodedir")))
privatedir = os.path.join(client.nodedir, "private")
os.makedirs(privatedir)
monkeypatch.setattr("gridsync.tahoe.Tahoe.mkdir", lambda _: "URI:DIR2:aaa")
monkeypatch.setattr(
"gridsync.tahoe.Tahoe.get_json",
lambda x, y: ["dirnode", {
"ro_uri": "URI:DIR2-RO:bbb"
}],
)
monkeypatch.setattr("gridsync.tahoe.Tahoe.link", MagicMock())
folder_path = str(tmpdir_factory.mktemp("TestFolder"))
yield client._create_magic_folder(folder_path, "testalias", 123)
assert client.get_alias("testalias") == "URI:DIR2:aaa"
def __init__(self,
local_dir,
remote_dircap,
tahoe=None,
ignore_patterns=None):
_ignore_patterns = [
'*.gridsync-versions*', '*.part*',
'*(conflicted copy *-*-* *-*-*)*'
]
if ignore_patterns:
_ignore_patterns += ignore_patterns
super(SyncFolder, self).__init__(ignore_patterns=_ignore_patterns)
if not tahoe:
from gridsync.tahoe import Tahoe
tahoe = Tahoe()
self.tahoe = tahoe
self.local_dir = os.path.expanduser(local_dir)
self.remote_dircap = remote_dircap
self.versions_dir = os.path.join(self.local_dir, '.gridsync-versions')
self.local_snapshot = 0
self.filesystem_modified = False
self.do_backup = False
self.do_sync = False
self.sync_state = 0
self.sync_log = []
self.keep_versions = 1
self.local_checker = LoopingCall(self.check_for_changes)
self.remote_checker = LoopingCall(reactor.callInThread, self.sync)
logging.debug("{} initialized; "
"{} <-> {}".format(self, self.local_dir,
self.remote_dircap))
def test_tahoe_create_client_add_storage_servers(tmpdir, monkeypatch):
nodedir = str(tmpdir.mkdir('TestGrid'))
os.makedirs(os.path.join(nodedir, 'private'))
monkeypatch.setattr('os.path.exists',
lambda _: False) # suppress FileExistsError
monkeypatch.setattr('gridsync.tahoe.Tahoe.command', lambda x, y: None)
client = Tahoe(nodedir)
storage_servers = {
'node-1': {
'anonymous-storage-FURL': 'pb://test',
'nickname': 'One'
}
}
settings = {'nickname': 'TestGrid', 'storage': storage_servers}
yield client.create_client(**settings)
assert client.get_storage_servers() == storage_servers
def test_tahoe_create_client_add_storage_servers(tmpdir, monkeypatch):
nodedir = str(tmpdir.mkdir("TestGrid"))
os.makedirs(os.path.join(nodedir, "private"))
monkeypatch.setattr("os.path.exists",
lambda _: False) # suppress FileExistsError
monkeypatch.setattr("gridsync.tahoe.Tahoe.command", lambda x, y: None)
client = Tahoe(nodedir)
storage_servers = {
"node-1": {
"anonymous-storage-FURL": "pb://test",
"nickname": "One"
}
}
settings = {"nickname": "TestGrid", "storage": storage_servers}
yield client.create_client(**settings)
assert client.get_storage_servers() == storage_servers
def validate_grid(settings, parent=None):
nickname = settings.get("nickname")
while not nickname:
nickname, _ = prompt_for_grid_name(nickname, parent)
nodedir = os.path.join(config_dir, nickname)
if os.path.isdir(nodedir):
conflicting_introducer = False
introducer = settings.get("introducer")
if introducer:
config = Config(os.path.join(nodedir, "tahoe.cfg"))
existing_introducer = config.get("client", "introducer.furl")
if introducer != existing_introducer:
conflicting_introducer = True
conflicting_servers = False
servers = settings.get("storage")
if servers:
existing_servers = Tahoe(nodedir).get_storage_servers()
if servers != existing_servers:
conflicting_servers = True
if conflicting_introducer or conflicting_servers:
while os.path.isdir(os.path.join(config_dir, nickname)):
nickname, _ = prompt_for_grid_name(nickname, parent)
settings["nickname"] = nickname
return settings
def start(self):
self.initialize_logger(self.args.debug)
try:
os.makedirs(config_dir)
except OSError:
pass
# Acquire a filesystem lock to prevent multiple instances from running
lock = FilesystemLock(
os.path.join(config_dir, "{}.lock".format(APP_NAME)))
lock.acquire()
logging.debug("Core starting with args: %s", self.args)
logging.debug("Loaded config.txt settings: %s", settings)
self.show_message()
self.gui = Gui(self)
self.gui.show_systray()
reactor.callLater(0, self.start_gateways)
reactor.run()
for nodedir in get_nodedirs(config_dir):
Tahoe(nodedir, executable=self.executable).kill()
lock.release()
def test_validate_folders_skip_folder(monkeypatch, tmpdir_factory):
gateway = Tahoe(
os.path.join(str(tmpdir_factory.mktemp("config_dir")), "SomeGrid")
)
gateway.magic_folders = {"FolderName": {}}
monkeypatch.setattr(
"gridsync.setup.prompt_for_folder_name", lambda x, y, z: (None, 0)
)
settings = {
"nickname": "SomeGrid",
"magic-folders": {"FolderName": {"code": "aaaaaaaa+bbbbbbbb"}},
}
assert validate_folders(settings, [gateway]) == {
"nickname": "SomeGrid",
"magic-folders": {},
}
def __init__(self, parent, local_dir, remote_dircap, tahoe=None, # pylint: disable=too-many-arguments
ignore_patterns=None):
self.parent = parent
_ignore_patterns = ['*.gridsync-versions*', '*.part*',
'*(conflicted copy *-*-* *-*-*)*']
if ignore_patterns:
_ignore_patterns += ignore_patterns
super(SyncFolder, self).__init__(ignore_patterns=_ignore_patterns)
if not tahoe:
from gridsync.tahoe import Tahoe
tahoe = Tahoe()
self.tahoe = tahoe
self.local_dir = os.path.expanduser(local_dir)
self.remote_dircap = remote_dircap
self.remote_dircap_alias = None
self.versions_dir = os.path.join(self.local_dir, '.gridsync-versions')
self.local_snapshot = 0
self.filesystem_modified = False
self.do_backup = False
self.do_sync = False
self.sync_state = 0
self.sync_log = []
self.keep_versions = 1
self.local_checker = LoopingCall(self.check_for_changes)
self.remote_checker = LoopingCall(reactor.callInThread, self.sync)
self.observer = None
logging.debug("%s initialized; %s <-> %s", self, self.local_dir,
self.remote_dircap)
def start(self):
reactor.listenTCP(52045, ServerFactory(self), interface='localhost')
try:
os.makedirs(self.config.config_dir)
except OSError:
pass
if self.args.debug:
logging.basicConfig(
format='%(asctime)s %(funcName)s %(message)s',
level=logging.DEBUG,
stream=sys.stdout)
else:
logfile = os.path.join(self.config.config_dir, 'gridsync.log')
logging.basicConfig(
format='%(asctime)s %(funcName)s %(message)s',
level=logging.INFO,
filename=logfile)
logging.info("Server started with args: {}".format((self.args)))
logging.debug("$PATH is: {}".format(os.getenv('PATH')))
try:
output = Tahoe().command(["--version-and-path"])
logging.info(output.split('\n')[0])
except Exception as e:
logging.error('Error checking Tahoe-LAFS version: {}'.format(e))
# TODO: Notify user?
try:
self.settings = self.config.load()
except IOError:
self.settings = {}
if not self.settings:
reactor.callLater(0, self.first_run)
else:
self.initialize_gateways()
reactor.callLater(0, self.start_gateways)
if not self.args.no_gui:
self.tray = SystemTrayIcon(self)
self.tray.show()
state_checker = LoopingCall(self.check_state)
state_checker.start(1.0)
connection_status_updater = LoopingCall(
reactor.callInThread, self.update_connection_status)
reactor.callLater(5, connection_status_updater.start, 60)
reactor.callLater(1, self.start_sync_folders)
reactor.addSystemEventTrigger("before", "shutdown", self.stop)
reactor.suggestThreadPoolSize(20) # XXX Adjust?
reactor.run()
def test_tahoe_set_streamedlogs_maxlen_from_config_txt(monkeypatch, given,
expected):
monkeypatch.setattr("gridsync.tahoe.global_settings",
{"debug": {
"log_maxlen": given
}})
client = Tahoe()
assert client.streamedlogs._buffer.maxlen == expected
def start(self):
reactor.listenTCP(52045, ServerFactory(self), interface='localhost')
try:
os.makedirs(self.config.config_dir)
except OSError:
pass
if self.args.debug:
logging.basicConfig(format='%(asctime)s %(funcName)s %(message)s',
level=logging.DEBUG,
stream=sys.stdout)
else:
logfile = os.path.join(self.config.config_dir, 'gridsync.log')
logging.basicConfig(format='%(asctime)s %(funcName)s %(message)s',
level=logging.INFO,
filename=logfile)
logging.info("Server started with args: {}".format((self.args)))
logging.debug("$PATH is: {}".format(os.getenv('PATH')))
try:
output = Tahoe().command(["--version-and-path"])
logging.info(output.split('\n')[0])
except Exception as e:
logging.error('Error checking Tahoe-LAFS version: {}'.format(e))
# TODO: Notify user?
try:
self.settings = self.config.load()
except IOError:
self.settings = {}
if not self.settings:
reactor.callLater(0, self.first_run)
else:
self.initialize_gateways()
reactor.callLater(0, self.start_gateways)
if not self.args.no_gui:
self.tray = SystemTrayIcon(self)
self.tray.show()
state_checker = LoopingCall(self.check_state)
state_checker.start(1.0)
connection_status_updater = LoopingCall(reactor.callInThread,
self.update_connection_status)
reactor.callLater(5, connection_status_updater.start, 60)
reactor.callLater(1, self.start_sync_folders)
reactor.addSystemEventTrigger("before", "shutdown", self.stop)
reactor.suggestThreadPoolSize(20) # XXX Adjust?
reactor.run()
def test_create_magic_folder_call__create_magic_folder(exception_raised,
num_calls, monkeypatch,
tmpdir_factory):
client = Tahoe(str(tmpdir_factory.mktemp('nodedir')))
monkeypatch.setattr('gridsync.tahoe.Tahoe.await_ready', MagicMock())
monkeypatch.setattr('gridsync.tahoe.Tahoe.load_magic_folders', MagicMock())
monkeypatch.setattr('gridsync.tahoe.Tahoe.link_magic_folder_to_rootcap',
MagicMock())
monkeypatch.setattr('gridsync.tahoe.deferLater', MagicMock())
m = MagicMock(side_effect=exception_raised)
monkeypatch.setattr('gridsync.tahoe.Tahoe._create_magic_folder', m)
folder_path = str(tmpdir_factory.mktemp('TestFolder'))
if exception_raised:
with pytest.raises(exception_raised):
yield client.create_magic_folder(folder_path)
else:
yield client.create_magic_folder(folder_path)
assert m.call_count == num_calls
def test_join_folders_emit_joined_folders_signal(monkeypatch, qtbot, tmpdir):
monkeypatch.setattr('gridsync.tahoe.Tahoe.link', lambda a, b, c, d: None)
sr = SetupRunner([])
sr.gateway = Tahoe(str(tmpdir.mkdir('TestGrid')))
sr.gateway.rootcap = 'URI:rootcap'
folders_data = {'TestFolder': {'code': 'URI:1+URI:2'}}
with qtbot.wait_signal(sr.joined_folders) as blocker:
yield sr.join_folders(folders_data)
assert blocker.args == [['TestFolder']]
def test_validate_folders_skip_folder(monkeypatch, tmpdir_factory):
gateway = Tahoe(
os.path.join(str(tmpdir_factory.mktemp('config_dir')), 'SomeGrid'))
gateway.magic_folders = {'FolderName': {}}
monkeypatch.setattr('gridsync.setup.prompt_for_folder_name',
lambda x, y, z: (None, 0))
settings = {
'nickname': 'SomeGrid',
'magic-folders': {
'FolderName': {
'code': 'aaaaaaaa+bbbbbbbb'
}
}
}
assert validate_folders(settings, [gateway]) == {
'nickname': 'SomeGrid',
'magic-folders': {}
}
