Merydion 1.9

Administrator's guide

The guides of the installation, the console and the organization in one document to read offline or print, in your language.

Generated from the portal's guides, Merydion 1.9.

For whoever installs Merydion

Installation and upgrade

The whole of Merydion — the portal, the six apps and the services behind them — runs on one machine. The build prepares it on the development machine in one of two forms: an image for Docker on a Linux server reached by its own domain, or a folder that runs on Windows 11 without installing anything. The machine that runs it needs no compiler.

This guide follows both ways up to the first administrator's sign-in, then covers what keeps the installation healthy: upgrades, backups, the coming-soon switch and the portal's security policy. The commands are those of the repository's deploy folder.

Before you start

The two ways to install the suite, and the file that names its administrators.

Choosing the way

The build runs on the development machine, with the repository and its tools, and hands over only what the target needs to run — never the source code. It comes in two forms, with the same services and the same apps.

  1. The image for Docker suits a Linux server with Docker Engine and a domain of its own: Caddy, inside the container, obtains the certificate from Let's Encrypt, so the domain must point at the machine and ports 80 and 443 must be reachable.
  2. The folder suits a Windows 11 x64 machine without Docker: it holds the services as programs, Caddy and the web pages, and serves HTTPS on port 8080 with a certificate of its own.
  3. Both start with an empty set of data and become usable with the first administrator: see The first administrator.
  4. Whichever you choose, keep the repository on the development machine: the upgrades are built there.

Tip The image is the way for a server open to the Internet; the folder suits a trial or a machine on the local network.

The administrators file

The installation's console opens only to the accounts listed in a plain text file called ADMINISTRATORS. Owning an organization is not enough: the file is the only list.

  1. Write one sign-in email per line; a line that starts with # is a comment, and upper or lower case makes no difference.
  2. With the image, the file is ADMINISTRATORS at the root of the repository on the server, mounted read-only into the container.
  3. With the folder, it is ADMINISTRATORS beside SERVER_CONFIGURATION.json; the variable MERYDION_ADMINISTRATORS_FILE can point to another path.
  4. The file is read again at every check: adding or removing a line takes effect at once, without restarting anything.

Tip A missing or empty file means no administrator at all: the console then refuses everyone.

The image on a Linux server

Build the image, prepare the server and start the container on your domain.

Building the image

The image is built on the development machine, with Docker Desktop running Linux containers, and travels to the server as a file: the server needs no registry and no source code.

  1. From the root of the repository, run .\rebuild_container_release.ps1 -NoSeedData: it builds the image, checks that it holds no source and every compiled part, starts it for a trial and saves it as deploy\docker\merydion-allinone.tar with its fingerprint.
  2. Copy the image and its fingerprint to the server, for example with scp deploy/docker/merydion-allinone.tar* admin@merydion.example.com:/tmp/.
  3. On the server, check the fingerprint and load the image: cd /tmp && sha256sum -c merydion-allinone.tar.sha256 && docker load -i merydion-allinone.tar.

Tip Without -NoSeedData the build also packs merydion-data.tar.gz with the development machine's data — personal data and the private key of the sign-in service included: it is not for a new installation.

Preparing the server

On the server, keep the layout of the repository: the compose file finds its neighbours by relative path. The files below belong to the server, never to the image.

  1. Point the DNS record of your domain at the server and open ports 80 and 443 to the Internet.
  2. In deploy/prod-allinone/Caddyfile, write a real email in the global block: Let's Encrypt writes to it before a certificate expires.
  3. Create deploy/prod-allinone/.env with MERYDION_DOMAIN=merydion.example.com and, so that the verification emails leave, MERYDION_AUTH_SMTP_PASSWORD= followed by the password of the mailbox.
  4. Create SERVER_SECRETS.json at the root of the repository, readable only by you (chmod 600): the other secrets of the services go there, and with none it holds { "services": {} } — without the file the container does not start.
  5. Write your email in ADMINISTRATORS, at the root of the repository.

Tip A secret never goes in SERVER_CONFIGURATION.json, which is versioned and keeps the secret fields empty; the variable of a field wins over SERVER_SECRETS.json.

Starting the container

The container holds the gateway, the services, the portal and the apps. It starts from the loaded image, without building anything on the server.

  1. From the root of the repository: docker compose --env-file deploy/prod-allinone/.env -f deploy/prod-allinone/docker-compose.yml up -d.
  2. Check that it runs: docker compose -f deploy/prod-allinone/docker-compose.yml ps must say running, not restarting.
  3. On the first visit Caddy obtains the certificate, which takes up to a minute: curl -sS https://merydion.example.com/health then answers ok.
  4. If the container keeps restarting, a service has stopped and taken the others with it: read why with docker compose -f deploy/prod-allinone/docker-compose.yml logs --tail=80.

Tip Video calls on this server also need the UDP port of the media service and a TURN relay: the single-node runbook in the repository describes the extra settings.

The folder on Windows

Build the copy-and-run folder and start it on a Windows machine.

Building the folder

The folder is built on the development machine and copied as it is: the Windows machine that runs it installs nothing — no Rust, no Node, no Docker.

  1. From the root of the repository, run .\rebuild_bare_release.ps1 -NoSeedData: it assembles deploy\bare\out\ with the services as programs, Caddy, the portal and the apps, the configuration and the start and stop scripts.
  2. If SERVER_SECRETS.json exists at the root of the repository it travels in the folder, which then has to be kept secret; otherwise write the file on the target machine, or set the variables of the secrets before starting.
  3. Copy the out folder to the Windows 11 x64 machine, wherever you like.

Tip With -NoSeedData the folder holds an empty set of data; without it, a copy of the development machine's data, personal data included.

Starting the folder

Two scripts start and stop everything. The ports are chosen at every start: on a clean machine the gateway takes 8080 and the services the ports from 9001.

  1. In PowerShell, in the folder, run .\start.ps1: it starts the services and Caddy in the background, opens in the firewall the ports the gateway does not cover and waits until sign-in answers.
  2. .\start.ps1 --list prints what it would start and on which ports, without starting anything.
  3. Open https://localhost:8080/ on the machine itself, or its address on port 8080 from the local network.
  4. The certificate is the machine's own: the browser warns once — accept the warning, or run the start as administrator so that Caddy installs its certificate authority.
  5. .\stop.ps1 stops everything, on the ports the start really took.

Tip If another program holds a port, only that role moves to the next free port, and the start says so on screen.

First sign-in and operation

The first administrator, upgrades, backups, the coming-soon switch and the security policy.

The first administrator

Registration is open only to whoever holds an invite code, and the codes are generated in the console — which nobody can open yet. The first code is generated on the machine itself.

  1. Image: on the server, from the root of the repository, docker compose -f deploy/prod-allinone/docker-compose.yml exec -e MERYDION_DATA_ROOT=/var/lib/merydion/data merydion merydion-auth invite-code.
  2. Folder: in PowerShell, in the folder, $env:MERYDION_DATA_ROOT = (Resolve-Path .\data).Path; .\bin\merydion-auth.exe invite-code.
  3. The command prints a code in the form XXXX-XXXX-XXXX; invite-code 5 prints five.
  4. On the portal, click Sign in, then Create account: enter the code and register with the email written in ADMINISTRATORS, then confirm it with the code the verification email brings.
  5. Sign in: Diagnostics, at the foot of every page, opens the console, where the other invite codes are generated.

Tip If the verification email does not arrive, check the password of the mailbox: the sign-in service says at start-up when it is missing.

Upgrading

An upgrade replaces the image and keeps the data: they live in the container's volume, which belongs to the project and not to the image.

  1. On the development machine, with the updated repository, build the new image: .\rebuild_container_release.ps1 -NoSeedData.
  2. Copy it to the server, check it and load it as the first time: sha256sum -c merydion-allinone.tar.sha256 && docker load -i merydion-allinone.tar.
  3. Start with the same command as the first time: docker compose --env-file deploy/prod-allinone/.env -f deploy/prod-allinone/docker-compose.yml up -d notices the new image and recreates the container, with an interruption of a few seconds.
  4. Open the console on the Upgrade tab: where a row says Update available, click Run upgrade — until then the data functions of that service stay off.

Tip Before every upgrade, check in the diagnostics that the database copies are fine (the “Database copies” card) and copy the files: the database upgrade works on a copy and keeps the original until the copy is verified, but the copies are your own way back.

Copies and restore

Every service keeps a continuous copy of the databases it holds — accounts, document indexes, mail, chats — at most about a second behind, and restores it to any instant of the last seven days. The files themselves — documents, attachments, previews — are written once and never change: they are copied apart, or kept in an S3 bucket.

  1. Move the database copies off the machine: register a destination of the class backups on an S3 bucket or on another disk, and activate it.
  2. Image: copy the files, without the databases, while it runs: docker run --rm -v merydion-prod-allinone_merydion_state:/d:ro -v "$PWD/files":/b alpine sh -c 'tar czf /b/files-$(date +%F).tgz -C /d --exclude="*.db" --exclude="*.db-*" --exclude=./backups --exclude=./restores .' writes a dated archive into the files folder.
  3. Folder: stop it with .\stop.ps1, copy the data folder whole, then start it again.
  4. If an administrator has registered another destination for the files, copy its folder in the same round: the files born after it was activated are only there.
  5. Keep the copies away from the machine they protect.

Tip To bring one database or the whole installation back to an instant, stop the installation and run merydion-storage copies restore (the runbook's “Copies and restore” procedure): it writes the restored databases into a new folder, which then takes the place of the old one.

Putting the site in coming soon

Coming soon shows every visitor only a preview page while the installation is being prepared: the portal, the apps, Palatys and the console wait behind it, for administrators too.

  1. Sign in as an administrator and open https://merydion.example.com/coming-soon.html?enabled=true: the page confirms and the site is in coming soon.
  2. To bring the site back, open https://merydion.example.com/coming-soon.html?enabled=false: after the confirmation the page takes you to the home page.
  3. If you are not signed in, the page first asks you to sign in; an account that is not an administrator is told so, and nothing changes.
  4. The state is the file site/coming-soon in the data folder: removing it brings the site back even without the page.

Tip The coming-soon page exists in English and Italian; a visitor with another language gets the English one.

Turning on the visit statistics

The site can count its visits with Google Analytics 4, asking every visitor for consent first: until a visitor accepts, nothing from Google loads. The statistics stay off until the installation names its measurement ID, and the administration console never has them.

  1. In Google Analytics, create a property and a web data stream for the address of the site, and copy its measurement ID (it starts with G-).
  2. Image: in the .env file next to docker-compose.yml add MERYDION_GOOGLE_ANALYTICS_ID=G-XXXXXXXXXX and recreate the container with docker compose up -d. Folder: export the same variable in the session before start.ps1.
  3. Open the site in a private window: the notice on visit statistics appears at the bottom left, and “Cookie preferences” appears at the bottom of every page.
  4. To turn the statistics off, empty the variable and recreate the container: the notice disappears, and the browsers of those who had accepted stop loading Google Analytics.

Tip The privacy policy and the cookie policy already describe the statistics, in every language, for the installation that turns them on. In the property, set the data retention you want — Google keeps the data of a visit for at most 14 months — and leave Google signals off: the site turns them off on its side too.

Offering the site to search engines

Every installation tells search engines not to index it until it turns the indexing on: a copy of the site that is not the official one — a test installation, the installation of an organization — never competes with it in the results. The addresses that the pages, the previews and the sitemaps declare name the official site, https://merydion.eu, and the account pages, the console and the page of a missing address never enter an index.

  1. Only on the installation that serves the official site. Image: in the .env file next to docker-compose.yml add MERYDION_SITE_INDEXING=1 and recreate the container with docker compose up -d. Folder: export the same variable in the session before start.ps1.
  2. Check it: curl -I https://merydion.eu/ no longer shows the X-Robots-Tag: noindex header, and https://merydion.eu/robots.txt points at https://merydion.eu/sitemap.xml.
  3. In Google Search Console and in Bing Webmaster Tools, verify the domain with a DNS record and submit https://merydion.eu/sitemap.xml.
  4. To take the site off search engines again, empty the variable and recreate the container: every response says noindex again, and the engines drop the pages at their next visit.

Tip A portal generated for another address sets MERYDION_SITE_ORIGIN (for example https://www.example.com) when it is generated: the canonical addresses, the language alternates, the previews and the sitemaps then name that address. The page of a missing address answers in the language of its folder, with the status 404.

The portal's Content-Security-Policy

The portal's pages run under a strict Content-Security-Policy that the gateway sends: a page may use only its own files, requests to its own origin, images also from data: and blob:, and no frame of another site. It is what keeps a stray piece of markup from running code. The one exception is the visit statistics: the pages that may count visits also admit Google's gtag.js, on its path only, and the collection of Google Analytics, which load only after a visitor accepts.

  1. A customized portal with scripts or styles written inside its pages does not work: scripts and styles go in files of their own.
  2. window.MERYDION_AUTH_BASE, window.MERYDION_API_BASE and window.MERYDION_DIAGNOSTICS_BASE can move a family of requests only under another path of the same origin; an address on another origin is ignored, with an error in the browser console.
  3. The pages of the installation console carry the policy without the exception of the statistics and, in addition, cannot be shown inside a frame.
  4. The policy lives in apps/portal-csp.mjs and in the three Caddyfiles, and a test keeps them equal: change it in all four places together.

Tip The sign-in form of the identity service and the refusal page of the console arrive with a policy of their own, stricter still.

For installation administrators

Installation console

The console is the tool of whoever runs a Merydion installation. It shows whether each service works, how the nodes are doing and whether the databases are up to date, and it manages accounts, invite codes, organizations and sharing governance, beside the feedback, support requests and messages people send.

This guide goes through its sections one by one. Governing a single organization from the inside is described in the Organization administration guide.

Getting started

Who may open the console, what its overview says and how its sections work.

Open the console

The console opens only for the administrators of the installation: the accounts listed, one per line, in its ADMINISTRATORS file. The file is read again at every check, so adding or removing a line takes effect at once.

  1. Sign in with an administrator account.
  2. Open the account menu at the top right and choose Administration console: only the administrators of the installation see it. You can also open diagnostics.html.
  3. Anyone else receives, in place of the console, a page in the language of the page they asked for that says why. Signed out, Sign in brings you back to the console once you are in; signed in with another account, choose Back to your workspace or Sign in with another account.

Tip How to name the first administrator is explained in the Installation guide.

Read the overview

The console opens on Overview, which says what in the installation needs attention: services not answering, databases to upgrade, support requests received and users awaiting verification.

  1. Read the four figures: a figure on a tinted card needs attention, one on a plain card does not; a dash means it is still being read.
  2. Under Databases to upgrade, Services not checked counts the services whose databases could not be checked.
  3. Click a figure to open the section where it is handled; Back brings you to the overview.
  4. Refresh now reads every figure again.

Tip The figures of the services and of the databases are those of Status and Database upgrade: they are read once for both sections, and refresh while you look at them.

Move between the sections

The console groups its sections by trade — Health (Overview, Status), Topology (Overview, Nodes, Cells, Routing, Storage, Events), People and organizations (Users, Organizations, Invite codes, Sharing), Operations (Database upgrade) and Voice of the users (Support, Feedback, Messages) — and shows one at a time.

  1. Click a section in the column on the left to open it.
  2. With the focus on a section, the up and down arrow keys open the next or the previous one, across the groups; Home and End open the first and the last.
  3. The address follows the section you open — for example diagnostics.html#diag-scope-status — so you can bookmark it or send it, and reloading the page keeps it.
  4. On a narrow screen the column becomes a list at the top of the page: choose the section there.

Tip A section reads what it shows the first time you open it, and the console asks nothing before it has checked that your account may administer. Every section has its own Refresh now; one that cannot read says what and why, and Try again reads it again.

Find your way in the console

The console is an app of the suite: the title bar at the top, the column of the sections at the left, the status bar at the bottom. The title bar names the installation and says its state; the status bar says whether the services answer, when the last announcement arrived and over which channel the console talks to the gateway.

  1. Read the name of the installation in the title bar, beside the quadrant: under it, a dot and the state of its nodes — all online, or how many are in each state — and the number of the current alerts.
  2. The pill beside the bell says the version of Merydion the console is built from.
  3. In the status bar, read whether all the services answer or which one does not, and how long ago the last announcement arrived.
  4. At the right of the status bar, «TLS 1.3» is the channel the gateway read for the console's requests; «Without TLS» says that the connection is not encrypted.
  5. The sun or the moon beside the language switches between the light and the dark theme; the language opens the list of the Portal's languages.

Tip On the page of a service or of a node the column of the sections stays: the section the page comes from is marked, and a click on another section opens it in the console.

Read the current alerts

The bell in the title bar counts the alerts of the installation's topology — a node or a service that does not answer, a role that no node online holds, services that run different versions — and lists them.

  1. Look at the number on the bell: it is the number of the current alerts; no number, no alert.
  2. Click the bell to open the list: each alert is a sentence that names the node, the service or the role.
  3. Follow «Open the topology's overview» at the foot of the list to see the nodes and the services.
  4. Esc, or a click elsewhere, closes the list.

Tip The alerts are those of now: an alert goes away by itself when what caused it is solved. The console reads them again every 30 seconds while its tab is in view.

Name the installation

The name of the installation appears in the title bar of the console. The topology of the installation keeps it, with who set it and when; without a name, the console shows the name of the host you reached.

  1. Click the wheel at the right of the title bar: Installation settings opens.
  2. Type the name, up to 64 characters — for example Production.
  3. Choose Save: the title bar shows the new name at once.
  4. To remove the name, empty the field and save.

Tip Spaces at the start and at the end are removed. Every change is recorded among the events of the topology, with the account that made it.

Services and databases

The state of the services, their detail and logs, the topology with its nodes, cells, routing, storage and events, and the database upgrade.

Check the state of the services

Status lists the eleven services of the installation, each with its icon, name, description and health address.

  1. Read the light of each row: Operational when the service answers its health check within 6 seconds, Unreachable when it does not.
  2. The checks repeat by themselves every 30 seconds while Status or the overview is in view, and rest while the browser tab is hidden; Refresh now repeats them at once and updates Last checked.
  3. Click the state of a service to open its health detail, or its logs icon to read its logs.
  4. Served runtimes lists what the browser runs from files of the front end, such as the video effects, with Served or Not served.

Tip When a service is Unreachable, its logs often say why.

Read the health detail of a service

Each service has a page with its health detail: an overall state, and a card for each of its subsystems.

  1. Open it by clicking the state of the service in Status.
  2. The pill at the top says Operational, Degraded or Down.
  3. Each card shows a subsystem with its light, its name, a summary and its figures.
  4. The page does not refresh by itself: click Refresh now. The path at the top of the page leads back to Status and to the console.

Tip Degraded means the service works but one of its parts does not: the card of that subsystem says which.

Read the logs of a service

Each service has a page with its logs, in a console that looks like a terminal.

  1. Open it with the logs icon of the service in Status.
  2. Choose the day in Day: the list shows the days that have logs, most recent first.
  3. The console shows the last lines of that day, coloured by level — ERROR, WARN, INFO, DEBUG, TRACE — and scrolls to the last one.
  4. Older lines were omitted. means the server cut the oldest lines; No log entries for this day. means the day has no file; File logging is not enabled for this service. means the service does not write logs to file.

Tip Refresh now reads the chosen day again.

Read the topology of the installation

Under Topology, the console shows the installation as the topology registry and the announcements of the services describe it. Its Overview says in six figures how it stands, which roles each node holds and which services announced themselves.

  1. Read the six figures: the nodes, the Rust services announced, the SQLite cells, the destinations of the bytes, the last round of the copies and the alerts. The nodes and the alerts are in the console's colour when all is well, in ochre or in red when something needs attention; a dash means the figure is not there yet.
  2. Last hour and Today, beside the title, show for each figure that has a series the worst value of the period and the time it was reached; the figures without a series stay those of now and say so. Now goes back to the present state.
  3. Roles × nodes has a row for each role and a column for each node: a filled square is a role switched on on that node. The name of a node opens its page; Show more adds the columns of the next nodes, and the table scrolls inside its card.
  4. Under the table three checks — no role without nodes, no mixed versions, all answer — turn into the alert in words when they fail.
  5. Announced services lists every service with the name of its binary, how many instances announced themselves, the version and a dot, green when they all answer; the first row is the ingress, caddy.
  6. The section reads again by itself every 30 seconds while the console is open, and rests while the browser tab is hidden; Refresh now reads it at once.

Tip In front of an alert, open the page of the node it names: its roles and services say which service does not answer. Different versions usually mean an upgrade still under way on some node.

Watch the nodes

Nodes lists the nodes the topology registry knows, ordered by role with the new ones at the top: for each one its address, its roles, its state, the CPU and memory it announced, the cells it holds and the age of its last announcement. Each row opens the page of the node, and a node that joins the installation appears by itself.

  1. Choose a state above the list — All, Online, New, Draining, Offline, and Unreachable when there is at least one —: beside each, the number of nodes. Filter the nodes, beside the title, searches the name and the identity.
  2. A new node stands at the top, with the ochre dot: it announced itself and has no work, and its row offers Bring online and Reject.
  3. The CPU beyond 70% is in ochre, and so are the cells beyond 80% of the declared capacity; a dash among the cells means the node does not hold the data role. When the installation has more nodes than the list shows, Show more adds the next ones.
  4. Weights and capacities, beside the title, opens the weights of the roles and the capacities of the node you choose: a weight goes from 1 to 1000, and 100 is the role's normal node; an empty capacity field leaves it undeclared. Save takes effect only if nobody changed the node in the meantime.
  5. The page of a node has the seven roles on the left: the one switched on carries the bar, and the services of the role are tokens lit when they run there and answer; a token opens, further down, the configuration and the resources of that service. On the right, the Effective configuration, grouped by origin: the seed of the first start, what the topology decides, what the configuration says, the state of the node and the secrets, redacted.
  6. Configure changes the name, roles, weights and capacities of the node; beside it stand the actions its state allows, each asked first.
  7. Resources shows the host of the node: in Now the CPU, memory, network, disk, monthly traffic and processes, refreshed every 5 seconds by the identity service of the node; in Last hour and Today the CPU and the memory minute by minute, as the services announced them.

Tip A secret never leaves the process that holds it: the page shows only its name, where it comes from and the redacted tag. The configuration changes only when a service restarts.

Bring nodes online, drain and retire them

Every state of a node offers only the actions the topology registry admits from it: on the row of a new node in Nodes, and in the head of the page of every node, beside Configure. Each action asks first, naming the node and saying what will really happen; what nothing undoes — Reject, Retire and Declare failed — you confirm by typing the identity of the node.

  1. New: Bring online gives the node work — new cells, the cells the topology moves, rooms, render jobs, mounts —, and the topology accepts it only once it hears the node: at least one of its services announces itself or, for a node with only the Ingress role, which has no service to announce, its ingress answers. Until then the button stays off and says why. Reject is the retirement of the node: it leaves every view, its identity and its epoch are never used again, and a process of it that tries to join again stays out.
  2. Online: Drain stops the node receiving work at once and moves its cells to the least loaded nodes, at most 4 at a time; a bucket it mounts is mounted on another storage node, while a folder on its disk stays and you move it from Storage. When nothing is left on it and its requests in flight have finished, within 30 seconds, it goes offline by itself. An unreachable node is not drained.
  3. Draining: the card Drain in progress follows the drain every 5 seconds while it is in view — who started it and when, the cells still on the node out of those it had, with their kinds, the open moves by phase, and what holds it back, in words: cells whose move was refused or cancelled, kinds no node online can receive, a folder on its disk, services that have not closed the census of its cells, a node that has gone silent —, or Nothing holds it back. Interrupt the drain brings the node back online: the moves of the drain not yet assigned are cancelled and their cells stay on it.
  4. Unreachable, or draining and silent: Declare failed, never offered for a node that holds the Control role. The confirmation first says the failover policy in force, read at that moment. The topology accepts the declaration only once the node's lease has been expired for more than 10 seconds, and refuses it before then: with automatic failover it declares the node failed by itself at that moment, so confirming never does it sooner; with manual failover your confirmation is the only way its cells restart elsewhere. The policy is a key of Routing.
  5. Failed: the card Recovery of the failed node follows its cells as they restart on other nodes from their last copied instant; the mounts it held are lost, and a destination nobody serves since then is named until you mount it on another storage node. Bring online stays off, saying why, until the topology hears it again: then it stops the recovery, and what has already restarted elsewhere stays there.
  6. Offline: Bring online gives the node work again; Retire removes it for good, as Reject does for a new node, and the topology refuses while the node still holds cells, moves, mounts or leases.
  7. A success is said in a notice and the page reads the node again: its head says where the node went. A refusal is said under the head, in the words of its reason.

Tip The topology never declares failed its own node or one that holds the Control role, and it refuses to drain the last node online with the Control, Identity or Data role, or the last one that writes an active destination: the refusal names the role or the destination.

Read the cells

Cells shows where the data of the installation lives: every cell is a SQLite database with one owner node. The line under the title counts the cells, their kinds and the data nodes; the chart, the kinds and the tables say how the cells are spread and how large they are.

  1. Choose what the chart shows beside the title: By node draws a column for each data node and the line of the capacity in cells each node declares — a node past 80% of its capacity is in ochre, a new node, still without work, in the colour of the console —; By kind draws a row for each kind of cell, with the nodes that hold it; By organization the organizations with the most cells, with their nodes and, for a divided organization, the services in which its entities have cells of their own.
  2. Cells per kind has a tile for each kind, with its count and its size. A size is the bytes of the cells' databases, what a move transfers: the services measure them only while someone looks at the section, so on a first visit the sizes are arriving and show with the next announcements; the line under the kinds then says from the census of how many nodes they come and how old it is. A size measured on part of the cells says how many were measured.
  3. Largest cells lists the cells with the largest databases and Most recently written those written last, each with the node that holds it. Nobody counts the writes of a cell: the most active cells are shown as the most recently written ones.
  4. Cells and sizes per node is the chart by node in words: for each node its state, its cells, its capacity with the share used or not declared, the size of its cells, the age of its census and the cells set aside. A node that comes back after a failover sets aside a cell whose copies lacked some of its writes: it waits for an operator, and the table says so.
  5. The section reads again by itself while it is in view — every 10 seconds while something arrives or moves, every 30 seconds otherwise —; Refresh now reads at once.
  6. On a narrow screen the cards stand one under the other, and the chart by node scrolls sideways inside its card; for a screen reader, the figures of the chart are those of the table Cells and sizes per node.

Tip The counts come from the topology registry and are exact; the sizes come from the last census of the services, and nobody measures the disks while nobody looks.

Rebalance the cells

Rebalancing plan shows what the rebalancer would move to even out the data nodes: only the next batch, because nobody measures the load of a single cell and the whole rebalancing cannot be foreseen. Beside it, the switch of the automatic rebalancer and the card Why, followed by the name of a node, which says where new cells go and why.

  1. Read the badge of the plan: dry run is the next batch as the rebalancer computes it now; authorized, once an operator has applied it; in progress, with how many moves of the batch have arrived; applied, once they have. The batch is said by its cells, its bytes, the nodes it leaves and those it reaches, then a row for each kind and route.
  2. Read under the plan what the rebalancer is doing and why — balanced, waiting for the gap to last, off, settling after the previous batch, out of budget —, with the gap between the data nodes and the threshold, and the budget of the last hour: moves, bytes and moves at once.
  3. Apply the plan, offered while a rebalancing is due, authorizes the rebalancer: at its next round, within seconds, it asks for the batch as it computes it then, which may differ from the one shown, and always within its budget. It holds even with the automatic rebalancer off, and it does not wait for the minimum duration. The badge then follows the batch, and the line under the plan says who authorized it and what the rebalancer did.
  4. When the rebalancer would no longer ask for a batch — fewer than two data nodes with a score, a drain under way, a gap within the threshold, the previous batch settling, the budget spent, sizes still missing, no measured cell that can move —, the topology refuses and the card says why, in words.
  5. Automatic rebalancer: Turn off keeps the plan computed and shown here but moves nothing by itself — a plan can still be applied, and drains and recoveries move their cells as always —; Turn on lets the rebalancer ask for batches by itself when the gap stays over the threshold for the minimum duration. Both ask first.
  6. Read the card Why: the load score of the node the new cells of the data services go to — the free share, higher is freer — with its reason, the measures that make it, each with its share in use and its weight, the freest candidates and the hysteresis, which keeps new work on the node chosen before while it stays close to the best.

Tip Drains and operators' moves do not count in the budget of the rebalancer. Threshold, minimum duration, budget and when a cell counts as cold are keys of the policy, in Routing.

Move a cell and follow the moves

Moves in progress lists the open moves of the cells, whoever asked for them — the rebalancer, a drain, a recovery or an operator —, and from Cells you can move a cell yourself to the data node you choose.

  1. Read each move: the cell by its kind and key, the node it leaves and the one it reaches, its phase — In transfer, Copied, Assigned — with a bar, who asked for it and when; a step that keeps failing is said under the phase, with how many times.
  2. Stop interrupts a move in transfer or copied that an operator or the rebalancer asked for: the cell stays active on its node at the same epoch, and what the destination restored so far is discarded; a cell whose move of the rebalancer you stop is not chosen by it again for a day. A move of a drain or of a recovery has no Stop and says whose it is: a drain is interrupted from the node's page, a recovery by bringing the node online again. An assigned move can no longer be stopped.
  3. Move… on a row of Largest cells or Most recently written opens the dialog with the cell and the node that holds it: choose the destination among the other data nodes online and press Move.
  4. Move a cell…, beside the title, asks for the kind, the key as the registry writes it — an organization, a user, or organization/fingerprint for an entity — and the destination node, and reads which node holds the cell before asking. The search of the console finds Move a cell… too, and opens its dialog.
  5. The confirmation names the cell, the node it leaves and the one it reaches: its writes wait while the source hands it over and the destination restores it, the source removes its files after the grace, and a move of an operator does not count in the budget of the rebalancer.
  6. A refusal is said in the dialog, in words: a cell already moving or already on that node, a destination that takes no new cells or lacks the role, too many open moves of that service on the node, a cell without a place of its own — an entity of an organization that is not divided moves with its organization.

Tip While a cell moves its writes wait and are asked to retry, and its epoch refuses a late one: nothing is lost.

See where new work goes

Routing says where new work goes and why: the policy of the topology, the score of every node, the node chosen for each assignment and the last choices with their motivation. The line under the title counts the nodes and the assignments, and recalls that a score is the free share: higher is freer.

  1. Scores lists every node in every role that receives work — Data, Compute, Storage — with its state, the weight of the role when it is not 100, its score and its measures, each with its share in use and its share of the weights of the role; a measure past 70% for the CPU, or 80% for the others, is in ochre. A node that has not announced a load yet says so; Load more nodes reads the next ones.
  2. Chosen nodes says where new work goes now — the new cells of each data service, the new rooms of the calls, the render jobs, the reads and the writes of each mounted destination —, each with its node, its reason and since when it is chosen. An assignment no node online can receive is named under the list.
  3. Open Why under a row to read the motivation of the choice: the score with its reason — the freest, the only candidate, the node that asks or the one chosen before within the hysteresis —, the measures with their share in use and their weight, the freest candidates and the hysteresis. A motivation left open stays open when the section reads again.
  4. Recent choices lists the last choices, newest first: the time, the assignment, the chosen node with its reason, and the cell and the node that asked when there are any. Assignment narrows them to one assignment, and Load more reads older ones. The motivation of a past choice shows the measures of that moment, not the weights it was made with, which the registry does not keep.
  5. The section reads again every 30 seconds while it is in view; Refresh now reads at once.

Tip How many choices the registry keeps is a key of the policy, Choices kept: Recent choices shows only those kept.

Change the policy of the topology

Policy, in Routing, holds the keys of the topology in three parts — Load, Rebalancing and Nodes —, each with its value, its default when the value differs from it, and who changed it and when. Change… beside a key opens its form.

  1. Load: Weights of the measures, how much each measure counts in the score of a data, compute and storage node — 0 leaves a measure out, and each role keeps at least one above zero; Saturation, where a node counts as full in connections, requests in flight and open cells; Hysteresis, how close to the best score the node that asks, or the one chosen before, keeps new work; Choices kept, how many choices the registry keeps for Recent choices.
  2. Rebalancing: Automatic rebalancer, the same switch as in Cells; Threshold of the gap, the gap between the scores of the data nodes that starts a rebalancing, which ends at half of it; Minimum duration, how long the gap must last before the rebalancer asks for a batch by itself; Budget, the moves and the bytes per hour and the moves at once; Cold after, after how long without writes a cell is cold — the rebalancer moves the cold ones first, and 0 makes every cell cold.
  3. Nodes: Joining nodes, whether a node that joins goes online by itself or stays new until an operator brings it online from Nodes; Failover, whether the topology declares a silent node failed by itself once its lease has been expired for more than 10 seconds, or waits for an operator to do it from the page of the node — until then the cells of the node cannot be reached.
  4. In the form each field says the bounds the topology accepts, and a wrong value is said under its field and not sent. Save asks first, saying what the change really does — where new work goes, what the rebalancer may ask for, who declares a node failed —, then writes the key and reads the section again.
  5. Every change is written in the topology registry with your name: the line under the key says who changed it and when, and Events shows it.

Tip The console checks every value against the bounds of the topology and does not write a value outside them; the topology refuses a value only when it is a topology of another version, whose bounds differ, and the refusal is said in the words of the section.

Trace a request

Request traces, in Routing, lists the collection windows and the traces they collected. A request is traced only inside a window an administrator opens: outside one, no service records anything about it.

  1. Open a window… asks what to collect — a user, by the pseudonymous identity the events show; an app, by the client_id its token is meant for; or a path as the gateway receives it, starting with /api/ —, for how many minutes, at most 30, and why. The reason stays in the events of the topology with your name, and at most four windows are open at once.
  2. The services start collecting at their next announcement, within 5 seconds, and stop when the window ends or when you close it early with Close.
  3. Every trace collected is a row: when, the request, its outcome, the app and the user, the time in the system. The row leads to the page of the trace.
  4. The page of the trace shows the path: a row per stage — the entry through the gateway, the routing to the node that owns the cell, the checks of the token, the cell in SQLite, the bytes of the storage —, each with its node and service, its time and its outcome, then the time in the system. While more stages may still arrive, the page reads the trace again by itself.
  5. Access token shows what the service that verified the token saw: the header and the payload, the first characters of the signature, and every check with its rule. The requests refused with the same token in the window are listed with the reason in words, and the chips under the path are lit only when a probe of the identity service confirms them.
  6. Copy the trace copies the page as text, without the signature.

Tip The token is never kept: a trace holds its decoded header and payload, the outcome of each check and the first 12 characters of the signature. Traces live only in the memory of the topology, at most an hour after their window ended.

Read the storage

Storage shows where the bytes of the installation live: a column for each class — user files, attachments, previews and database copies — with its destinations, how full each one is against its thresholds, and the storage nodes that mount them and how many bytes they serve.

  1. Read each column: the outlined destination is the active one of its class, the one that receives the new writes; under each destination you see its kind (disk or S3), its folder or bucket, the meter against its space threshold and the nodes that mount it.
  2. The tick on the meter marks where the rotation prepares the next destination; past it the meter turns ochre, and at the threshold the next destination ready in the class becomes the active one by itself.
  3. Read Mounts: a row for each storage node, with the destinations it mounts and the state of each mount, the epoch of its last change and the bytes it serves per second.
  4. Read the storage events at the foot of the page: who registered, activated, mounted or emptied what, newest first; Show more reads the older ones.
  5. The page reads again every 30 seconds while it is in view; Refresh now reads it at once.

Tip A destination without a threshold shows only the bytes counted since it was registered: the counters are indicative, and the rotation decides only on a count the storage node makes by listing the destination.

Govern the destinations

From Storage you add a destination — a folder on the disk of a storage node or a bucket of a service compatible with S3 — and you activate, seal, empty, retire it and change its thresholds; Rotation sets when the next destination must be ready and when it becomes the active one.

  1. Press Add destination: give it a name and the class it will serve, choose disk with an absolute folder or S3 with endpoint, region, bucket and the credential reference — the name the storage node resolves from its own secrets, never the credential —, the storage node that mounts it and, if you want, its thresholds. The node verifies it before it serves; until then it is new.
  2. Open the menu of a destination with its button: it offers only what its state allows. Activate for a class makes it the active one of that class; Seal hands every class it serves to its next destination, the one the rotation would choose, and the confirmation names it.
  3. Thresholds… sets the space, in GB or TB, and the objects; an empty field means no threshold. The rotation weighs new thresholds at its next round.
  4. Empty moves the bytes of a sealed destination into the active one of their class, in the background; Suspend the emptying stops it. Retire removes a ready destination that has never received bytes: confirm it by typing its name.
  5. Press Rotation to set the preparation and the rotation, in percent of the threshold, and whether the destination the rotation seals empties itself into the new active one.

Tip Every action asks first, naming the destination and saying what will happen; when the topology refuses, the reason appears beside the destination, in words.

Mount, unmount and empty

A destination serves its bytes from the storage nodes that mount it: Mounts shows a row for each storage node, and from the menu of a destination you mount it on a node, unmount it from one or move a mount to another node.

  1. Read Mounts: each storage node with the destinations it mounts, the state of each mount — a green dot serves, an ochre one is being verified, a ring is being unmounted —, the epoch of its last change and the bytes it serves per second.
  2. Choose Mount on… in the menu, or the button on a destination nobody serves: pick a storage node, new or online, and the mode. The node verifies the folder or the bucket before it serves.
  3. Choose Unmount from a node: the node stops admitting new operations, lets those in flight finish for up to 60 seconds and cancels the rest. The last node that serves an active destination for writing cannot be unmounted until another destination is active: the confirmation says so.
  4. Choose Move from a node… to move a mount to another storage node, new or online: the first one drains, the second one verifies.
  5. While a destination empties, its tile shows the bar toward the active destination of its class with the share of references moved, then the grace, the removal of the old copies and the verification by count.

Tip Unmounting never loses a byte: reads go to another node that mounts the destination, and without one its files answer «unavailable» until it is mounted again — never «not found».

Reading the map of the installation

Map shows the whole installation at a glance: the nodes in three bands by role, every data node a tile with the mosaic of its cells on its capacity, the continuous copies of the databases with the tape of their last rounds, and the last events that changed the installation, each with its author.

  1. Read the bands: Entry · control · identity has a tile per node with its roles and the services that answer on it; Data has a tile per data node — its name, its state, the mosaic of forty places (its cells on the capacity declared in Weights and capacities, or on the fullest data node when none is declared), how many cells it holds and its CPU —; Compute · storage · TURN has a chip per node. Every tile and chip opens the page of its node.
  2. Follow a node that falls: an ochre outline says its lease is not renewed; a red outline with «isolated · N» says the lease has expired and the node has isolated itself; «offline · N» says the topology declared it failed and is recovering its cells from the copies — the places it lost are outlined in red —, and the nodes that receive them have the outline in the pigment, the received places darker, for an hour after the recovery ends.
  3. Choose what the colour of the tiles says with Roles · Load · Cells: the states, the CPU (ochre beyond 70%), or the cells on the capacity (ochre beyond 80%).
  4. Continuous copies says how often every process copies its databases, the tape of the last thirty rounds of the installation — every bar the longest round of its second, the newest in the pigment, one longer than the cadence in ochre —, where the copies go and how far back a database can be restored.
  5. Events shows the last events that changed the map, a run of cells recovered or moved in one line, with their author: a person with their login, a job as «topology», a node with its name. All the events opens the Events section.
  6. The map reads again every 5 seconds while it is in view; Refresh now reads at once. An installation with more than four rows of data nodes scrolls inside the card.

Tip When a node falls, keep the map open: you see the lease expire, the node isolate itself, its cells fenced and recovered on the least loaded nodes — and in Events who did what, minute by minute.

Read the events of the topology

Events is the registry of the topology, newest first: what happened to the installation — its nodes, cells, leases, storage and policy —, each event with its author, a person or a job of the topology. The line under the title says how many events the registry keeps.

  1. Choose a type above the list — All, Nodes, Cells, Leases, Storage, Policy, Topology — and a node in Node: the list shows the events of that family that name that node, as their subject or among the nodes before and after them. The filters stay in the address of the page, so a link keeps them.
  2. Read each row: the time, with the date when it is not today; the dot and the word of the family; what happened, in words; its subject — a node is a link to its page, a cell is its kind and its key —; and underneath its author: an administrator by the account, a job of the topology by what it does, such as the presence, the leases or the rebalancer.
  3. Open Before and after on a row to read what the event changed, as the registry wrote it; nothing means there was no value.
  4. Load more reads the older events. The topology reads its registry a stretch at a time: when a stretch has no event for your filters the console goes on by itself a few times, then says so and offers Keep looking — it says that no event matches only when nothing older is left.
  5. New events arrive at the top every 30 seconds while the section is in view; Refresh now reads at once.

Tip A change of the policy, a drain, a node declared failed or a plan applied carries the name of whoever did it: Events is where to find who changed what, and when.

Upgrade the databases

Upgrade checks, for each service, whether its databases are at the version the server expects. Until they are, the data features of that service stay off to protect the data.

  1. Read each row: Total and Outdated, with Up to date, Update available, Unreachable — the service did not answer — or Check failed, with the reason under the row.
  2. Run upgrade appears only when something is out of date. The confirmation names the service, how many databases go to which version and that it cannot be undone: type the identifier of the service it shows — such as auth — and confirm; the server upgrades in the background while the row says Upgrading…
  3. The row checks again every 2 seconds until the server has finished, and a notice says how it ended; Upgrade failed says it did not.
  4. The database icon opens the detail page, with each database, its file path, its current and target version and its status — Newer than server and Not created yet included; the upgrade can be run from there too.

Tip You can close the page during an upgrade: when you open it again, it goes back to watching.

Accounts and organizations

Accounts, invite codes, organizations and sharing governance.

Manage accounts

Account lists the registered users: name, email, status — Active, Suspended, Pending verification or Deactivated — and date of registration.

  1. Access log opens the sign-in history of a user: time, event, outcome, IP address and client.
  2. Reset password opens a field where you type a new password and click Apply: the sessions of the user are closed.
  3. Suspend asks first, naming the user: they can no longer sign in, their sessions close and an app they already have open stops within minutes; Reactivate lets them in again, without a confirmation.
  4. Delete asks you to type the user's email: it removes for good the account, its profile, its memberships of organizations and its sessions; the files, mail and conversations they have in the apps are not deleted.
  5. Create user adds an account with email and password, active at once.

Tip A password set from here closes every session of the user: give them the new one through a safe channel.

Generate invite codes

Merydion is invitation-only: each invite code opens a single registration, and whoever uses it burns it.

  1. Click Generate invite code: the new code appears beside the button, ready to give to the person you are inviting.
  2. The list shows the codes, newest first: Available or Burned, the creation date and, once used, Used by with the account it opened.
  3. Click a code to select it whole, then copy it.

Tip Give each code to one person only: once used, it cannot open a second registration.

Manage organizations

Tenant lists every organization of the installation, with its type, status, members and administrators; an organization with no administrators is highlighted.

  1. Under Create organization, type the Organization name and click Create tenant.
  2. To rename an organization, change its name in the row and click Rename.
  3. Members opens the panel of an organization: change a member's role, Remove a member after a confirmation that names the person and the organization — the last administrator stays, and the row says so —, and invite people as on the organization's own page.
  4. Direct association adds a user at once, without an invitation, with the role you choose: it is reserved for installation administrators.

Tip To give an organization its first administrator, associate a person with the Admin role, or invite them as an administrator.

Govern sharing

Governance sets the sharing policy and the sensitivity labels of any organization, and shows the audit log of its sharing decisions.

  1. Type the identifier of the organization in Tenant: its policy, labels and log load.
  2. Under Sharing policy, set Internal sharing, Public links, File requests and Real-time co-editing, then click Save policy, which lights up only when something has changed.
  3. Under Sensitivity labels, add a label with its name, colour and Blocks sharing, or delete one: the confirmation names it and, for a label that blocks sharing, reminds you that the documents carrying it can be shared publicly again.
  4. Audit log lists the recent decisions with time, subject, action, resource, decision and reason, the action named in words, such as Public link or Saving a co-editing session; Entries chooses how many, from 1 to 500.

Tip The administrators of an organization set the same rules from their own page; here you can do it for any organization.

Feedback, requests and messages

What people send: ratings, support requests and messages from the site.

Read the feedback

Feedback gathers the ratings and comments people send with Help → Feedback in the apps, newest first.

  1. Read the summary: the average rating, the number of feedback received and a bar for each rating from 5 to 1.
  2. Click a bar to see only that rating, and again to remove the filter; Only with a comment keeps the feedback that has one, and All removes the filters.
  3. App chooses the app whose feedback you read.
  4. Each card shows the rating, the reference, the comment, who sent it, the app with its version and the platform.

Tip When there is more feedback than the list shows, a line says so: the summary always counts it all.

Handle support requests

Support requests is the queue of the requests people open with Help → Support in the apps, newest first.

  1. Each card shows the impact, the category, the reference, the subject and the description, who wrote it, the app with its version, the platform, the language and the date.
  2. Show full description opens a long description, and Show less closes it.
  3. The search and the App, Impact and Category filters narrow the queue; Showing says how many requests are shown out of the total.
  4. Reply by email opens your email program towards the author, with the reference and the subject already in the subject line.

Tip Answer by email and keep the reference in the subject, so the conversation stays together.

Read the messages from the site

Messages collects what visitors write with the contact form of the site, newest first. The form sends no email to anyone: the console is the only place where the messages arrive.

  1. The search narrows the messages by name, email, subject or text.
  2. Show full message opens a long message.
  3. Reply by email opens your email program towards the sender, with Re: and the reference in the subject.
  4. Delete, when the sender asks for it, removes a message for good: confirm with Delete for good, or step back with Cancel or Esc.

Tip Messages are deleted automatically after 12 months.

For organization administrators

Organization administration

Organization administration is the page where the owners and administrators of an organization govern it. It opens on the organization you administer, and its sections follow one another on the left: overview, people, storage, services, sharing and two logs.

This guide walks through each section. Running the whole installation is a different job, described in the Installation console guide.

Getting started

Open the page and read the overview of your organization.

Open organization administration

The page is for the owners and administrators of an organization. Your personal space is not an organization to administer, so it never appears here.

  1. Open the account menu at the top right, or the quick actions of your workspace, and choose Administer organization: it appears only if you administer an organization.
  2. After accepting an invitation as an administrator, Administer the organization on the invitation page leads here too.
  3. If you administer more than one organization, choose the one to govern in the Organization selector at the top.
  4. Refresh now reads every section again and writes the time of the last check.

Tip Signed out, the page shows Sign in, which brings you back here; if you administer no organization, it says so, reminds you that administration rights are granted by an owner or administrator of the organization and takes you back to your workspace; if the organization cannot be read, Try again reads it again.

Read the overview

The top of the page names the organization, its type, its status and when it was created. The sections follow one another on the left, one at a time.

  1. Overview shows the figures of the organization: members, administrators, services on out of the total, and the storage in use.
  2. To rename the organization, change Name and click Save: the top of the page and the selector take the new name at once.
  3. Move between the sections by clicking them, or with the arrow keys, Home and End.
  4. A dot on People, and a band in the overview, warn that the organization has no administrators left.
  5. Each section says when it is loading; one that cannot read what it shows says what and why, with Try again, and an empty one offers the next step.

Tip An organization without administrators cannot be governed until someone is given the role: ask the administrator of the installation.

People

The members and their roles, and the invitations to join.

Manage members and roles

People lists who belongs to the organization: name, email and role. For owners and administrators, a line says since when and who designated them.

  1. Choose a role in a person's row — Owner, Admin or Member: the change applies at once, granting or revoking administration.
  2. If the server refuses a change, the previous role comes back: the organization must keep at least one administrator.
  3. Remove asks first, naming the person and the organization: to come back, they will need a new invitation, to accept. If the server refuses, the row says why.
  4. With more than six members, Search a person filters the list by name or email.

Tip To bring someone new in, invite them: see Invite people into the organization.

Invite people into the organization

From People you invite an address as a member or as an administrator. The person joins only by accepting, so nobody is added without their consent, and the answer is the same whether the address has an account or not.

  1. Under Invite a person, type the email, choose the proposed role — Member or Admin — and click Send invitation.
  2. The invitation lasts seven days. Under Invitations you see the pending ones, expired included, and the recently declined and revoked ones, each with who invited and when it expires.
  3. Resend sends the invitation again with a new expiry; Revoke cancels it, and the link in the email stops working.
  4. Pending, Expired, Declined and Revoked say where each invitation stands: a membership is born only when the person accepts.

Tip Adding someone at once, without an invitation, is reserved for the administrator of the installation, from the console.

Storage and services

How much each member may store, and which apps the organization may use.

Set storage quotas

Storage shows, for each member, how much they store out of their quota.

  1. Read each row: the space used out of the quota, with a bar that turns red from 90%.
  2. To change a quota, type the new value in Quota (GB) — a whole number greater than zero — and click Save: Quota updated. confirms it.
  3. A member who has never opened Aerarys has no storage yet: setting a quota creates it.

Tip When the storage of a member cannot be read, the row says so instead of showing zero.

Turn apps on and off

Services has a switch for each of the six apps. The members of the organization cannot sign in to an app that is off, on the web or in the desktop apps, and its tile in their workspace is dimmed.

  1. Read each row: Available or Turned off, with who set it and when — or that it has never been restricted.
  2. Click a switch to turn an app off: the confirmation names the app and the organization and reminds you that the members will no longer be able to open it; until you confirm, the switch stays on.
  3. The notice that follows offers Undo, which turns the app back on: it stays until you close it.
  4. Click the switch again to turn the app back on, without a confirmation.
  5. If the server refuses the change, the switch goes back and the row says the change was not saved.

Tip Turning an app off deletes nothing: documents stay where they are, and are there again as soon as the app is back on.

Sharing

What may leave the organization, the sensitivity labels, and the logs of what happened.

Set the sharing rules

Sharing has four switches that decide what may leave the organization: sharing with a colleague, public links, file requests and real-time co-editing. The page changes only what you touch, and never starts from a value it has not read.

  1. Read the four switches. A switch showing a dash has not been read yet, and stays locked until the current state has loaded.
  2. Click a switch to change that rule only: the others keep their value.
  3. If another administrator changed the rules after you opened the page, your change is not saved: click Reload to see the current state, then decide again.
  4. If the current state cannot be read, the switches stay locked until it is.

Tip Every decision these rules take is recorded in the Sharing log.

Manage sensitivity labels

Sensitivity labels are the classifications the documents of the organization can carry, such as Confidential. A label can block the public sharing of whatever carries it.

  1. Under Sensitivity labels, type the Label name, tick Blocks public sharing if needed, and click Add label.
  2. A name already in use is refused.
  3. To remove a label, click Delete and confirm: the confirmation names it and, for a label that blocks public sharing, reminds you that the documents carrying it can be shared again with a public link or a file request.

Tip A label is never renamed: its name is its identity, and is already written on the documents that carry it.

Read the sharing log

Sharing log lists the last 100 sharing decisions taken for the organization, most recent first.

  1. Read each row: when, the action and the resource, the outcome — Allowed or Denied — and who asked. The action is named in words: Internal share, Public link, File request, Joining real-time co-editing, Saving a co-editing session or Administering a person's storage.
  2. A Denied decision means that a sharing rule or a sensitivity label stopped the sharing.

Tip Refresh now, at the top of the page, reads the log again.

Read the Simposys log

Simposys log records who changed the teams, channels and group chats of the organization: members added or removed, roles, join codes, channel addresses and webhooks, and messages deleted by a moderator.

  1. Read each line: who did what, in which team, channel or group chat, and when — most recent first.
  2. Click Load more to see older events.

Tip If the Simposys log cannot be read at the moment, the section says so: try again with Refresh now.