Gunnar Wolf: Started a guide to writing FUSE filesystems in Python
As DebConf22 was coming to an end, in Kosovo, talking with Eeveelweezel they
invited me to prepare a talk to give for the Chicago Python User
Group. I replied that I m not really that much of a Python
guy But would think about a topic. Two years passed. I meet Eeveelweezel
again for DebConf24 in Busan, South Korea. And the topic came up again. I had
thought of some ideas, but none really pleased me. Again, I do write some Python
when needed, and I teach using Python, as it s the language I find my students
can best cope with. But delivering a talk to ChiPy?
On the other hand, I have long used a very simplistic and limited filesystem
I ve designed as an implementation project at class:
FIUnamFS
(for Facultad de Ingenier a, Universidad Nacional Aut noma de M xico : the
Engineering Faculty for Mexico s National University, where I teach. Sorry, the
link is in Spanish but you will find several implementations of it from the
students ). It is a toy filesystem, with as many bad characteristics you can
think of, but easy to specify and implement. It is based on contiguous file
allocation, has no support for sub-directories, and is often limited to the size
of a 1.44MB floppy disk.
As I give this filesystem as a project to my students (and not as a mere
homework), I always ask them to try and provide a good, polished, professional
interface, not just the simplistic menu I often get. And I tell them the best
possible interface would be if they provide support for FIUnamFS transparently,
usable by the user without thinking too much about it. With high probability,
that would mean: Use FUSE.
But, in the six semesters I ve used this project (with 30-40 students per
semester group), only one student has bitten the bullet and presented a FUSE
implementation.
Maybe this is because it s not easy to understand how to build a FUSE-based
filesystem from a high-level language such as Python? Yes, I ve seen several
implementation examples and even nice web pages (i.e. the examples shipped with
the
python-fuse
module Stavros
passthrough filesystem,
Dave Filesystem based upon, and further explaining,
Stavros ,
and several others) explaining how to provide basic functionality. I found a
particularly useful presentation by Matteo
Bertozzi presented
~15 years ago at PyCon4 But none of those is IMO followable enough by
itself. Also, most of them are very old (maybe the world is telling me
something that I refuse to understand?).
And of course, there isn t a single interface to work from. In Python only, we
can find
python-fuse,
Pyfuse,
Fusepy Where to start from?
So I setup to try and help.
Over the past couple of weeks, I have been slowly working on my own version, and
presenting it as a progressive set of tasks, adding filesystem calls, and
being careful to thoroughly document what I write (but maybe my documentation
ends up obfuscating the intent? I hope not and, read on, I ve provided some
remediation).
I registered a GitLab project for a hand-holding guide to writing FUSE-based
filesystems in Python. This
is a project where I present several working FUSE filesystem implementations,
some of them RAM-based, some passthrough-based, and I intend to add to this also
filesystems backed on pseudo-block-devices (for implementations such as my
FIUnamFS).
So far, I have added five stepwise pieces, starting from the barest possible
empty
filesystem,
and adding system calls (and functionality) until (so far) either a read-write
filesystem in RAM with basicstat()
support
or a read-only passthrough
filesystem.
I think providing fun or useful examples is also a good way to get students to
use what I m teaching, so I ve added some ideas I ve had: DNS
Filesystem,
on-the-fly markdown compiling
filesystem,
unzip
filesystem
and uncomment
filesystem.
They all provide something that could be seen as useful, in a way that s easy to
teach, in just some tens of lines. And, in case my comments/documentation are
too long to read, uncommentfs
will happily strip all comments and whitespace
automatically!
So I will be delivering my talk tomorrow (2024.10.10, 18:30 GMT-6) at
ChiPy (virtually). I am also presenting
this talk virtually at Jornadas Regionales de Software
Libre in Santa Fe,
Argentina, next week (virtually as well). And also in November, in person, at
nerdear.la, that will be held in Mexico City for the
first time.
Of course, I will also share this project with my students in the next couple of
weeks And hope it manages to lure them into implementing FUSE in Python. At
some point, I shall report!