Some time ago I heard about a cloud storage service from Rackspace called Mosso Cloud Files. You can store arbitrary files at this service and retrieve them at any time. To ease the the handling of the service, but mainly because I always wanted to write a FUSE module, I decided to create one called MossoFS. Mossofs is currently in pre-alpha phase. It is capable of mapping mosso's directory structure as well as retrieving arbitrary stored files from the service at the moment.
I have created a detailed project page for MossoFS. It explains the details of the service as well as details on the features currently supported by MossoFS. Furthermore detailed download and installation instructions are given.
Have fun with it.
What is MossoFS?
What is FUSE?
FUSE stands for "Filesystem in USErspace". It is a linux kernel filesystem driver, which acts as some kind of proxy between an arbitrary userspace program, using the fuse library, and the linux kernel filesystem architecture. Therefore it allows the development of filesystems which are running completely in userspace instead of kernelspace.
Who is mosso?
Mosso is a service belonging to the well established Rackspace company. It provides different kinds of cloud computing resources. One of them is Cloud Files, which is the service MossoFS has been written for.
What is Cloud Files?
Rackspace describes its service as follows:
Cloud Files is reliable, scalable and affordable web-based storage for backing up and archiving all your static content.
Kore Nordmann published an interesting blog post on howto backup svn repositories on a as needed basis to the mosso cloud. I am using a slightly modified version of his scripts by myself and it works like a charm.
Mosso provides a comprehensive REST based api to interact with the service, to store, manage and retrieve files.
To ease the use of data retrieval once it has been stored in the cloud I started the development of MossoFS. It is a simple FUSE based filesystem application which maps the contents and structure of your Cloud Files storage to a linux filesystem in a fully transparent way.
MossoFS is a readonly filesystem at the moment. It supports reading of your Cloud Files storage. Write-support is planned to be added in a future release.
Currently supported features
- Support of "Containers"
- Support of virtual directories as described in the Cloud Files documentation
- Full read support of stored files.
- Rudimental caching of retrieved metadata and container listings
Planned features for future releases
- Write support for files
- Creation/Deletion support for containers and virtual directories
- Support for extended metadata to store and retrieve informations like fileowner and filegroup
- Inteligent caching of retrieved files
Currently read operations on files are not cached at all. The exact amount of data requested by each read syscall is retrieved from the cloud and returned to the calling function. This implies the overhead of a full HTTP request everytime a chunk of data is read. If these chunks are quite small the performance impact might be huge.
This development release does not include proper caching strategies for file reading. Future releases are supposed to have this feature implemented.
Install from source
- FUSE library version 26 or later
- cURL library version 7.19 or later
- CMake version 2.6 or later
- gcc C compiler
Steps to compile and install
Download the source code of the current release:
Decompress the archive:
tar xvzf mossofs-latesttar.gz
Create a build directory and run cmake to configure:
cd mossofs-* mkdir build cd build cmake ../
Compile the source and link the executable:
Install the executable to /usr/local/bin/mossofs:
After finishing this easy steps you can call the mossofs executable by issueing mossofs in your terminal.
The usage of MossoFS is quite intuitive. The mossofs executable is called given your Mosso Files username followed by an @ symbol followed by the api key provided by Mosso as the first parameter and the path to mount the filesystem to as second parameter. :
mossofs jakob@123456789abcdef /mnt/mosso
After the command is issued a connection to Cloud Files is established and all connection parameters are negotiated. The container and file structure is then mapped to the provided directory. The base structure of this directory mapping might look something like this:
. |-- container1 | `-- some_file.txt `-- container2 |-- virtual_directory1 | `-- another_file.txt `-- and_yet_another_file.txt
You may interact with the files in this filesystem like you would with any other file on your computer. Currently the filesystem does only support read operations. For future releases write support is planned.
You may always retrieve the current trunk of the project by checking out its subversion repository:
svn co svn://svn.pureenergy.cc/mossofs