async def _trio_claim_user(
queue,
qt_on_done,
qt_on_error,
config,
addr,
device_id,
token,
use_pkcs11,
password=None,
pkcs11_token=None,
pkcs11_key=None,
):
portal = trio.BlockingTrioPortal()
queue.put(portal)
with trio.open_cancel_scope() as cancel_scope:
queue.put(cancel_scope)
try:
async with backend_anonymous_cmds_factory(addr) as cmds:
device = await core_claim_user(cmds, device_id, token)
if use_pkcs11:
devices_manager.save_device_with_pkcs11(
config.config_dir, device, pkcs11_token, pkcs11_key)
else:
devices_manager.save_device_with_password(
config.config_dir, device, password)
qt_on_done.emit()
except BackendCmdsBadResponse as e:
qt_on_error.emit(e.status)
async def _bootstrap_organization(
debug, device_id, organization_bootstrap_addr, config_dir, force, password
):
root_signing_key = SigningKey.generate()
root_verify_key = root_signing_key.verify_key
organization_addr = organization_bootstrap_addr.generate_organization_addr(root_verify_key)
device_display = click.style(device_id, fg="yellow")
device = generate_new_device(device_id, organization_addr)
with operation(f"Creating locally {device_display}"):
save_device_with_password(config_dir, device, password, force=force)
now = pendulum.now()
certified_user = certify_user(None, root_signing_key, device.user_id, device.public_key, now)
certified_device = certify_device(None, root_signing_key, device_id, device.verify_key, now)
async with spinner(f"Sending {device_display} to server"):
async with backend_anonymous_cmds_factory(organization_bootstrap_addr) as cmds:
await cmds.organization_bootstrap(
organization_bootstrap_addr.organization_id,
organization_bootstrap_addr.bootstrap_token,
root_verify_key,
certified_user,
certified_device,
)
organization_addr_display = click.style(organization_addr, fg="yellow")
click.echo(f"Organization url: {organization_addr_display}")
async def _claim_user(config, backend_addr, token, new_device_id, password,
pkcs11):
async with backend_anonymous_cmds_factory(backend_addr) as cmds:
async with spinner("Waiting for referee to reply"):
device = await actual_claim_user(cmds, new_device_id, token)
device_display = click.style(new_device_id, fg="yellow")
with operation(f"Saving locally {device_display}"):
if pkcs11:
token_id = click.prompt("PCKS11 token id", type=int)
key_id = click.prompt("PCKS11 key id", type=int)
save_device_with_pkcs11(config.config_dir, device, token_id,
key_id)
else:
save_device_with_password(config.config_dir, device, password)
async def amain(
backend_address="ws://*****:*****@laptop",
bob_device_id="bob@laptop",
other_device_name="pc",
alice_workspace="alicews",
bob_workspace="bobws",
password="******",
administrator_token=DEFAULT_ADMINISTRATOR_TOKEN,
force=False,
):
configure_logging("WARNING")
config_dir = get_default_config_dir(os.environ)
organization_id = OrganizationID(organization_id)
backend_address = BackendAddr(backend_address)
alice_device_id = DeviceID(alice_device_id)
bob_device_id = DeviceID(bob_device_id)
alice_slugid = f"{organization_id}:{alice_device_id}"
bob_slugid = f"{organization_id}:{bob_device_id}"
# Create organization
async with backend_administrator_cmds_factory(backend_address, administrator_token) as cmds:
bootstrap_token = await cmds.organization_create(organization_id)
organization_bootstrap_addr = BackendOrganizationBootstrapAddr.build(
backend_address, organization_id, bootstrap_token
)
# Bootstrap organization and Alice user
async with backend_anonymous_cmds_factory(organization_bootstrap_addr) as cmds:
root_signing_key = SigningKey.generate()
root_verify_key = root_signing_key.verify_key
organization_addr = organization_bootstrap_addr.generate_organization_addr(root_verify_key)
alice_device = generate_new_device(alice_device_id, organization_addr)
save_device_with_password(config_dir, alice_device, password, force=force)
now = pendulum.now()
certified_user = certify_user(
None, root_signing_key, alice_device.user_id, alice_device.public_key, now
)
certified_device = certify_device(
None, root_signing_key, alice_device_id, alice_device.verify_key, now
)
await cmds.organization_bootstrap(
organization_bootstrap_addr.organization_id,
organization_bootstrap_addr.bootstrap_token,
root_verify_key,
certified_user,
certified_device,
)
# Create a workspace for Alice
config = load_config(config_dir, debug="DEBUG" in os.environ)
async with logged_core_factory(config, alice_device) as core:
await core.fs.workspace_create(f"/{alice_workspace}")
# Register a new device for Alice
token = generate_invitation_token()
other_alice_device_id = DeviceID("@".join((alice_device.user_id, other_device_name)))
other_alice_slugid = f"{organization_id}:{other_alice_device_id}"
async def invite_task():
async with backend_cmds_factory(
alice_device.organization_addr, alice_device.device_id, alice_device.signing_key
) as cmds:
await invite_and_create_device(alice_device, cmds, other_device_name, token)
async def claim_task():
async with backend_anonymous_cmds_factory(alice_device.organization_addr) as cmds:
other_alice_device = await retry(claim_device, cmds, other_alice_device_id, token)
save_device_with_password(config_dir, other_alice_device, password, force=force)
async with trio.open_nursery() as nursery:
nursery.start_soon(invite_task)
nursery.start_soon(claim_task)
# Invite Bob in
token = generate_invitation_token()
async def invite_task():
async with backend_cmds_factory(
alice_device.organization_addr, alice_device.device_id, alice_device.signing_key
) as cmds:
await invite_and_create_user(
alice_device, cmds, bob_device_id.user_id, token, is_admin=True
)
async def claim_task():
async with backend_anonymous_cmds_factory(alice_device.organization_addr) as cmds:
bob_device = await retry(claim_user, cmds, bob_device_id, token)
save_device_with_password(config_dir, bob_device, password, force=force)
async with trio.open_nursery() as nursery:
nursery.start_soon(invite_task)
nursery.start_soon(claim_task)
# Create bob workspace and share with Alice
bob_device = load_device_with_password(
config.config_dir, organization_id, bob_device_id, password
)
async with logged_core_factory(config, bob_device) as core:
await core.fs.workspace_create(f"/{bob_workspace}")
await core.fs.share(f"/{bob_workspace}", alice_device_id.user_id)
# Share Alice workspace with bob
async with logged_core_factory(config, alice_device) as core:
await core.fs.share(f"/{alice_workspace}", bob_device_id.user_id)
# Print out
click.echo(
f"""
Mount alice and bob drives using:
$ parsec core run -P {password} -D {alice_slugid}
$ parsec core run -P {password} -D {other_alice_slugid}
$ parsec core run -P {password} -D {bob_slugid}
"""
)
async def claim_task():
async with backend_anonymous_cmds_factory(alice_device.organization_addr) as cmds:
bob_device = await retry(claim_user, cmds, bob_device_id, token)
save_device_with_password(config_dir, bob_device, password, force=force)
