Home
Reading
Searching
Subscribe
Sponsors
Statistics
Posting
Contact
Spam
Lists
Links
About
Hosting
Filtering
Features Download
Marketing
Archives
FAQ
Blog
 
Gmane
From: David Roundy <droundy <at> darcs.net>
Subject: haskell and fuse
Newsgroups: gmane.comp.lang.haskell.cafe
Date: Sunday 28th August 2005 13:03:59 UTC (over 12 years ago)
Hi all,

I worked for a bit while I was on vacation on a haskell interface to
libfuse, which I thought some of you might find interesting.  It is VERY
much a halted-work-in-progress, as I didn't get very far, and don't have
time to continue work on it.  You can get what there is with

darcs get http://abridgegame.org/repos/fuse_example

or browse at

http://abridgegame.org/cgi-bin/darcs.cgi/fuse_example

It's basically an attempt at combining a nice DarcsIO-style filesystem
interface on the haskell side (called FuseIO) with an interface to libfuse
(which is a library for creating filesystems from user space on linux).

The main file is (quite confusingly) called hello.hs, and you can see that
it basically just imports one function from FuseIO and one from Fuse.  It
tries to do the equivalent of `mount --bind dir1 dir2`, execpt that there's
no support for writing to files, or in general modifying the mounted
filesystem.

I had been thinking (although I now have no time for this) about the
possibility of implementing a caching distributed network filesystem which
had git as its backend.  Of course, I'd start with just a local filesystem
with git as the backend, which would be a bit stupid, although it'd have
the (very minor) advantage that identical files would be effectively
hard-linked as far as space use goes.

The FuseIO module itself might be rather interesting for other projects
(e.g. darcs), or even (one could imagine) as an alternative to the haskell
standard IO libraries for filesystem access, since it'd allow you to write
a function that is guaranteed by the typesystem to do nothing but read from
a filesystem, and it'd also allow writing polymorphic filesystem
access/modification code that could be applied outside the IO monad
(e.g. to Slurpies).  It would also allow one to use treat network objects
(e.g. http or ftp) as filesystems.

The Fuse side of things uses hsffig to generate an interface to libfuse,
and then translates the libfuse interface into FuseIO commands, so
implementing a new sort of filesystem (e.g. sshfs) would require modifying
neither FuseIO nor Fuse, but instead just implementing a new FS and
plugging it in.  But the Fuse interface is very limited, as is the FuseIO
interface (which doesn't support, for example, file permissions), so to
make a real useful filesystem would require considerable extension of both
modules.
-- 
David Roundy
http://www.darcs.net
 
CD: 3ms