contact Me

Use the form on the right to contact me.

You are welcome, to contact me regarding the topics of this page, my open source projects, or my work. Please use the contact form and leave a valid email address for me to respond to.

Thank you.

Egidestr. 9
44892 Bochum
Germany

/brain/dump

Random thoughts, bright ideas and interesting experiments. In short the ramblings of a fulltime nerd.

 

MossoFS - A first development snapshot released

Jakob Westhoff

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.

MossoFS

What is MossoFS?

MossoFS is a FUSE based filesystem which allows easy access to Cloud Files a service provided by mosso.

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.

FUSE Architecture

FUSE Architecture

The picture above has been derived from FUSESStructuressvg found on the wikimedia commons. It has originally been created by User:Sven and is licensed under CC-by-sa 3.0.

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?

Cloud Files is a service provided by mosso, which allows the user to store arbitrary data in a cloud. The user pays for the amount of data stored as well as the amount of traffic used.

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.

Supported Features

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

Known Limitations

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

Needed prerequisites

  • 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:

wget http://westhoffswelt.de/s/mossofs-latesttar.gz

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:

make

Install the executable to /usr/local/bin/mossofs:

make install

After finishing this easy steps you can call the mossofs executable by issueing mossofs in your terminal.

Usage Example

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.

Download

Bleeding Edge

You may always retrieve the current trunk of the project by checking out its subversion repository:

svn co svn://svn.pureenergy.cc/mossofs