mfusepy update

[mxmlnkn]

Hello,

I am currently working a bit on type-hint support for mfusepy among others and saw that this project already depends on it and unfortunately does not pin the major version:

ninfs/pyproject.toml

Line 32 in 8a5a02c

"mfusepy>=1.0.0",

It should be mfusepy ~= 1.0 to avoid breaking your project when I relase version 2.0.

In particular, I was gonna remove the indirection through Operations.__call__ because I don't see the use of it and it looks not idiomatic. Decorators should get you the same results. In particular, this means that LoggingMixIn, which uses __call__ would be removed. Most of its functionality can also be achieved with -o debug although at a slightly different abstraction layer. Do you need the LoggingMixin functionality or did you just accidentally copy-paste it from the examples?

ninfs/ninfs/mount/romfs.py

Line 24 in 8a5a02c

class RomFSMount(LoggingMixIn, Operations):

[ihaveamac]

I do use it, however I copied it from fusepy originally because I wanted to suppress certain logging events (specifically access).

ninfs/ninfs/mount/_common.py

Line 61 in 8a5a02c

# custom LoggingMixIn modified from the original fusepy, to suppress certain entries.

If there's a better way to do this then I would like to hear about it for sure.

Unfortunately I wrote most of this code between 6 to 8 years ago so I can't say I remember my motivations, however I'm sure I did just copy it from an example back then.

But I know that I was using fusepy's logging because it was consistent across all platforms and let me peek into fusepy's inner workings (the objects it was getting and all that), while -o debug logging through libfuse / macFUSE / WinFSP was all different, especially the last one.

Also I'll pin the version to 1.0 now.

[mxmlnkn]

Ah, thank you for the feedback.

This also works, although it is slightly more complicated:

class LoggingMixIn:
    log = logging.getLogger('fuse.log-mixin')

    @staticmethod
    def _wrapper(op, func, path, *args):
        if op != 'access':
            LoggingMixIn.log.debug('-> %s %s %s', op, path, repr(args))
        ret = '[Unhandled Exception]'
        try:
            ret = func(path, *args)
            return ret
        except OSError as e:
            ret = str(e)
            raise
        finally:
            if op != 'access':
                LoggingMixIn.log.debug('<- %s %s', op, repr(ret))

    def __getattribute__(self, name):
        value = super().__getattribute__(name)
        if not name.startswith('_') and callable(value):
            return functools.partial(LoggingMixIn._wrapper, name, value)
        return value

My main motivation for removing the __call__ is because it obfuscates the code for humans, code linters, and type checkers. Performance is probably not an issue as I have tried to reduce indirections in the past and did not notice much of a speedup. Python seems to be well-optimized in that regard.

For now, I'll probably also leave at least a stub and a warning when __call__ exists so that this change does not break old code, only the logging. Although, the loopback example is also using the __call__ wrapper functionally by prefixing all paths centrally. I hope that this is not a widely used idiom but even then, I was able to rewrite it with decorators.

Using a logging decorator would it also make it clear and easy to show which implemented methods should be logged and which should not be, e.g.:

logger = logging.getLogger('fuse.log-decorator')

def log_method(method):
    """Simple decorator that adds log output for the decorated method."""

    def wrap_method_call(path, *args):
        op = method.__name__
        logger.debug('-> %s %s %s', op, path, repr(args))
        ret = '[Unhandled Exception]'
        try:
            ret = method(path, *args)
            return ret
        except OSError as e:
            ret = str(e)
            raise
        finally:
            logger.debug('<- %s %s', op, repr(ret))

    return wrap_method_call


class Memory(mfusepy.Operations):
    'Example memory filesystem. Supports only one level of files.'

    flag_nullpath_ok = True
    flag_nopath = True

    [...]

    # Not logged.
    def chown(self, path, uid, gid):
        self.files[path]['st_uid'] = uid
        self.files[path]['st_gid'] = gid

    @log_method
    def create(self, path, mode, fi=None):
        self.files[path] = {
            'st_mode': (stat.S_IFREG | mode),
            'st_nlink': 1,
            'st_size': 0,
            'st_ctime': time.time(),
            'st_mtime': time.time(),
            'st_atime': time.time(),
        }

        self.fd += 1
        self._opened[self.fd] = path
        return self.fd

    @log_method
    def getattr(self, path, fh=None):
        if fh is not None and fh in self._opened:
            path = self._opened[fh]
        if path not in self.files:
            raise mfusepy.FuseOSError(errno.ENOENT)
        return self.files[path]

[ihaveamac]

Cool, having a decorator for this would be better then.

[ihaveamac]

Just to be clear, are you going to put a decorator like this in mfusepy, or should I put it in my own code?

[mxmlnkn]

I'll add a simple logging decorator to mfusepy, and probably also an overrides decorator for various reasons. But, you can also implement one of your own for maximum control.

[ihaveamac]

I'm gonna open this up as a reminder that I should replace the custom LoggingMixIn.