def __init__(
self,
workspace_id: EntryID,
get_workspace_entry: Callable[[], WorkspaceEntry],
device: LocalDevice,
local_storage: BaseWorkspaceStorage,
backend_cmds: BackendAuthenticatedCmds,
event_bus: EventBus,
remote_devices_manager: RemoteDevicesManager,
):
self.workspace_id = workspace_id
self.get_workspace_entry = get_workspace_entry
self.device = device
self.local_storage = local_storage
self.backend_cmds = backend_cmds
self.event_bus = event_bus
self.remote_devices_manager = remote_devices_manager
self.sync_locks: Dict[EntryID, trio.Lock] = defaultdict(trio.Lock)
self.remote_loader = RemoteLoader(
self.device,
self.workspace_id,
self.get_workspace_entry,
self.backend_cmds,
self.remote_devices_manager,
self.local_storage,
)
self.transactions = SyncTransactions(
self.workspace_id,
self.get_workspace_entry,
self.device,
self.local_storage,
self.remote_loader,
self.event_bus,
)
async def _transactions_factory(device, backend_cmds, local_storage, cls=SyncTransactions):
def _get_workspace_entry():
return workspace_entry
workspace_entry = WorkspaceEntry.new("test")
workspace_manifest = LocalWorkspaceManifest.new_placeholder(
id=workspace_entry.id, now=Pendulum(2000, 1, 1)
)
async with local_storage.lock_entry_id(workspace_entry.id):
await local_storage.set_manifest(workspace_entry.id, workspace_manifest)
remote_devices_manager = remote_devices_manager_factory(device)
remote_loader = RemoteLoader(
device,
workspace_entry.id,
_get_workspace_entry,
backend_cmds,
remote_devices_manager,
local_storage,
)
return cls(
workspace_entry.id,
_get_workspace_entry,
device,
local_storage,
remote_loader,
event_bus,
)
def __init__(
self,
device: LocalDevice,
local_db: LocalDB,
backend_cmds: BackendCmdsPool,
encryption_manager,
event_bus: EventBus,
):
self.device = device
self.local_db = local_db
self.backend_cmds = backend_cmds
self.event_bus = event_bus
self._local_folder_fs = LocalFolderFS(device, local_db, event_bus)
self._local_file_fs = LocalFileFS(device, local_db,
self._local_folder_fs, event_bus)
self._remote_loader = RemoteLoader(backend_cmds, encryption_manager,
local_db)
self._syncer = Syncer(
device,
backend_cmds,
encryption_manager,
self._local_folder_fs,
self._local_file_fs,
event_bus,
)
self._sharing = Sharing(
device,
backend_cmds,
encryption_manager,
self._local_folder_fs,
self._syncer,
self._remote_loader,
event_bus,
)
def __init__(
self,
workspace_id: EntryID,
get_workspace_entry,
device: LocalDevice,
local_storage,
backend_cmds,
event_bus,
remote_device_manager,
):
self.workspace_id = workspace_id
self.get_workspace_entry = get_workspace_entry
self.device = device
self.local_storage = local_storage
self.backend_cmds = backend_cmds
self.event_bus = event_bus
self.remote_device_manager = remote_device_manager
self.sync_locks = defaultdict(trio.Lock)
self.remote_loader = RemoteLoader(
self.device,
self.workspace_id,
self.get_workspace_entry,
self.backend_cmds,
self.remote_device_manager,
self.local_storage,
)
self.transactions = SyncTransactions(
self.workspace_id,
self.get_workspace_entry,
self.device,
self.local_storage,
self.remote_loader,
self.event_bus,
)
async def _transactions_factory(device,
local_storage,
cls=SyncTransactions):
def _get_workspace_entry():
return workspace_entry
async def _get_previous_workspace_entry():
# The tests shouldn't need this yet
assert False
workspace_entry = WorkspaceEntry.new(EntryName("test"),
device.timestamp())
workspace_manifest = LocalWorkspaceManifest.new_placeholder(
device.device_id,
id=workspace_entry.id,
timestamp=datetime(2000, 1, 1))
async with local_storage.lock_entry_id(workspace_entry.id):
await local_storage.set_manifest(workspace_entry.id,
workspace_manifest)
async with backend_authenticated_cmds_factory(
device.organization_addr, device.device_id,
device.signing_key) as cmds:
remote_devices_manager = remote_devices_manager_factory(device)
remote_loader = RemoteLoader(
device,
workspace_entry.id,
_get_workspace_entry,
_get_previous_workspace_entry,
cmds,
remote_devices_manager,
local_storage,
)
yield cls(
workspace_entry.id,
_get_workspace_entry,
device,
local_storage,
remote_loader,
event_bus,
core_config,
)
def __init__(
self,
device: LocalDevice,
path: Path,
backend_cmds: BackendAuthenticatedCmds,
remote_devices_manager: RemoteDevicesManager,
event_bus: EventBus,
):
self.device = device
self.path = path
self.backend_cmds = backend_cmds
self.remote_devices_manager = remote_devices_manager
self.event_bus = event_bus
self.storage = None
# Message processing is done in-order, hence it is pointless to do
# it concurrently
self._workspace_storage_nursery = None
self._process_messages_lock = trio.Lock()
self._update_user_manifest_lock = trio.Lock()
self._workspace_storages = {}
now = pendulum_now()
wentry = WorkspaceEntry(
name="<user manifest>",
id=device.user_manifest_id,
key=device.user_manifest_key,
encryption_revision=1,
encrypted_on=now,
role_cached_on=now,
role=WorkspaceRole.OWNER,
)
self.remote_loader = RemoteLoader(
self.device,
self.device.user_manifest_id,
lambda: wentry,
self.backend_cmds,
self.remote_devices_manager,
# Hack, but fine as long as we only call `load_realm_current_roles`
None,
)
async def _transactions_factory(device,
backend_cmds,
local_storage,
cls=SyncTransactions):
def _get_workspace_entry():
return workspace_entry
async def _get_previous_workspace_entry():
# The tests shouldn't need this yet
assert False
workspace_entry = WorkspaceEntry.new("test")
workspace_manifest = LocalWorkspaceManifest.new_placeholder(
device.device_id, id=workspace_entry.id, now=datetime(2000, 1, 1))
async with local_storage.lock_entry_id(workspace_entry.id):
await local_storage.set_manifest(workspace_entry.id,
workspace_manifest)
remote_devices_manager = remote_devices_manager_factory(device)
remote_loader = RemoteLoader(
device,
workspace_entry.id,
_get_workspace_entry,
_get_previous_workspace_entry,
backend_cmds,
remote_devices_manager,
local_storage,
)
return cls(
workspace_entry.id,
_get_workspace_entry,
device,
local_storage,
remote_loader,
event_bus,
)