Get Started

The following is written for users of Mac OS X. If you are not using one of these platforms, please refer to the Linux or Windows guide.

Before proceeding, this guide uses the Infinit command-line tools with a terminal window. You don’t need to be a UNIX guru but you should be familiar with typing shell commands and interpreting outputs. You can otherwise download the Infinit Drive desktop client.

1. Installation

Download and install Infinit’s dependencies

FUSE

Infinit relies on FUSE to create filesystems in userland. You will need to install the OSXFUSE from the link below:

DOWNLOAD OSXFUSE

NOTE: Infinit requires a version of OSXFUSE that is newer than available on https://osxfuse.github.io/.

Download and install the Infinit command-line tools

Infinit Command Line Tools

Click the link below to download the Infinit command-line tools:

DOWNLOAD COMMAND LINE TOOLS

Next, open your terminal and extract the Infinit tarball:

%%EDITORCONTENT%%gt; tar xjvf Infinit-x86_64-osx-clang3-0.3.7.tbz
Infinit-x86_64-osx-clang3-0.3.7/
Infinit-x86_64-osx-clang3-0.3.7/bin/
Infinit-x86_64-osx-clang3-0.3.7/lib
...
Infinit-x86_64-osx-clang3-0.3.7/bin/infinit-storage
Infinit-x86_64-osx-clang3-0.3.7/bin/infinit-user
Infinit-x86_64-osx-clang3-0.3.7/bin/infinit-volume
...

All the configuration files that the Infinit command-line tools create and use are located in the $INFINIT_DATA_HOME directory which, by default, is set to $HOME/.local/share/infinit/filesystem/, following the XDG Base Directory Specification. You can edit your shell configuration to set INFINIT_DATA_HOME to another location if you would like.

Now that you’ve extracted the tarball, take a look. The extracted directory contains the following subdirectories:

  • The bin/ subdirectory contains the actual Infinit binaries such as infinit-userinfinit-network, etc.
  • The lib/ subdirectory contains all the libraries the above binaries depend upon to operate (excluding the FUSE library you installed earlier).
  • The share/infinit/filesystem/test/ subdirectory is provided for you to quickly test the command-line tools, see below.
%%EDITORCONTENT%%gt; cd Infinit-x86_64-osx-clang3-0.3.7/
%%EDITORCONTENT%%gt; ls
bin/    lib/    share/

2. Basic Test

For you to quickly (through a single command) try Infinit out, the following is going to let you mount an existing volume and access files through a mount point. Don’t worry, this file system only contains test files that we put there ourselves for you to test Infinit. You cannot do any harm to those files since you only have read-only access to this test volume.

Run the infinit-volume command by prefixing it with the environment variable INFINIT_DATA_HOME=$PWD/share/infinit/filesystem/test/home to tell the command where to look for the configuration files required for this test.

%%EDITORCONTENT%%gt; INFINIT_DATA_HOME=$PWD/share/infinit/filesystem/test/home/ ./bin/infinit-volume --mount --as demo --name infinit/demo --mountpoint ~/mnt-demo/ --publish --cache

NOTE: You can stop this test volume by hitting CTRL^C or by interrupting the infinit-volume process.

This command mounts the volume named ‘infinit/demo’ on behalf of the user ‘demo’ and makes it accessible through the mount point ~/mnt-demo/.

Now open another terminal. You can access the files in the ‘demo’ volume by browsing the mount point ~/mnt-demo/ as you would any other POSIX-compliant filesystem.

Infinit streams the data as it is needed from our server in the US. This allows you to access the files immediately without having to wait for them to be cloned locally as you would with a cloud storage service like Dropbox.

%%EDITORCONTENT%%gt; ls ~/mnt-demo/
Aosta Valley/         Brannenburg/          Cape Town/            Infinit_MakingOf.mp4 New York/             Paris/

3. Create Infrastructure

It is now time for you to create your own storage infrastructure. What follows is a step-by-step guide to set up infrastructure for a single user with two devices (named A and B). One of the devices will contribute storage capacity to store the blocks of data composing the files while the second device will read and write blocks over the network. This creates an NFS-like system even though it is also possible to create infrastructure where more than one node stores blocks.

two devices with a file composed of blocks that are distributed among those devices

NOTE: For more information to learn how to set up completely decentralized infrastructure, how to plug cloud storage services such as AWS S3, Google Cloud Storage etc. or how to invite non-tech-savvy users to join and use storage infrastructure to store and access files as usual, please refer to the reference documentation.

First, add the bin/ directory to the PATH environment variable to be able to invoke the command-line tools from anywhere:

%%EDITORCONTENT%%gt; export PATH=$PWD/bin/:$PATH

Create a user

The first step consists of creating a user on the Hub. All the commands that follow use the user name ‘bob’ but you should pick your own unique user name:

DEVICE A
%%EDITORCONTENT%%gt; infinit-user --signup --name bob --email bob@company.com --fullname "Bob"
Generating RSA keypair.
Remotely pushed user "bob".

Create a storage resource

A storage resource behaves like a hard disk, storing data blocks without understanding the data’s meaning. The beauty of Infinit is that it is completely agnostic of the nature of such storage resources.

Next, we are going to declare a local storage resource. A local storage stores data blocks as files in a directory (such as /var/storage/infinit/) on the local filesystem.

The binary infinit-storage is used for this purpose. The option ‑‑filesystem is used to indicate that the storage will be on the local filesystem:

DEVICE A
%%EDITORCONTENT%%gt; infinit-storage --create --filesystem --name local --capacity 1GB
Created storage "local".

Create a network

Now that we have at least one storage resource to store data, we can create a network interconnecting different machines.

The infinit-network command is used to create the network, specifying a name along with the list of storage resources to rely upon. We will ignore the other options now but you can read about them in the reference documentation. In this example, only the ‘local’ storage resource is used but you could plug as many as you like. Obviously, you need to substitute ‘bob’ with your username:

DEVICE A
%%EDITORCONTENT%%gt; infinit-network --create --as bob --storage local --kelips --name my-network --push
Locally created network "bob/my-network".
Remotely pushed network "bob/my-network".

NOTE: The ‑‑push option is used to publish the created network (likewise for other objects) onto the Hub for it to be easily fetched on another device or shared with other users.

Create a volume

The last step on this device consists of creating a logical volume to store and access files. Volumes can be manipulated through the infinit-volume binary as shown next:

DEVICE A
%%EDITORCONTENT%%gt; infinit-volume --create --as bob --network my-network --name my-volume --push
Locally created volume "bob/my-volume".
Remotely pushed volume "bob/my-volume".

That’s it, you’ve created a volume named ‘my-volume’ i.e. a filesystem. The blocks that the files are composed of will be distributed across the network named ‘my-network’, currently composed of a single computer with a single storage resource.

Mount the volume

Let’s access this volume by mounting it as easily as any other filesystem:

DEVICE A
%%EDITORCONTENT%%gt; infinit-volume --mount --as bob --name my-volume --mountpoint ~/mnt-my-volume/ --async --cache --publish
Fetched endpoints for "bob/my-network".
Running network "bob/my-network".
Remotely pushed endpoints for "bob/my-network".
Running volume "bob/my-volume".

NOTE: This command does not return. You can make it run in the background if you prefer. To stop it and unmount the volume, just hit CTRL^C or interrupt the process. You should wait until the end of the guide to stop this process though.

That’s it! You can now create, list and access files from the mount point ~/mnt-my-volume. Try creating a file right now:

DEVICE A
%%EDITORCONTENT%%gt; echo "everything is" > ~/mnt-my-volume/awesome.txt
%%EDITORCONTENT%%gt; cat ~/mnt-my-volume/awesome.txt
everything is

Access from another machine

Now that you have successfully created and mounted a volume on your machine, it would be interesting to access the data from your other devices. If you don’t have another device, you can simulate another device by opening another terminal and setting INFINIT_DATA_HOME to a different directory.

In order to access your volume from another device, you will need to transfer your user’s identity to that device. A user’s identity is analogous to an SSH key pair and should be treated in the same way. Because of its critical nature, it is not stored on the Hub like network and volume descriptors could be for instance. For this guide, we will rely on the Hub to transmit the identity in encrypted form to the other device.

Let’s transmit the user’s identity to the other device. Note that it will be encrypted with a passphrase chosen by you. Also you will only have 5 minutes to retrieve it on device B.

DEVICE A
%%EDITORCONTENT%%gt; infinit-device --transmit --user --as bob
Passphrase: ********
Transmitted user identity for "bob".
User identity on the Hub for: 297 seconds

Now let’s move to device B. First, you need to download, install and configure the Infinit command-line tools on this new device as you did for device A. Please refer to the first sections of this guide for that purpose.

DEVICE B
%%EDITORCONTENT%%gt; infinit-device --receive --user --name bob
Passphrase: ********
Received user identity for "bob".

NOTE: The pairing process may have expired on device A. If so, please try again and enter the passphrase on device B in order to retrieve your user identity before the counter runs down.

The next steps consist of fetching the resources that you previously pushed on the Hub: networks and volumes.

DEVICE B
%%EDITORCONTENT%%gt; infinit-network --fetch --as bob --name my-network
Fetched network "bob/my-network".
%%EDITORCONTENT%%gt; infinit-volume --fetch --as bob --name my-volume
Fetched volume "bob/my-volume".

Let’s link this device to the ‘my-network’ network you created on device A.

DEVICE B
%%EDITORCONTENT%%gt; infinit-network --link --as bob --name my-network
Linked device to network "bob/my-network".

Finally, the volume can be mounted on device B as simply as on device A:

DEVICE B
%%EDITORCONTENT%%gt; infinit-volume --mount --mountpoint ~/mnt-my-volume2/ --as bob --name my-volume --async --cache --publish
Fetch endpoints for "bob/my-network".
Running network “bob/my-network”.
Running volume "bob/my-volume".

It is now time to check if the file you created on device A is synchronized with device B:

DEVICE B
%%EDITORCONTENT%%gt; ls ~/mnt-my-volume2/
awesome.txt
%%EDITORCONTENT%%gt; cat ~/mnt-my-volume/awesome.txt
everything is

That’s it, you’ve created a filesystem that you quickly connected to with two devices, without having to go through a complicated administrative process.

4. Go Further

You can now invite other users to join the network, to contribute additional storage and/or share files and collaborate. Just keep in mind that the storage infrastructure presented in this guide is very sensitive to computers disconnecting, possibly rendering files inaccessible. Please take a look at the reference documentation to learn how to add additional storage, add more nodes, invite friends and configure the network to be more resilient.

Join our Facebook Group

Ask us something on Slack

Follow us on Twitter