Configuring a Tahoe-LAFS node¶
- Node Types
- Overall Node Configuration
- Connection Management
- Client Configuration
- Storage Server Configuration
- Frontend Configuration
- Running A Helper
- Running An Introducer
- Other Files in BASEDIR
- Static Server Definitions
- Other files
A Tahoe-LAFS node is configured by writing to files in its base directory. These files are read by the node when it starts, so each time you change them, you need to restart the node.
The node also writes state to its base directory, so it will create files on its own.
This document contains a complete list of the config files that are examined by the client node, as well as the state files that you’ll observe in its base directory.
The main file is named “
tahoe.cfg”, and is an ”.INI”-style configuration
file (parsed by the Python stdlib ‘ConfigParser’ module: “
markers, lines with “
key.subkey: value”, rfc822-style
continuations). There are also other files containing information that does
not easily fit into this format. The “
tahoe create-node” or “
create-client” command will create an initial
tahoe.cfg file for
you. After creation, the node will never modify the
tahoe.cfg file: all
persistent state is put in other files.
The item descriptions below use the following types:
one of (True, yes, on, 1, False, off, no, 0), case-insensitive
a Twisted listening-port specification string, like “
tcp:80” or “
tcp:3456:interface=127.0.0.1”. For a full description of the format, see the Twisted strports documentation. Please note, if interface= is not specified, Tahoe-LAFS will attempt to bind the port specified on all interfaces.
endpoint specification string
a Twisted Endpoint specification string, like “
tcp:80” or “
tcp:3456:interface=127.0.0.1”. These are replacing strports strings. For a full description of the format, see the Twisted Endpoints documentation. Please note, if interface= is not specified, Tahoe-LAFS will attempt to bind the port specified on all interfaces. Also note that
tub.portonly works with TCP endpoints right now.
a Foolscap endpoint identifier, like
A node can be a client/server, an introducer, or a statistics gatherer.
Client/server nodes provide one or more of the following services:
- web-API service
- SFTP service
- FTP service
- Magic Folder service
- helper service
- storage service.
A client/server that provides storage service (i.e. storing shares for clients) is called a “storage server”. If it provides any of the other services, it is a “storage client” (a node can be both a storage server and a storage client). A client/server node that provides web-API service is called a “gateway”.
Overall Node Configuration¶
This section controls the network behavior of the node overall: which ports and IP addresses are used, when connections are timed out, etc. This configuration applies to all node types and is independent of the services that the node is offering.
If your node is behind a firewall or NAT device and you want other clients to
connect to it, you’ll need to open a port in the firewall or NAT, and specify
that port number in the tub.port option. If behind a NAT, you may need to
tub.location option described below.
nickname = (UTF-8 string, optional)
This value will be displayed in management tools as this node’s “nickname”. If not provided, the nickname will be set to “<unspecified>”. This string shall be a UTF-8 encoded Unicode string.
web.port = (strports string, optional)
This controls where the node’s web server should listen, providing node status and, if the node is a client/server, providing web-API service as defined in The Tahoe REST-ful Web API.
This file contains a Twisted “strports” specification such as “
3456” or “
tcp:3456:interface=127.0.0.1”. The “
tahoe create-node” or “
tahoe create-client” commands set the
tcp:3456:interface=127.0.0.1” by default; this is overridable by the
--webportoption. You can make it use SSL by writing “
If this is not provided, the node will not run a web server.
web.static = (string, optional)
This controls where the
/staticportion of the URL space is served. The value is a directory name (
The default value is “
public_html”, which will serve
BASEDIR/public_html. With the default settings,
http://127.0.0.1:3456/static/foo.htmlwill serve the contents of
tub.port = (endpoint specification strings or "disabled", optional)
This controls which port the node uses to accept Foolscap connections from other nodes. It is parsed as a comma-separated list of Twisted “server endpoint descriptor” strings, each of which is a value like
To listen on multiple ports at once (e.g. both TCP-on-IPv4 and TCP-on-IPv6), use something like
tcp6:interface=2600\:3c01\:f03c\:91ff\:fe93\:d272:3456,tcp:interface=184.108.40.206:3456. Lists of endpoint descriptor strings like the following
tcp:12345,tcp6:12345are known to not work because an
Address already in use.error.
tub.portis the string
disabled, the node will not listen at all, and thus cannot accept connections from other nodes. If
[storage] enabled = true, or
[helper] enabled = true, or the node is an Introducer, then it is an error to have
tub.portbe empty. If
tub.portis disabled, then
tub.locationmust also be disabled, and vice versa.
For backwards compatibility, if this contains a simple integer, it will be used as a TCP port number, like
tcp:%d(which will accept connections on all interfaces). However
tcp:0(older versions accepted this, but the node is no longer willing to ask Twisted to allocate port numbers in this way). If
tub.portis present, it may not be empty.
tub.portconfig key is not provided (e.g.
tub.portappears nowhere in the
[node]section, or is commented out), the node will look in
BASEDIR/introducer.port, for introducers) for the descriptor that was used last time.
tub.portnor the port file is available, the node will ask the kernel to allocate any available port (the moral equivalent of
tcp:0). The allocated port number will be written into a descriptor string in
introducer.port), so that subsequent runs will re-use the same port.
tub.location = (hint string or "disabled", optional)
In addition to running as a client, each Tahoe-LAFS node can also run as a server, listening for connections from other Tahoe-LAFS clients. The node announces its location by publishing a “FURL” (a string with some connection hints) to the Introducer. The string it publishes can be found in
tub.locationconfiguration controls what location is published in this announcement.
If your node is meant to run as a server, you should fill this in, using a hostname or IP address that is reachable from your intended clients.
tub.portis set to
tub.locationmust also be
If you don’t provide
tub.location, the node will try to figure out a useful one by itself, by using tools like “
ifconfig” to determine the set of IP addresses on which it can be reached from nodes both near and far. It will also include the TCP port number on which it is listening (either the one specified by
tub.port, or whichever port was assigned by the kernel when
tub.portis left unspecified). However this automatic address-detection is discouraged, and will probably be removed from a future release. It will include the
127.0.0.1“localhost” address (which is only useful to clients running on the same computer), and RFC1918 private-network addresses like
192.168.*.*(which are only useful to clients on the local LAN). In general, the automatically-detected IP addresses will only be useful if the node has a public IP address, such as a VPS or colo-hosted server.
You will certainly need to set
tub.locationif your node lives behind a firewall that is doing inbound port forwarding, or if you are using other proxies such that the local IP address or port number is not the same one that remote clients should use to connect. You might also want to control this when using a Tor proxy to avoid revealing your actual IP address through the Introducer announcement.
tub.locationis specified, by default it entirely replaces the automatically determined set of IP addresses. To include the automatically determined addresses as well as the specified ones, include the uppercase string “
AUTO” in the list.
The value is a comma-separated string of method:host:port location hints, like this:tcp:220.127.116.11:8098,tcp:tahoe.example.com:8098,tcp:127.0.0.1:8098
A few examples:
Don’t listen at all (client-only mode):tub.port = disabled tub.location = disabled
Use a DNS name so you can change the IP address more easily:tub.port = tcp:8098 tub.location = tcp:tahoe.example.com:8098
Run a node behind a firewall (which has an external IP address) that has been configured to forward external port 7912 to our internal node’s port 8098:tub.port = tcp:8098 tub.location = tcp:external-firewall.example.com:7912
Emulate default behavior, assuming your host has public IP address of 18.104.22.168, and the kernel-allocated port number was 8098:tub.port = tcp:8098 tub.location = tcp:22.214.171.124:8098,tcp:127.0.0.1:8098
Use a DNS name but also include the default set of addresses:tub.port = tcp:8098 tub.location = tcp:tahoe.example.com:8098,AUTO
Run a node behind a Tor proxy (perhaps via
torsocks), in client-only mode (i.e. we can make outbound connections, but other nodes will not be able to connect to us). The literal ‘
unreachable.example.org‘ will not resolve, but will serve as a reminder to human observers that this node cannot be reached. “Don’t call us.. we’ll call you”:tub.port = tcp:8098 tub.location = tcp:unreachable.example.org:0
Run a node behind a Tor proxy, and make the server available as a Tor “hidden service”. (This assumes that other clients are running their node with
torsocks, such that they are prepared to connect to a
.onionaddress.) The hidden service must first be configured in Tor, by giving it a local port number and then obtaining a
.onionname, using something in the
torrcfile like:HiddenServiceDir /var/lib/tor/hidden_services/tahoe HiddenServicePort 29212 127.0.0.1:8098
once Tor is restarted, the
.onionhostname will be in
/var/lib/tor/hidden_services/tahoe/hostname. Then set up your
tahoe.cfglike:tub.port = tcp:8098 tub.location = tor:ualhejtq2p7ohfbb.onion:29212
log_gatherer.furl = (FURL, optional)
If provided, this contains a single FURL string that is used to contact a “log gatherer”, which will be granted access to the logport. This can be used to gather operational logs in a single place. Note that in previous releases of Tahoe-LAFS, if an old-style
BASEDIR/log_gatherer.furlfile existed it would also be used in addition to this value, allowing multiple log gatherers to be used at once. As of Tahoe-LAFS v1.9.0, an old-style file is ignored and a warning will be emitted if one is detected. This means that as of Tahoe-LAFS v1.9.0 you can have at most one log gatherer per node. See ticket #1423 about lifting this restriction and letting you have multiple log gatherers.
timeout.keepalive = (integer in seconds, optional)
timeout.disconnect = (integer in seconds, optional)
timeout.keepaliveis provided, it is treated as an integral number of seconds, and sets the Foolscap “keepalive timer” to that value. For each connection to another node, if nothing has been heard for a while, we will attempt to provoke the other end into saying something. The duration of silence that passes before sending the PING will be between KT and 2*KT. This is mainly intended to keep NAT boxes from expiring idle TCP sessions, but also gives TCP’s long-duration keepalive/disconnect timers some traffic to work with. The default value is 240 (i.e. 4 minutes).
If timeout.disconnect is provided, this is treated as an integral number of seconds, and sets the Foolscap “disconnect timer” to that value. For each connection to another node, if nothing has been heard for a while, we will drop the connection. The duration of silence that passes before dropping the connection will be between DT-2*KT and 2*DT+2*KT (please see ticket #521 for more details). If we are sending a large amount of data to the other end (which takes more than DT-2*KT to deliver), we might incorrectly drop the connection. The default behavior (when this value is not provided) is to disable the disconnect timer.
See ticket #521 for a discussion of how to pick these timeout values. Using 30 minutes means we’ll disconnect after 22 to 68 minutes of inactivity. Receiving data will reset this timeout, however if we have more than 22min of data in the outbound queue (such as 800kB in two pipelined segments of 10 shares each) and the far end has no need to contact us, our ping might be delayed, so we may disconnect them by accident.
tempdir = (string, optional)
This specifies a temporary directory for the web-API server to use, for holding large files while they are being uploaded. If a web-API client attempts to upload a 10GB file, this tempdir will need to have at least 10GB available for the upload to complete.
The default value is the
tmpdirectory in the node’s base directory (i.e.
BASEDIR/tmp), but it can be placed elsewhere. This directory is used for files that usually (on a Unix system) go into
/tmp. The string will be interpreted relative to the node’s base directory.
reveal-IP-address = (boolean, optional, defaults to True)
This is a safety flag. When set to False (aka “private mode”), the node will refuse to start if any of the other configuration options would reveal the node’s IP address to servers or the external network. This flag does not directly affect the node’s behavior: its only power is to veto node startup when something looks unsafe.
The default is True (non-private mode), because setting it to False requires the installation of additional libraries (use
pip install tahoe-lafs[tor]and/or
pip install tahoe-lafs[i2p]to get them) as well as additional non-python software (Tor/I2P daemons). Performance is also generally reduced when operating in private mode.
When False, any of the following configuration problems will cause
tahoe startto throw a PrivacyError instead of starting the node:
[node] tub.locationcontains any
AUTO, or is missing/empty (because that defaults to AUTO)
[connections] tcp =is set to
tcp(or left as the default), rather than being set to
Three sections (
[connections]) control how the
Tahoe node makes outbound connections. Tor and I2P are configured here. This
also controls when Tor and I2P are used: for all TCP connections (to hide
your IP address), or only when necessary (just for servers which declare that
they need Tor, because they use
Note that if you want to protect your node’s IP address, you should set
[node] reveal-IP-address = False, which will refuse to launch the node if
any of the other configuration settings might violate this privacy property.
This section controls when Tor and I2P are used. The
[i2p] sections (described later) control how Tor/I2P connections are
All Tahoe nodes need to make a connection to the Introducer; the
introducer.furl setting (described below) indicates where the Introducer
lives. Tahoe client nodes must also make connections to storage servers:
these targets are specified in announcements that come from the Introducer.
Both are expressed as FURLs (a Foolscap URL), which include a list of
“connection hints”. Each connection hint describes one (of perhaps many)
network endpoints where the service might live.
Connection hints include a type, and look like:
tor hints are always handled by the
tor handler (configured in the
[tor] section, described below). Likewise,
i2p hints are always
routed to the
i2p handler. But either will be ignored if Tahoe was not
installed with the necessary Tor/I2P support libraries, or if the Tor/I2P
daemon is unreachable.
[connections] section lets you control how
tcp hints are handled.
By default, they use the normal TCP handler, which just makes direct
connections (revealing your node’s IP address to both the target server and
the intermediate network). The node behaves this way if the
section is missing entirely, or if it looks like this:
[connections] tcp = tcp
To hide the Tahoe node’s IP address from the servers that it uses, set the
[connections] section to use Tor for TCP hints:
[connections] tcp = tor
You can also disable TCP hints entirely, which would be appropriate when running an I2P-only node:
[connections] tcp = disabled
(Note that I2P does not support connections to normal TCP ports, so
[connections] tcp = i2p is invalid)
In the future, Tahoe services may be changed to live on HTTP/HTTPS URLs
instead of Foolscap. In that case, connections will be made using whatever
handler is configured for
tcp hints. So the same
tcp = tor
configuration will work.
This controls how Tor connections are made. The defaults (all empty) mean
that, when Tor is needed, the node will try to connect to a Tor daemon’s
SOCKS proxy on localhost port 9050 or 9150. Port 9050 is the default Tor
SOCKS port, so it should be available under any system Tor instance (e.g. the
one launched at boot time when the standard Debian
tor package is
installed). Port 9150 is the SOCKS port for the Tor Browser Bundle, so it
will be available any time the TBB is running.
You can set
launch = True to cause the Tahoe node to launch a new Tor
daemon when it starts up (and kill it at shutdown), if you don’t have a
system-wide instance available. Note that it takes 30-60 seconds for Tor to
get running, so using a long-running Tor process may enable a faster startup.
If your Tor executable doesn’t live on
enabled = (boolean, optional, defaults to True)
If False, this will disable the use of Tor entirely. The default of True means the node will use Tor, if necessary, and if possible.
socks.port = (string, optional, endpoint specification string, defaults to empty)
This tells the node that Tor connections should be routed to a SOCKS proxy listening on the given endpoint. The default (of an empty value) will cause the node to first try localhost port 9050, then if that fails, try localhost port 9150. These are the default listening ports of the standard Tor daemon, and the Tor Browser Bundle, respectively.
While this nominally accepts an arbitrary endpoint string, internal limitations prevent it from accepting anything but
tcp:HOST:PORT(unfortunately, unix-domain sockets are not yet supported). See ticket #2813 for details. Also note that using a HOST of anything other than localhost is discouraged, because you would be revealing your IP address to external (and possibly hostile) machines.
control.port = (string, optional, endpoint specification string)
This tells the node to connect to a pre-existing Tor daemon on the given control port (which is typically
tcp:localhost:9051). The node will then ask Tor what SOCKS port it is using, and route Tor connections to that.
launch = (bool, optional, defaults to False)
If True, the node will spawn a new (private) copy of Tor at startup, and will kill it at shutdown. The new Tor will be given a persistent state directory under
NODEDIR/private/, where Tor’s microdescriptors will be cached, to speed up subsequent startup.
tor.executable = (string, optional, defaults to empty)
This controls which Tor executable is used when
launch = True. If empty, the first executable program named
$PATHwill be used.
There are 5 valid combinations of these configuration settings:
(empty): use SOCKS on port 9050/9150
launch = true: launch a new Tor
socks.port = tcp:HOST:PORT: use an existing Tor on the given SOCKS port
control.port = ENDPOINT: use an existing Tor at the given control port
enabled = false: no Tor at all
1 is the default, and should work for any Linux host with the system Tor package installed. 2 should work on any box with Tor installed into $PATH, but will take an extra 30-60 seconds at startup. 3 and 4 can be used for specialized installations, where Tor is already running, but not listening on the default port. 5 should be used in environments where Tor is installed, but should not be used (perhaps due to a site-wide policy).
Note that Tor support depends upon some additional Python libraries. To
install Tahoe with Tor support, use
pip install tahoe-lafs[tor].
This controls how I2P connections are made. Like with Tor, the all-empty
defaults will cause I2P connections to be routed to a pre-existing I2P daemon
on port 7656. This is the default SAM port for the
enabled = (boolean, optional, defaults to True)
If False, this will disable the use of I2P entirely. The default of True means the node will use I2P, if necessary, and if possible.
sam.port = (string, optional, endpoint descriptor, defaults to empty)
This tells the node that I2P connections should be made via the SAM protocol on the given port. The default (of an empty value) will cause the node to try localhost port 7656. This is the default listening port of the standard I2P daemon.
launch = (bool, optional, defaults to False)
If True, the node will spawn a new (private) copy of I2P at startup, and will kill it at shutdown. The new I2P will be given a persistent state directory under
NODEDIR/private/, where I2P’s microdescriptors will be cached, to speed up subsequent startup. The daemon will allocate its own SAM port, which will be queried from the config directory.
i2p.configdir = (string, optional, directory)
This tells the node to parse an I2P config file in the given directory, and use the SAM port it finds there. If
launch = True, the new I2P daemon will be told to use the given directory (which can be pre-populated with a suitable config file). If
launch = False, we assume there is a pre-running I2P daemon running from this directory, and can again parse the config file for the SAM port.
i2p.executable = (string, optional, defaults to empty)
This controls which I2P executable is used when
launch = True. If empty, the first executable program named
$PATHwill be used.
introducer.furl = (FURL string, mandatory)
This FURL tells the client how to connect to the introducer. Each Tahoe-LAFS grid is defined by an introducer. The introducer’s FURL is created by the introducer node and written into its private base directory when it starts, whereupon it should be published to everyone who wishes to attach a client to that grid
helper.furl = (FURL string, optional)
If provided, the node will attempt to connect to and use the given helper for uploads. See The Tahoe Upload Helper for details.
stats_gatherer.furl = (FURL string, optional)
If provided, the node will connect to the given stats gatherer and provide it with operational statistics.
shares.needed = (int, optional) aka "k", default 3
shares.total = (int, optional) aka "N", N >= k, default 10
shares.happy = (int, optional) 1 <= happy <= N, default 7
These three values set the default encoding parameters. Each time a new file is uploaded, erasure-coding is used to break the ciphertext into separate shares. There will be
shares.total) shares created, and the file will be recoverable if any
shares.needed) shares are retrieved. The default values are 3-of-10 (i.e.
shares.needed = 3,
shares.total = 10). Setting
kto 1 is equivalent to simple replication (uploading
Ncopies of the file).
These values control the tradeoff between storage overhead and reliability. To a first approximation, a 1MB file will use (1MB *
k) of backend storage space (the actual value will be a bit more, because of other forms of overhead). Up to
kshares can be lost before the file becomes unrecoverable. So large
kratios are more reliable, and small
kratios use less disk space.
Ncannot be larger than 256, because of the 8-bit erasure-coding algorithm that Tahoe-LAFS uses.
kcan not be greater than
N. See Performance costs for some common operations for more details.
shares.happyallows you control over how well to “spread out” the shares of an immutable file. For a successful upload, shares are guaranteed to be initially placed on at least
shares.happydistinct servers, the correct functioning of any
kof which is sufficient to guarantee the availability of the uploaded file. This value should not be larger than the number of servers on your grid.
A value of
kis allowed, but this is not guaranteed to provide any redundancy if some servers fail or lose shares. It may still provide redundancy in practice if
Nis greater than the number of connected servers, because in that case there will typically be more than one share on at least some storage nodes. However, since a successful upload only guarantees that at least
shares.happyshares have been stored, the worst case is still that there is no redundancy.
(Mutable files use a different share placement algorithm that does not currently consider this parameter.)
mutable.format = sdmf or mdmf
This value tells Tahoe-LAFS what the default mutable file format should be. If
mutable.format=sdmf, then newly created mutable files will be in the old SDMF format. This is desirable for clients that operate on grids where some peers run older versions of Tahoe-LAFS, as these older versions cannot read the new MDMF mutable file format. If
mdmf, then newly created mutable files will use the new MDMF format, which supports efficient in-place modification and streaming downloads. You can overwrite this value using a special mutable-type parameter in the webapi. If you do not specify a value here, Tahoe-LAFS will use SDMF for all newly-created mutable files.
Note that this parameter applies only to files, not to directories. Mutable directories, which are stored in mutable files, are not controlled by this parameter and will always use SDMF. We may revisit this decision in future versions of Tahoe-LAFS.
See Mutable Files for details about mutable file formats.
peers.preferred = (string, optional)
This is an optional comma-separated list of Node IDs of servers that will be tried first when selecting storage servers for reading or writing.
Servers should be identified here by their Node ID as it appears in the web ui, underneath the server’s nickname. For storage servers running tahoe versions >=1.10 (if the introducer is also running tahoe >=1.10) this will be a “Node Key” (which is prefixed with ‘v0-‘). For older nodes, it will be a TubID instead. When a preferred server (and/or the introducer) is upgraded to 1.10 or later, clients must adjust their configs accordingly.
Every node selected for upload, whether preferred or not, will still receive the same number of shares (one, if there are
Nor more servers accepting uploads). Preferred nodes are simply moved to the front of the server selection lists computed for each file.
This is useful if a subset of your nodes have different availability or connectivity characteristics than the rest of the grid. For instance, if there are more than
Nservers on the grid, and
Kor more of them are at a single physical location, it would make sense for clients at that location to prefer their local servers so that they can maintain access to all of their uploads without using the internet.
The Tahoe-LAFS client process can run a variety of frontend file access protocols. You will use these to create and retrieve files from the Tahoe-LAFS file store. Configuration details for each are documented in the following protocol-specific guides:
Tahoe runs a webserver by default on port 3456. This interface provides a human-oriented “WUI”, with pages to create, modify, and browse directories and files, as well as a number of pages to check on the status of your Tahoe node. It also provides a machine-oriented “WAPI”, with a REST-ful HTTP interface that can be used by other programs (including the CLI tools). Please see The Tahoe REST-ful Web API for full details, and the
web.staticconfig variables above. Download status also describes a few WUI status pages.
tahoeexecutable includes subcommands for manipulating the file store, uploading/downloading files, and creating/running Tahoe nodes. See The Tahoe-LAFS CLI commands for details.
Tahoe can also run both SFTP and FTP servers, and map a username/password pair to a top-level Tahoe directory. See Tahoe-LAFS SFTP and FTP Frontends for instructions on configuring these services, and the
A node running on Linux or Windows can be configured to automatically upload files that are created or changed in a specified local directory. See Tahoe-LAFS Magic Folder Frontend for details.
Storage Server Configuration¶
enabled = (boolean, optional)
If this is
True, the node will run a storage server, offering space to other clients. If it is
False, the node will not run a storage server, meaning that no shares will be stored on this node. Use
Falsefor clients who do not wish to provide storage service. The default value is
readonly = (boolean, optional)
True, the node will run a storage server but will not accept any shares, making it effectively read-only. Use this for storage servers that are being decommissioned: the
storage/directory could be mounted read-only, while shares are moved to other servers. Note that this currently only affects immutable shares. Mutable shares (used for directories) will be written and modified anyway. See ticket #390 for the current status of this bug. The default value is
reserved_space = (str, optional)
If provided, this value defines how much disk space is reserved: the storage server will not accept any share that causes the amount of free disk space to drop below this value. (The free space is measured by a call to
statvfs(2)on Unix, or
GetDiskFreeSpaceExon Windows, and is the space available to the user account under which the storage server runs.)
This string contains a number, with an optional case-insensitive scale suffix, optionally followed by “B” or “iB”. The supported scale suffixes are “K”, “M”, “G”, “T”, “P” and “E”, and a following “i” indicates to use powers of 1024 rather than 1000. So “100MB”, “100 M”, “100000000B”, “100000000”, and “100000kb” all mean the same thing. Likewise, “1MiB”, “1024KiB”, “1024 Ki”, and “1048576 B” all mean the same thing.
tahoe create-node” generates a tahoe.cfg with “
reserved_space=1G”, but you may wish to raise, lower, or remove the reservation to suit your needs.
These settings control garbage collection, in which the server will delete shares that no longer have an up-to-date lease on them. Please see Garbage Collection in Tahoe for full details.
Running A Helper¶
A “helper” is a regular client node that also offers the “upload helper” service.
enabled = (boolean, optional)
True, the node will run a helper (see The Tahoe Upload Helper for details). The helper’s contact FURL will be placed in
private/helper.furl, from which it can be copied to any clients that wish to use it. Clearly nodes should not both run a helper and attempt to use one: do not create
helper.furland also define
[helper]enabledin the same node. The default is
Running An Introducer¶
The introducer node uses a different
.tac file (named
introducer.tac”), and pays attention to the
[node] section, but not
The Introducer node maintains some different state than regular client nodes.
This is generated the first time the introducer node is started, and used again on subsequent runs, to give the introduction service a persistent long-term identity. This file should be published and copied into new client nodes before they are started for the first time.
Other Files in BASEDIR¶
Some configuration is not kept in
tahoe.cfg, for the following reasons:
- it doesn’t fit into the INI format of
- it is generated by the node at startup, e.g. encryption keys. The node
never writes to
- it is generated by user action, e.g. the “
tahoe create-alias” command.
In addition, non-configuration persistent state is kept in the node’s base directory, next to the configuration knobs.
This section describes these other files.
This contains an SSL private-key certificate. The node generates this the first time it is started, and re-uses it on subsequent runs. This certificate allows the node to have a cryptographically-strong identifier (the Foolscap “TubID”), and to establish secure connections to other nodes.
Nodes that host StorageServers will create this directory to hold shares of files on behalf of other clients. There will be a directory underneath it for each StorageIndex for which this node is holding shares. There is also an “incoming” directory where partially-completed shares are held while they are being received.
This file defines the client, by constructing the actual Client instance each time the node is started. It is used by the “
twistd” daemonization program (in the
-ymode), which is run internally by the “
tahoe start” command. This file is created by the “
tahoe create-node” or “
tahoe create-client” commands.
This file is used to construct an introducer, and is created by the “
tahoe create-introducer” command.
This file is used to construct a statistics gatherer, and is created by the “
tahoe create-stats-gatherer” command.
This file contains a FURL that provides access to a control port on the client node, from which files can be uploaded and downloaded. This file is created with permissions that prevent anyone else from reading it (on operating systems that support such a concept), to insure that only the owner of the client node can use this feature. This port is intended for debugging and testing use.
This file contains a FURL that provides access to a ‘log port’ on the client node, from which operational logs can be retrieved. Do not grant logport access to strangers, because occasionally secret information may be placed in the logs.
If the node is running a helper (for use by other clients), its contact FURL will be placed here. See The Tahoe Upload Helper for more details.
The command-line tools will read a directory cap out of this file and use it, if you don’t specify a ‘–dir-cap’ option or if you specify ‘–dir-cap=root’.
private/convergence (automatically generated)
An added secret for encrypting immutable files. Everyone who has this same string in their
private/convergencefile encrypts their immutable files in the same way when uploading them. This causes identical files to “converge” – to share the same storage space since they have identical ciphertext – which conserves space and optimizes upload time, but it also exposes file contents to the possibility of a brute-force attack by people who know that string. In this attack, if the attacker can guess most of the contents of a file, then they can use brute-force to learn the remaining contents.
So the set of people who know your
private/convergencestring is the set of people who converge their storage space with you when you and they upload identical immutable files, and it is also the set of people who could mount such an attack.
The content of the
private/convergencefile is a base-32 encoded string. If the file doesn’t exist, then when the Tahoe-LAFS client starts up it will generate a random 256-bit string and write the base-32 encoding of this string into the file. If you want to converge your immutable files with as many people as possible, put the empty string (so that
private/convergenceis a zero-length file).
Additional Introducer Definitions¶
private/introducers.yaml file defines additional Introducers. The
first introducer is defined in
introducer.furl. To use two or more Introducers, choose a locally-unique
“petname” for each one, then define their FURLs in
private/introducers.yaml like this:
introducers: petname2: furl: FURL2 petname3: furl: FURL3
Servers will announce themselves to all configured introducers. Clients will merge the announcements they receive from all introducers. Nothing will re-broadcast an announcement (i.e. telling introducer 2 about something you heard from introducer 1).
If you omit the introducer definitions from both
introducers.yaml, the node will not use an Introducer at all. Such
“introducerless” clients must be configured with static servers (described
below), or they will not be able to upload and download files.
Static Server Definitions¶
private/servers.yaml file defines “static servers”: those which are
not announced through the Introducer. This can also control how we connect to
Most clients do not need this file. It is only necessary if you want to use
servers which are (for some specialized reason) not announced through the
Introducer, or to connect to those servers in different ways. You might do
this to “freeze” the server list: use the Introducer for a while, then copy
all announcements into
servers.yaml, then stop using the Introducer
entirely. Or you might have a private server that you don’t want other users
to learn about (via the Introducer). Or you might run a local server which is
announced to everyone else as a Tor onion address, but which you can connect
to directly (via TCP).
The file syntax is YAML, with a top-level dictionary named
Other items may be added in the future.
storage dictionary takes keys which are server-ids, and values which
are dictionaries with two keys:
value is a dictionary which will be used in lieu of the introducer
announcement, so it can be populated by copying the
ann dictionary from
The server-id can be any string, but ideally you should use the public key as
published by the server. Each server displays this as “Node ID:” in the
top-right corner of its “WUI” web welcome page. It can also be obtained from
other client nodes, which record it as
key_s: in their
introducer_cache.yaml file. The format is “v0-” followed by 52 base32
characters like so:
ann dictionary really only needs one key:
anonymous-storage-FURL: how we connect to the server
(note that other important keys may be added in the future, as Accounting and HTTP-based servers are implemented)
Optional keys include:
nickname: the name of this server, as displayed on the Welcome page server list
permutation-seed-base32: this controls how shares are mapped to servers. This is normally computed from the server-ID, but can be overridden to maintain the mapping for older servers which used to use Foolscap TubIDs as server-IDs. If your selected server-ID cannot be parsed as a public key, it will be hashed to compute the permutation seed. This is fine as long as all clients use the same thing, but if they don’t, then your client will disagree with the other clients about which servers should hold each share. This will slow downloads for everybody, and may cause additional work or consume extra storage when repair operations don’t converge.
- anything else from the
my-version, which is displayed on the Welcome page server list
For example, a private static server could be defined with a
private/servers.yaml file like this:
storage: v0-4uazse3xb6uu5qpkb7tel2bm6bpea4jhuigdhqcuvvse7hugtsia: ann: nickname: my-server-1 anonymous-storage-FURL: pb://u33m4y7klhz3bypswqkozwetvabelhxt@tcp:126.96.36.199:51298/eiu2i7p6d6mm4ihmss7ieou5hac3wn6b
Or, if you’re feeling really lazy:
storage: my-serverid-1: ann: anonymous-storage-FURL: pb://u33m4y7klhz3bypswqkozwetvabelhxt@tcp:188.8.131.52:51298/eiu2i7p6d6mm4ihmss7ieou5hac3wn6b
Overriding Connection-Handlers for Static Servers¶
connections entry will override the default connection-handler mapping
(as established by
tahoe.cfg [connections]). This can be used to build a
“Tor-mostly client”: one which is restricted to use Tor for all connections,
except for a few private servers to which normal TCP connections will be
made. To override the published announcement (and thus avoid connecting twice
to the same server), the server ID must exactly match.
[connections] # this forces the use of Tor for all "tcp" hints tcp = tor
storage: v0-c2ng2pbrmxmlwpijn3mr72ckk5fmzk6uxf6nhowyosaubrt6y5mq: ann: nickname: my-server-1 anonymous-storage-FURL: pb://u33m4y7klhz3bypswqkozwetvabelhxt@tcp:10.1.2.3:51298/eiu2i7p6d6mm4ihmss7ieou5hac3wn6b connections: # this overrides the tcp=tor from tahoe.cfg, for just this server tcp: tcp
connections table is needed to override the
tcp = tor mapping
that comes from
tahoe.cfg. Without it, the client would attempt to use
Tor to connect to
10.1.2.3, which would fail because it is a
local/non-routeable (RFC1918) address.
Each Tahoe-LAFS node creates a directory to hold the log messages produced as the node runs. These logfiles are created and rotated by the “
twistd” daemonization program, so
logs/twistd.logwill contain the most recent messages,
logs/twistd.log.1will contain the previous ones,
logs/twistd.log.2will be older still, and so on.
twistdrotates logfiles after they grow beyond 1MB in size. If the space consumed by logfiles becomes troublesome, they should be pruned: a cron job to delete all files that were created more than a month ago in this
logs/directory should be sufficient.
this is written by all nodes after startup, and contains a base32-encoded (i.e. human-readable) NodeID that identifies this specific node. This NodeID is the same string that gets displayed on the web page (in the “which peers am I connected to” list), and the shortened form (the first few characters) is recorded in various log messages.
Gateway nodes may find it necessary to prohibit access to certain files. The web-API has a facility to block access to filecaps by their storage index, returning a 403 “Forbidden” error instead of the original file. For more details, see the “Access Blacklist” section of The Tahoe REST-ful Web API.
The following is a sample
tahoe.cfg file, containing values for some of
the keys described in the previous section. Note that this is not a
recommended configuration (most of these are not the default values), merely
a legal one.
[node] nickname = Bob's Tahoe-LAFS Node tub.port = tcp:34912 tub.location = tcp:184.108.40.206:8098,tcp:220.127.116.11:8098 web.port = tcp:3456 log_gatherer.furl = pb://email@example.com:44801/eqpwqtzm timeout.keepalive = 240 timeout.disconnect = 1800 [client] introducer.furl = pb://ok45ssoklj4y7eok5c3xkmj@tcp:tahoe.example:44801/ii3uumo helper.furl = pb://ggti5ssoklj4y7eok5c3xkmj@tcp:helper.tahoe.example:7054/kk8lhr [storage] enabled = True readonly = True reserved_space = 10000000000 [helper] enabled = True
Old Configuration Files¶
Tahoe-LAFS releases before v1.3.0 had no
tahoe.cfg file, and used
distinct files for each item. This is no longer supported and if you have
configuration in the old format you must manually convert it to the new
format for Tahoe-LAFS to detect it. See Old Configuration Files.