Sites with no network

Some field sites never see a network. People there still label, and their work still belongs in the organisation. A sync bundle carries it: a file of changes that one computer writes and another takes in. A USB stick, a shared folder or a laptop that travels between the site and the office will do.

Before you go

Sign in to the organisation on the computer that goes to the field, open the organisation’s datasets and let it sync once. Signing in registers that computer with the hub, so the hub (and every computer that syncs with it) can tell its changes are really yours. A computer that has never signed in can still label offline, but its changes can’t be carried for it.

Write a bundle

Open the organisation’s home from the account menu and choose Datasets.
Choose Write a bundle… and pick where to save it, for example on a USB stick.

The bundle holds the organisation’s changes on this computer: your own and those you received from others. It never holds audio, where recordings live on this computer, or anything the hub refused.

Take a bundle in

On the other computer, open the same organisation’s Datasets.
Choose Import a bundle… and pick the file.

Sift says what it took. Taking the same bundle twice, or two bundles that overlap, does no harm: changes it already holds are skipped. Bundles can travel in either direction and in any order; the computers end up in step once each has seen the other’s changes.

If the computer that took the bundle can reach the hub, its next sync sends the changes on. The hub records each one as the work of the person who made it, not of whoever carried it, and checks it against what that person may do now. Anyone in the organisation can carry anyone’s work.

If the person who made a change was removed from the organisation, or their role was lowered, before their work reached the hub, the hub refuses it. The computer that carried it sets it aside, so you see what everyone else sees. The author’s own computer keeps the work as refused changes when it next syncs; they can export it for a manager to import (see Refused changes).

Why a change isn’t taken

Every change is signed by the computer it was made on. Each computer’s signing key stays in its keychain, and the hub keeps the matching public key. A bundle carries the keys its changes need, vouched for by the hub, so a computer can check them even where there is no network. Sift leaves a change out when:

It isn’t signed, or comes from a computer this one doesn’t know yet. Sync this computer with the hub, then import the bundle again.
Its signature doesn’t hold. It was changed on the way, or it claims to be by someone who didn’t sign it.
It was made after its author’s computer was signed out or removed from their account, or after the author was removed from the organisation or their role was lowered (each of these retires the computer’s signing key; Sift makes a new one at the next sign-in or sync).
It is dated before its author’s computer was signed in. A change can’t claim to be older than the key that signed it.
It is yours and you can’t make it here, for example you can only view that dataset.

If the hub refuses a carried change, for example because its author couldn’t make it then, Sift sets it aside on this computer too, so you see what everyone else sees.

After the hub was restored from a backup

If the organisation’s hub is restored from a backup, it may lose changes people made after that backup. Each computer sends its own back by itself. Changes by others that your computer holds are signed by their authors and carry the hub’s receipt, so your computer sends them back too, as theirs. The hub takes them as it took them the first time, even if their author has left the organisation since. The sync badge shows “N changes held here, not on the hub yet” until the hub has them, and publishing waits until then.

A few changes may have been made before Sift signed changes. Those can only be sent again by their author’s own computer. Choose held here… on the Datasets page to see each one and what becomes of it.

What the hub can’t know

A computer that carries a bundle could pass on only some of the changes in it. The hub can’t tell what it wasn’t given. Every change it takes still stands on its author’s own signature, and the author’s own computer sends the rest when it syncs.