[ { "path": ".github/workflows/codespell.yml", "content": "# Codespell configuration is within pyproject.toml\n---\nname: Codespell\n\non:\n push:\n branches: [main]\n pull_request:\n branches: [main]\n\npermissions:\n contents: read\n\njobs:\n codespell:\n name: Check for spelling errors\n runs-on: ubuntu-latest\n\n steps:\n - name: Checkout\n uses: actions/checkout@v4\n - name: Codespell\n uses: codespell-project/actions-codespell@v2\n" }, { "path": ".github/workflows/test.yml", "content": "name: Test\n\non: [push]\n\nenv:\n FORCE_COLOR: 1\n\njobs:\n build:\n runs-on: ${{ matrix.os }}\n strategy:\n fail-fast: true\n matrix:\n python-version: [\"3.10\", \"3.11\", \"3.12\", \"3.13\", \"3.14\"]\n os: [ubuntu-24.04]\n\n steps:\n - uses: actions/checkout@v4\n with:\n # Retrieve some git history, which will hopefully include the last release tag\n # and enable us to generate better version numbers.\n fetch-depth: 256\n\n - name: Install uv\n uses: astral-sh/setup-uv@v6\n with:\n enable-cache: true\n python-version: ${{ matrix.python-version }}\n\n - name: Install Linux dependencies\n run: |\n sudo apt-get update\n sudo apt-get install -y libattr1-dev libfuse3-dev fuse3 pkg-config gcc\n\n - name: Build\n run: uv sync --locked\n\n - name: Lint (ruff)\n run: uv run ruff check\n\n - name: Lint (format)\n run: uv run ruff format --diff\n\n - name: Type check (mypy)\n run: uv run mypy .\n\n - name: Type check (pyright)\n run: uv run pyright\n\n - name: Run tests\n run: uv run pytest -v -rs test/\n\n - name: Build docs\n run: uv run sphinx-build -b html rst doc/html\n" }, { "path": ".gitignore", "content": "MANIFEST\nbuild/\ndist/\ndoc/html/\ndoc/doctrees/\nsrc/pyfuse3/__init__.c\nsrc/pyfuse3/__init__*.so\nsrc/*.so\nsrc/pyfuse3.c\ntest/.cache/\n__pycache__\ntest/.pytest_cache/\n*.egg-info\n*.pyc\n" }, { "path": ".readthedocs.yaml", "content": "# .readthedocs.yaml - Read the Docs configuration file.\n# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details.\n\nversion: 2\n\nbuild:\n os: ubuntu-22.04\n tools:\n python: \"3.11\"\n jobs:\n post_checkout:\n # Retrieve some git history, which will hopefully include the last release tag\n # and enable us to generate better version numbers.\n - git fetch --depth=256\n apt_packages:\n - build-essential\n - pkg-config\n - libfuse3-dev\n\npython:\n install:\n - method: pip\n path: .\n\nsphinx:\n configuration: rst/conf.py\n" }, { "path": "Changes.rst", "content": "===========\n Changelog\n===========\n\n.. currentmodule:: pyfuse3\n\npyfuse 3.4.2 (2026-01-06)\n=========================\n\n* Removed the `pyfuse3_asyncio` module. This has been renamed to\n `pyfuse3.asyncio` for quite some time.\n\n* Fixed a test failure in test_examples.py\n\n* Many internal changes, modernizing build process and adding more\n type annotations.\n\nRelease 3.4.1 (2025-12-22)\n==========================\n\n* Cythonized with latest Cython 3.2.3.\n\n* CI: also test on Python 3.14, on Ubuntu 24.04.\n\n* asyncio:\n\n - use .run and .get_running_loop, #106.\n - replace deprecated Future() with create_future; fix lazy trio.Lock init.\n\n* use SPDX license identifier, #107\n\n* fix LICENSE text: LGPL v2.1, #102\n\n\nRelease 3.4.0 (2024-08-28)\n==========================\n\n* Cythonized with latest Cython 3.0.11 to support Python 3.13.\n\n* CI: also test python 3.13, run mypy.\n\n* Move ``_pyfuse3`` to ``pyfuse3._pyfuse3`` and add a compatibility wrapper\n for the old name.\n\n* Move ``pyfuse3_asyncio`` to ``pyfuse3.asyncio`` and add a compatibility\n wrapper for the old name.\n\n* Add `bytes` subclass `XAttrNameT` as the type of extended attribute names.\n\n* Various fixes to type annotations.\n\n* Add ``py.typed`` marker to enable external use of type annotations.\n\n\nRelease 3.3.0 (2023-08-06)\n==========================\n\n* Note: This is the first pyfuse3 release compatible with Cython 3.0.0 release.\n Cython 0.29.x is also still supported.\n\n* Cythonized with latest Cython 3.0.0.\n\n* Drop Python 3.6 and 3.7 support and testing, #71.\n\n* CI: also test python 3.12. test on cython 0.29 and cython 3.0.\n\n* Tell Cython that callbacks may raise exceptions, #80.\n\n* Fix lookup in examples/hello.py, similar to #16.\n\n* Misc. CI, testing, build and sphinx related fixes.\n\n\n\n\n\nRelease 3.2.3 (2023-05-09)\n==========================\n\n* cythonize with latest Cython 0.29.34 (brings Python 3.12 support)\n\n* add a minimal pyproject.toml, require setuptools\n\n* tests: fix integer overflow on 32-bit arches, fixes #47\n\n* test: Use shutil.which() instead of external which(1) program\n\n* setup.py: catch more generic OSError when searching Cython, fixes #63\n\n* setup.py: require Cython >= 0.29\n\n* fix basedir computation in setup.py (fix pip install -e .)\n\n* use sphinx < 6.0 due to compatibility issues with more recent versions\n\n\nRelease 3.2.2 (2022-09-28)\n==========================\n\n* remove support for python 3.5 (broken, out of support by python devs)\n\n* cythonize with latest Cython 0.29.x (brings Python 3.11 support)\n\n* use github actions for CI, remove travis-ci\n\n* update README: minimal maintenance, not developed\n\n* update setup.py with tested python versions\n\n* examples/tmpfs.py: work around strange kernel behaviour (calling SETATTR after\n UNLINK of a (not open) file): respond with ENOENT instead of crashing.\n\n\nRelease 3.2.1 (2021-09-17)\n==========================\n\n* Add type annotations\n\n* Passing a XATTR_CREATE or XATTR_REPLACE to `setxattr` is now working\n correctly.\n\nRelease 3.2.0 (2020-12-30)\n==========================\n\n* Fix long-standing rounding error in file date handling when the nanosecond\n part of file dates were > 999999500.\n\n* There is a new `pyfuse3.terminate()` function to gracefully end the\n main loop.\n\n\nRelease 3.1.1 (2020-10-06)\n==========================\n\n* No source changes. Regenerated Cython files with Cython 0.29.21 for Python 3.9\n compatibility.\n\n\nRelease 3.1.0 (2020-05-31)\n==========================\n\n* Made compatible with newest Trio module.\n\n\nRelease 3.0.0 (2020-05-08)\n==========================\n\n* Changed `~Operations.create` handler to return a `FileInfo` struct to allow\n for modification of certain kernel file attributes, e.g. ``direct_io``.\n\n Note that this change breaks backwards compatibility, code that depends\n on the old behavior needs to be changed.\n\n\nRelease 2.0.0\n=============\n\n* Changed `~Operations.open` handler to return the new `FileInfo` struct to\n allow for modification of certain kernel file attributes, e.g. ``direct_io``.\n\n Note that this change breaks backwards compatibility, code that depends on the old\n behavior needs to be changed.\n\nRelease 1.3.1 (2019-07-17)\n==========================\n\n* Fixed a bug in the :file:`hello_asyncio.py` example.\n\nRelease 1.3 (2019-06-02)\n========================\n\n* Fixed a bug in the :file:`tmpfs.py` and :file:`passthroughfs.py` example\n file systems (so rename operations no longer fail).\n\nRelease 1.2 (2018-12-22)\n========================\n\n* Clarified that `invalidate_inode` may block in some circumstances.\n* Added support for using the asyncio module instead of Trio.\n\nRelease 1.1 (2018-11-02)\n========================\n\n* Fixed :file:`examples/passthroughfs.py` - was not handling readdir()\n correctly.\n* `invalidate_entry_async` now accepts an additional *ignore_enoent*\n parameter. When this is set, no errors are logged if the kernel is\n not actually aware of the entry that should have been removed.\n\n\nRelease 1.0 (2018-10-08)\n========================\n\n* Added a new `syncfs` function.\n\n\nRelease 0.9 (2018-09-27)\n========================\n\n* First release\n* pyfuse3 was forked from python-llfuse - thanks for all the work!\n* If you need compatibility with Python 2.x or libfuse 2.x, you may\n want to take a look at python-llfuse instead.\n" }, { "path": "Include/fuse_common.pxd", "content": "'''\nfuse_common.pxd\n\nThis file contains Cython definitions for fuse_common.h\n\nCopyright © 2010 Nikolaus Rath \n\nThis file is part of pyfuse3. This work may be distributed under\nthe terms of the GNU LGPL.\n'''\n\nfrom fuse_opt cimport *\nfrom posix.types cimport off_t\nfrom libc.stdint cimport uint64_t\n\n# Based on fuse sources, revision tag fuse_2_9_4\ncdef extern from * nogil: # fuse_common.h should not be included\n\n struct fuse_file_info:\n int flags\n unsigned int direct_io\n unsigned int keep_cache\n unsigned int nonseekable\n uint64_t fh\n uint64_t lock_owner\n\n struct fuse_conn_info:\n unsigned proto_major\n unsigned proto_minor\n unsigned max_write\n unsigned max_read\n unsigned max_readahead\n unsigned capable\n unsigned want\n unsigned max_background\n unsigned congestion_threshold\n unsigned time_gran\n\n struct fuse_session:\n pass\n\n struct fuse_chan:\n pass\n\n struct fuse_pollhandle:\n pass\n\n void fuse_pollhandle_destroy(fuse_pollhandle *ph)\n\n struct fuse_loop_config:\n int clone_fd\n unsigned max_idle_threads\n\n # Capability bits for fuse_conn_info.{capable,want}\n enum:\n FUSE_CAP_ASYNC_READ\n FUSE_CAP_POSIX_LOCKS\n FUSE_CAP_ATOMIC_O_TRUNC\n FUSE_CAP_EXPORT_SUPPORT\n FUSE_CAP_DONT_MASK\n FUSE_CAP_SPLICE_WRITE\n FUSE_CAP_SPLICE_MOVE\n FUSE_CAP_SPLICE_READ\n FUSE_CAP_FLOCK_LOCKS\n FUSE_CAP_IOCTL_DIR\n FUSE_CAP_AUTO_INVAL_DATA\n FUSE_CAP_READDIRPLUS\n FUSE_CAP_READDIRPLUS_AUTO\n FUSE_CAP_ASYNC_DIO\n FUSE_CAP_WRITEBACK_CACHE\n FUSE_CAP_NO_OPEN_SUPPORT\n FUSE_CAP_PARALLEL_DIROPS\n FUSE_CAP_POSIX_ACL\n FUSE_CAP_HANDLE_KILLPRIV\n\n int fuse_set_signal_handlers(fuse_session *se)\n void fuse_remove_signal_handlers(fuse_session *se)\n\n # fuse_common.h declares these as enums, but they are\n # actually flags (i.e., FUSE_BUF_IS_FD|FUSE_BUF_FD_SEEK)\n # is a valid variable. Therefore, we declare the type\n # as integer instead.\n ctypedef int fuse_buf_flags\n enum:\n FUSE_BUF_IS_FD\n FUSE_BUF_FD_SEEK\n FUSE_BUF_FD_RETRY\n\n ctypedef int fuse_buf_copy_flags\n enum:\n FUSE_BUF_NO_SPLICE\n FUSE_BUF_FORCE_SPLICE\n FUSE_BUF_SPLICE_MOVE\n FUSE_BUF_SPLICE_NONBLOCK\n\n struct fuse_buf:\n size_t size\n fuse_buf_flags flags\n void *mem\n int fd\n off_t pos\n\n struct fuse_bufvec:\n size_t count\n size_t idx\n size_t off\n fuse_buf buf[1]\n\n size_t fuse_buf_size(fuse_bufvec *bufv)\n ssize_t fuse_buf_copy(fuse_bufvec *dst, fuse_bufvec *src,\n fuse_buf_copy_flags flags)\n" }, { "path": "Include/fuse_lowlevel.pxd", "content": "'''\nfuse_lowlevel.pxd\n\nThis file contains Cython definitions for fuse_lowlevel.h\n\nCopyright © 2010 Nikolaus Rath \n\nThis file is part of pyfuse3. This work may be distributed under\nthe terms of the GNU LGPL.\n'''\n\nfrom fuse_common cimport *\nfrom posix.stat cimport *\nfrom posix.types cimport *\nfrom libc_extra cimport statvfs\nfrom libc.stdlib cimport const_char\nfrom libc.stdint cimport uint32_t\n\n# Based on fuse sources, revision tag fuse-3.2.6\ncdef extern from \"\" nogil:\n enum:\n FUSE_ROOT_ID\n\n ctypedef unsigned fuse_ino_t\n ctypedef struct fuse_req:\n pass\n ctypedef fuse_req* fuse_req_t\n\n struct fuse_entry_param:\n fuse_ino_t ino\n uint64_t generation\n struct_stat attr\n double attr_timeout\n double entry_timeout\n\n struct fuse_ctx:\n uid_t uid\n gid_t gid\n pid_t pid\n mode_t umask\n\n struct fuse_forget_data:\n fuse_ino_t ino\n uint64_t nlookup\n\n ctypedef fuse_ctx const_fuse_ctx \"const struct fuse_ctx\"\n int FUSE_SET_ATTR_MODE\n int FUSE_SET_ATTR_UID\n int FUSE_SET_ATTR_GID\n int FUSE_SET_ATTR_SIZE\n int FUSE_SET_ATTR_ATIME\n int FUSE_SET_ATTR_MTIME\n int FUSE_SET_ATTR_ATIME_NOW\n int FUSE_SET_ATTR_MTIME_NOW\n int FUSE_SET_ATTR_CTIME\n\n # Request handlers\n # We allow these functions to raise exceptions because we will catch them\n # when checking exception status on return from fuse_session_process_buf().\n struct fuse_lowlevel_ops:\n void (*init) (void *userdata, fuse_conn_info *conn) except *\n void (*destroy) (void *userdata) except *\n void (*lookup) (fuse_req_t req, fuse_ino_t parent, const_char *name) except *\n void (*forget) (fuse_req_t req, fuse_ino_t ino, uint64_t nlookup) except *\n void (*getattr) (fuse_req_t req, fuse_ino_t ino,\n fuse_file_info *fi) except *\n void (*setattr) (fuse_req_t req, fuse_ino_t ino, struct_stat *attr,\n int to_set, fuse_file_info *fi) except *\n void (*readlink) (fuse_req_t req, fuse_ino_t ino) except *\n void (*mknod) (fuse_req_t req, fuse_ino_t parent, const_char *name,\n mode_t mode, dev_t rdev) except *\n void (*mkdir) (fuse_req_t req, fuse_ino_t parent, const_char *name,\n mode_t mode) except *\n void (*unlink) (fuse_req_t req, fuse_ino_t parent, const_char *name) except *\n void (*rmdir) (fuse_req_t req, fuse_ino_t parent, const_char *name) except *\n void (*symlink) (fuse_req_t req, const_char *link, fuse_ino_t parent,\n const_char *name) except *\n void (*rename) (fuse_req_t req, fuse_ino_t parent, const_char *name,\n fuse_ino_t newparent, const_char *newname, unsigned flags) except *\n void (*link) (fuse_req_t req, fuse_ino_t ino, fuse_ino_t newparent,\n const_char *newname) except *\n void (*open) (fuse_req_t req, fuse_ino_t ino,\n fuse_file_info *fi) except *\n void (*read) (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off,\n fuse_file_info *fi) except *\n void (*write) (fuse_req_t req, fuse_ino_t ino, const_char *buf,\n size_t size, off_t off, fuse_file_info *fi) except *\n void (*flush) (fuse_req_t req, fuse_ino_t ino,\n fuse_file_info *fi) except *\n void (*release) (fuse_req_t req, fuse_ino_t ino,\n fuse_file_info *fi) except *\n void (*fsync) (fuse_req_t req, fuse_ino_t ino, int datasync,\n fuse_file_info *fi) except *\n void (*opendir) (fuse_req_t req, fuse_ino_t ino,\n fuse_file_info *fi) except *\n void (*readdir) (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off,\n fuse_file_info *fi) except *\n void (*releasedir) (fuse_req_t req, fuse_ino_t ino,\n fuse_file_info *fi) except *\n void (*fsyncdir) (fuse_req_t req, fuse_ino_t ino, int datasync,\n fuse_file_info *fi) except *\n void (*statfs) (fuse_req_t req, fuse_ino_t ino) except *\n void (*setxattr) (fuse_req_t req, fuse_ino_t ino, const_char *name,\n const_char *value, size_t size, int flags) except *\n void (*getxattr) (fuse_req_t req, fuse_ino_t ino, const_char *name,\n size_t size) except *\n void (*listxattr) (fuse_req_t req, fuse_ino_t ino, size_t size) except *\n void (*removexattr) (fuse_req_t req, fuse_ino_t ino, const_char *name) except *\n void (*access) (fuse_req_t req, fuse_ino_t ino, int mask) except *\n void (*create) (fuse_req_t req, fuse_ino_t parent, const_char *name,\n mode_t mode, fuse_file_info *fi) except *\n void (*write_buf) (fuse_req_t req, fuse_ino_t ino, fuse_bufvec *bufv,\n off_t off, fuse_file_info *fi) except *\n void (*retrieve_reply) (fuse_req_t req, void *cookie, fuse_ino_t ino,\n off_t offset, fuse_bufvec *bufv) except *\n void (*forget_multi) (fuse_req_t req, size_t count,\n fuse_forget_data *forgets) except *\n void (*fallocate) (fuse_req_t req, fuse_ino_t ino, int mode,\n off_t offset, off_t length, fuse_file_info *fi) except *\n void (*readdirplus) (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off,\n fuse_file_info *fi) except *\n void (*poll) (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi,\n fuse_pollhandle *ph) except *\n\n\n # Reply functions\n int fuse_reply_err(fuse_req_t req, int err)\n void fuse_reply_none(fuse_req_t req)\n int fuse_reply_entry(fuse_req_t req, fuse_entry_param *e)\n int fuse_reply_create(fuse_req_t req, fuse_entry_param *e,\n fuse_file_info *fi)\n int fuse_reply_attr(fuse_req_t req, struct_stat *attr,\n double attr_timeout)\n int fuse_reply_readlink(fuse_req_t req, const_char *link)\n int fuse_reply_open(fuse_req_t req, fuse_file_info *fi)\n int fuse_reply_write(fuse_req_t req, size_t count)\n int fuse_reply_buf(fuse_req_t req, const_char *buf, size_t size)\n int fuse_reply_data(fuse_req_t req, fuse_bufvec *bufv,\n fuse_buf_copy_flags flags)\n int fuse_reply_statfs(fuse_req_t req, statvfs *stbuf)\n int fuse_reply_xattr(fuse_req_t req, size_t count)\n int fuse_reply_poll(fuse_req_t req, unsigned revents)\n\n size_t fuse_add_direntry(fuse_req_t req, const_char *buf, size_t bufsize,\n const_char *name, struct_stat *stbuf,\n off_t off)\n size_t fuse_add_direntry_plus(fuse_req_t req, char *buf, size_t bufsize,\n char *name, fuse_entry_param *e, off_t off)\n\n # Notification\n int fuse_lowlevel_notify_inval_inode(fuse_session *se, fuse_ino_t ino,\n off_t off, off_t len)\n int fuse_lowlevel_notify_inval_entry(fuse_session *se, fuse_ino_t parent,\n const_char *name, size_t namelen)\n int fuse_lowlevel_notify_delete(fuse_session *se, fuse_ino_t parent,\n fuse_ino_t child, const_char *name,\n size_t namelen)\n int fuse_lowlevel_notify_store(fuse_session *se, fuse_ino_t ino,\n off_t offset, fuse_bufvec *bufv,\n fuse_buf_copy_flags flags)\n int fuse_lowlevel_notify_retrieve(fuse_session *se, fuse_ino_t ino,\n size_t size, off_t offset, void *cookie)\n int fuse_lowlevel_notify_poll(fuse_pollhandle *ph)\n\n # Utility functions\n void *fuse_req_userdata(fuse_req_t req)\n fuse_ctx *fuse_req_ctx(fuse_req_t req)\n int fuse_req_getgroups(fuse_req_t req, size_t size, gid_t list[])\n\n\n # Inquiry functions\n void fuse_lowlevel_version()\n void fuse_lowlevel_help()\n\n # Filesystem setup & teardown\n fuse_session *fuse_session_new(fuse_args *args, fuse_lowlevel_ops *op,\n size_t op_size, void *userdata)\n int fuse_session_mount(fuse_session *se, char *mountpoint)\n int fuse_session_loop(fuse_session *se)\n int fuse_session_loop_mt(fuse_session *se, fuse_loop_config *config);\n void fuse_session_exit(fuse_session *se)\n void fuse_session_reset(fuse_session *se)\n bint fuse_session_exited(fuse_session *se)\n void fuse_session_unmount(fuse_session *se)\n void fuse_session_destroy(fuse_session *se)\n\n # Custom event loop support\n int fuse_session_fd(fuse_session *se)\n int fuse_session_receive_buf(fuse_session *se, fuse_buf *buf)\n void fuse_session_process_buf(fuse_session *se, fuse_buf *buf) except *\n" }, { "path": "Include/fuse_opt.pxd", "content": "'''\nfuse_opt.pxd\n\nThis file contains Cython definitions for fuse_opt.h\n\nCopyright © 2010 Nikolaus Rath \n\nThis file is part of pyfuse3. This work may be distributed under\nthe terms of the GNU LGPL.\n'''\n\n\n# Based on fuse sources, revision tag fuse_2_8_3\ncdef extern from \"\" nogil:\n struct fuse_args:\n int argc\n char **argv\n int allocated\n" }, { "path": "Include/libc_extra.pxd", "content": "'''\nlibc_extra.pxd\n\nThis file contains Cython definitions libc functions that are not included in\nthe pxd files shipped with Cython.\n\nCopyright © 2010 Nikolaus Rath \n\nThis file is part of pyfuse3. This work may be distributed under\nthe terms of the GNU LGPL.\n'''\n\nfrom posix.time cimport timespec\n\ncdef extern from \"\" nogil:\n ctypedef struct DIR:\n pass\n cdef struct dirent:\n char* d_name\n\n dirent* readdir(DIR* dirp)\n int readdir_r(DIR *dirp, dirent *entry, dirent **result)\n\ncdef extern from \"\" nogil:\n DIR *opendir(char *name)\n int closedir(DIR* dirp)\n\ncdef extern from \"\" nogil:\n ctypedef int fsblkcnt_t\n ctypedef int fsfilcnt_t\n\n struct statvfs:\n unsigned long f_bsize\n unsigned long f_frsize\n fsblkcnt_t f_blocks\n fsblkcnt_t f_bfree\n fsblkcnt_t f_bavail\n fsfilcnt_t f_files\n fsfilcnt_t f_ffree\n fsfilcnt_t f_favail\n unsigned long f_namemax\n\ncdef extern from \"xattr.h\" nogil:\n int setxattr_p (char *path, char *name,\n void *value, int size, int namespace)\n\n ssize_t getxattr_p (char *path, char *name,\n void *value, int size, int namespace)\n\n enum:\n EXTATTR_NAMESPACE_SYSTEM\n EXTATTR_NAMESPACE_USER\n XATTR_CREATE\n XATTR_REPLACE\n XATTR_NOFOLLOW\n XATTR_NODEFAULT\n XATTR_NOSECURITY\n\n\ncdef extern from \"gettime.h\" nogil:\n int gettime_realtime(timespec *tp)\n\ncdef extern from \"\" nogil:\n int syncfs(int fd)\n" }, { "path": "LICENSE", "content": " GNU LESSER GENERAL PUBLIC LICENSE\n Version 2.1, February 1999\n\n Copyright (C) 1991, 1999 Free Software Foundation, Inc.\n \n Everyone is permitted to copy and distribute verbatim copies\n of this license document, but changing it is not allowed.\n\n[This is the first released version of the Lesser GPL. It also counts\n as the successor of the GNU Library Public License, version 2, hence\n the version number 2.1.]\n\n Preamble\n\n The licenses for most software are designed to take away your\nfreedom to share and change it. By contrast, the GNU General Public\nLicenses are intended to guarantee your freedom to share and change\nfree software--to make sure the software is free for all its users.\n\n This license, the Lesser General Public License, applies to some\nspecially designated software packages--typically libraries--of the\nFree Software Foundation and other authors who decide to use it. You\ncan use it too, but we suggest you first think carefully about whether\nthis license or the ordinary General Public License is the better\nstrategy to use in any particular case, based on the explanations below.\n\n When we speak of free software, we are referring to freedom of use,\nnot price. Our General Public Licenses are designed to make sure that\nyou have the freedom to distribute copies of free software (and charge\nfor this service if you wish); that you receive source code or can get\nit if you want it; that you can change the software and use pieces of\nit in new free programs; and that you are informed that you can do\nthese things.\n\n To protect your rights, we need to make restrictions that forbid\ndistributors to deny you these rights or to ask you to surrender these\nrights. These restrictions translate to certain responsibilities for\nyou if you distribute copies of the library or if you modify it.\n\n For example, if you distribute copies of the library, whether gratis\nor for a fee, you must give the recipients all the rights that we gave\nyou. You must make sure that they, too, receive or can get the source\ncode. If you link other code with the library, you must provide\ncomplete object files to the recipients, so that they can relink them\nwith the library after making changes to the library and recompiling\nit. And you must show them these terms so they know their rights.\n\n We protect your rights with a two-step method: (1) we copyright the\nlibrary, and (2) we offer you this license, which gives you legal\npermission to copy, distribute and/or modify the library.\n\n To protect each distributor, we want to make it very clear that\nthere is no warranty for the free library. Also, if the library is\nmodified by someone else and passed on, the recipients should know\nthat what they have is not the original version, so that the original\nauthor's reputation will not be affected by problems that might be\nintroduced by others.\n\n Finally, software patents pose a constant threat to the existence of\nany free program. We wish to make sure that a company cannot\neffectively restrict the users of a free program by obtaining a\nrestrictive license from a patent holder. Therefore, we insist that\nany patent license obtained for a version of the library must be\nconsistent with the full freedom of use specified in this license.\n\n Most GNU software, including some libraries, is covered by the\nordinary GNU General Public License. This license, the GNU Lesser\nGeneral Public License, applies to certain designated libraries, and\nis quite different from the ordinary General Public License. We use\nthis license for certain libraries in order to permit linking those\nlibraries into non-free programs.\n\n When a program is linked with a library, whether statically or using\na shared library, the combination of the two is legally speaking a\ncombined work, a derivative of the original library. The ordinary\nGeneral Public License therefore permits such linking only if the\nentire combination fits its criteria of freedom. The Lesser General\nPublic License permits more lax criteria for linking other code with\nthe library.\n\n We call this license the \"Lesser\" General Public License because it\ndoes Less to protect the user's freedom than the ordinary General\nPublic License. It also provides other free software developers Less\nof an advantage over competing non-free programs. These disadvantages\nare the reason we use the ordinary General Public License for many\nlibraries. However, the Lesser license provides advantages in certain\nspecial circumstances.\n\n For example, on rare occasions, there may be a special need to\nencourage the widest possible use of a certain library, so that it becomes\na de-facto standard. To achieve this, non-free programs must be\nallowed to use the library. A more frequent case is that a free\nlibrary does the same job as widely used non-free libraries. In this\ncase, there is little to gain by limiting the free library to free\nsoftware only, so we use the Lesser General Public License.\n\n In other cases, permission to use a particular library in non-free\nprograms enables a greater number of people to use a large body of\nfree software. For example, permission to use the GNU C Library in\nnon-free programs enables many more people to use the whole GNU\noperating system, as well as its variant, the GNU/Linux operating\nsystem.\n\n Although the Lesser General Public License is Less protective of the\nusers' freedom, it does ensure that the user of a program that is\nlinked with the Library has the freedom and the wherewithal to run\nthat program using a modified version of the Library.\n\n The precise terms and conditions for copying, distribution and\nmodification follow. Pay close attention to the difference between a\n\"work based on the library\" and a \"work that uses the library\". The\nformer contains code derived from the library, whereas the latter must\nbe combined with the library in order to run.\n\n GNU LESSER GENERAL PUBLIC LICENSE\n TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION\n\n 0. This License Agreement applies to any software library or other\nprogram which contains a notice placed by the copyright holder or\nother authorized party saying it may be distributed under the terms of\nthis Lesser General Public License (also called \"this License\").\nEach licensee is addressed as \"you\".\n\n A \"library\" means a collection of software functions and/or data\nprepared so as to be conveniently linked with application programs\n(which use some of those functions and data) to form executables.\n\n The \"Library\", below, refers to any such software library or work\nwhich has been distributed under these terms. A \"work based on the\nLibrary\" means either the Library or any derivative work under\ncopyright law: that is to say, a work containing the Library or a\nportion of it, either verbatim or with modifications and/or translated\nstraightforwardly into another language. (Hereinafter, translation is\nincluded without limitation in the term \"modification\".)\n\n \"Source code\" for a work means the preferred form of the work for\nmaking modifications to it. For a library, complete source code means\nall the source code for all modules it contains, plus any associated\ninterface definition files, plus the scripts used to control compilation\nand installation of the library.\n\n Activities other than copying, distribution and modification are not\ncovered by this License; they are outside its scope. The act of\nrunning a program using the Library is not restricted, and output from\nsuch a program is covered only if its contents constitute a work based\non the Library (independent of the use of the Library in a tool for\nwriting it). Whether that is true depends on what the Library does\nand what the program that uses the Library does.\n\n 1. You may copy and distribute verbatim copies of the Library's\ncomplete source code as you receive it, in any medium, provided that\nyou conspicuously and appropriately publish on each copy an\nappropriate copyright notice and disclaimer of warranty; keep intact\nall the notices that refer to this License and to the absence of any\nwarranty; and distribute a copy of this License along with the\nLibrary.\n\n You may charge a fee for the physical act of transferring a copy,\nand you may at your option offer warranty protection in exchange for a\nfee.\n\n 2. You may modify your copy or copies of the Library or any portion\nof it, thus forming a work based on the Library, and copy and\ndistribute such modifications or work under the terms of Section 1\nabove, provided that you also meet all of these conditions:\n\n a) The modified work must itself be a software library.\n\n b) You must cause the files modified to carry prominent notices\n stating that you changed the files and the date of any change.\n\n c) You must cause the whole of the work to be licensed at no\n charge to all third parties under the terms of this License.\n\n d) If a facility in the modified Library refers to a function or a\n table of data to be supplied by an application program that uses\n the facility, other than as an argument passed when the facility\n is invoked, then you must make a good faith effort to ensure that,\n in the event an application does not supply such function or\n table, the facility still operates, and performs whatever part of\n its purpose remains meaningful.\n\n (For example, a function in a library to compute square roots has\n a purpose that is entirely well-defined independent of the\n application. Therefore, Subsection 2d requires that any\n application-supplied function or table used by this function must\n be optional: if the application does not supply it, the square\n root function must still compute square roots.)\n\nThese requirements apply to the modified work as a whole. If\nidentifiable sections of that work are not derived from the Library,\nand can be reasonably considered independent and separate works in\nthemselves, then this License, and its terms, do not apply to those\nsections when you distribute them as separate works. But when you\ndistribute the same sections as part of a whole which is a work based\non the Library, the distribution of the whole must be on the terms of\nthis License, whose permissions for other licensees extend to the\nentire whole, and thus to each and every part regardless of who wrote\nit.\n\nThus, it is not the intent of this section to claim rights or contest\nyour rights to work written entirely by you; rather, the intent is to\nexercise the right to control the distribution of derivative or\ncollective works based on the Library.\n\nIn addition, mere aggregation of another work not based on the Library\nwith the Library (or with a work based on the Library) on a volume of\na storage or distribution medium does not bring the other work under\nthe scope of this License.\n\n 3. You may opt to apply the terms of the ordinary GNU General Public\nLicense instead of this License to a given copy of the Library. To do\nthis, you must alter all the notices that refer to this License, so\nthat they refer to the ordinary GNU General Public License, version 2,\ninstead of to this License. (If a newer version than version 2 of the\nordinary GNU General Public License has appeared, then you can specify\nthat version instead if you wish.) Do not make any other change in\nthese notices.\n\n Once this change is made in a given copy, it is irreversible for\nthat copy, so the ordinary GNU General Public License applies to all\nsubsequent copies and derivative works made from that copy.\n\n This option is useful when you wish to copy part of the code of\nthe Library into a program that is not a library.\n\n 4. You may copy and distribute the Library (or a portion or\nderivative of it, under Section 2) in object code or executable form\nunder the terms of Sections 1 and 2 above provided that you accompany\nit with the complete corresponding machine-readable source code, which\nmust be distributed under the terms of Sections 1 and 2 above on a\nmedium customarily used for software interchange.\n\n If distribution of object code is made by offering access to copy\nfrom a designated place, then offering equivalent access to copy the\nsource code from the same place satisfies the requirement to\ndistribute the source code, even though third parties are not\ncompelled to copy the source along with the object code.\n\n 5. A program that contains no derivative of any portion of the\nLibrary, but is designed to work with the Library by being compiled or\nlinked with it, is called a \"work that uses the Library\". Such a\nwork, in isolation, is not a derivative work of the Library, and\ntherefore falls outside the scope of this License.\n\n However, linking a \"work that uses the Library\" with the Library\ncreates an executable that is a derivative of the Library (because it\ncontains portions of the Library), rather than a \"work that uses the\nlibrary\". The executable is therefore covered by this License.\nSection 6 states terms for distribution of such executables.\n\n When a \"work that uses the Library\" uses material from a header file\nthat is part of the Library, the object code for the work may be a\nderivative work of the Library even though the source code is not.\nWhether this is true is especially significant if the work can be\nlinked without the Library, or if the work is itself a library. The\nthreshold for this to be true is not precisely defined by law.\n\n If such an object file uses only numerical parameters, data\nstructure layouts and accessors, and small macros and small inline\nfunctions (ten lines or less in length), then the use of the object\nfile is unrestricted, regardless of whether it is legally a derivative\nwork. (Executables containing this object code plus portions of the\nLibrary will still fall under Section 6.)\n\n Otherwise, if the work is a derivative of the Library, you may\ndistribute the object code for the work under the terms of Section 6.\nAny executables containing that work also fall under Section 6,\nwhether or not they are linked directly with the Library itself.\n\n 6. As an exception to the Sections above, you may also combine or\nlink a \"work that uses the Library\" with the Library to produce a\nwork containing portions of the Library, and distribute that work\nunder terms of your choice, provided that the terms permit\nmodification of the work for the customer's own use and reverse\nengineering for debugging such modifications.\n\n You must give prominent notice with each copy of the work that the\nLibrary is used in it and that the Library and its use are covered by\nthis License. You must supply a copy of this License. If the work\nduring execution displays copyright notices, you must include the\ncopyright notice for the Library among them, as well as a reference\ndirecting the user to the copy of this License. Also, you must do one\nof these things:\n\n a) Accompany the work with the complete corresponding\n machine-readable source code for the Library including whatever\n changes were used in the work (which must be distributed under\n Sections 1 and 2 above); and, if the work is an executable linked\n with the Library, with the complete machine-readable \"work that\n uses the Library\", as object code and/or source code, so that the\n user can modify the Library and then relink to produce a modified\n executable containing the modified Library. (It is understood\n that the user who changes the contents of definitions files in the\n Library will not necessarily be able to recompile the application\n to use the modified definitions.)\n\n b) Use a suitable shared library mechanism for linking with the\n Library. A suitable mechanism is one that (1) uses at run time a\n copy of the library already present on the user's computer system,\n rather than copying library functions into the executable, and (2)\n will operate properly with a modified version of the library, if\n the user installs one, as long as the modified version is\n interface-compatible with the version that the work was made with.\n\n c) Accompany the work with a written offer, valid for at\n least three years, to give the same user the materials\n specified in Subsection 6a, above, for a charge no more\n than the cost of performing this distribution.\n\n d) If distribution of the work is made by offering access to copy\n from a designated place, offer equivalent access to copy the above\n specified materials from the same place.\n\n e) Verify that the user has already received a copy of these\n materials or that you have already sent this user a copy.\n\n For an executable, the required form of the \"work that uses the\nLibrary\" must include any data and utility programs needed for\nreproducing the executable from it. However, as a special exception,\nthe materials to be distributed need not include anything that is\nnormally distributed (in either source or binary form) with the major\ncomponents (compiler, kernel, and so on) of the operating system on\nwhich the executable runs, unless that component itself accompanies\nthe executable.\n\n It may happen that this requirement contradicts the license\nrestrictions of other proprietary libraries that do not normally\naccompany the operating system. Such a contradiction means you cannot\nuse both them and the Library together in an executable that you\ndistribute.\n\n 7. You may place library facilities that are a work based on the\nLibrary side-by-side in a single library together with other library\nfacilities not covered by this License, and distribute such a combined\nlibrary, provided that the separate distribution of the work based on\nthe Library and of the other library facilities is otherwise\npermitted, and provided that you do these two things:\n\n a) Accompany the combined library with a copy of the same work\n based on the Library, uncombined with any other library\n facilities. This must be distributed under the terms of the\n Sections above.\n\n b) Give prominent notice with the combined library of the fact\n that part of it is a work based on the Library, and explaining\n where to find the accompanying uncombined form of the same work.\n\n 8. You may not copy, modify, sublicense, link with, or distribute\nthe Library except as expressly provided under this License. Any\nattempt otherwise to copy, modify, sublicense, link with, or\ndistribute the Library is void, and will automatically terminate your\nrights under this License. However, parties who have received copies,\nor rights, from you under this License will not have their licenses\nterminated so long as such parties remain in full compliance.\n\n 9. You are not required to accept this License, since you have not\nsigned it. However, nothing else grants you permission to modify or\ndistribute the Library or its derivative works. These actions are\nprohibited by law if you do not accept this License. Therefore, by\nmodifying or distributing the Library (or any work based on the\nLibrary), you indicate your acceptance of this License to do so, and\nall its terms and conditions for copying, distributing or modifying\nthe Library or works based on it.\n\n 10. Each time you redistribute the Library (or any work based on the\nLibrary), the recipient automatically receives a license from the\noriginal licensor to copy, distribute, link with or modify the Library\nsubject to these terms and conditions. You may not impose any further\nrestrictions on the recipients' exercise of the rights granted herein.\nYou are not responsible for enforcing compliance by third parties with\nthis License.\n\n 11. If, as a consequence of a court judgment or allegation of patent\ninfringement or for any other reason (not limited to patent issues),\nconditions are imposed on you (whether by court order, agreement or\notherwise) that contradict the conditions of this License, they do not\nexcuse you from the conditions of this License. If you cannot\ndistribute so as to satisfy simultaneously your obligations under this\nLicense and any other pertinent obligations, then as a consequence you\nmay not distribute the Library at all. For example, if a patent\nlicense would not permit royalty-free redistribution of the Library by\nall those who receive copies directly or indirectly through you, then\nthe only way you could satisfy both it and this License would be to\nrefrain entirely from distribution of the Library.\n\nIf any portion of this section is held invalid or unenforceable under any\nparticular circumstance, the balance of the section is intended to apply,\nand the section as a whole is intended to apply in other circumstances.\n\nIt is not the purpose of this section to induce you to infringe any\npatents or other property right claims or to contest validity of any\nsuch claims; this section has the sole purpose of protecting the\nintegrity of the free software distribution system which is\nimplemented by public license practices. Many people have made\ngenerous contributions to the wide range of software distributed\nthrough that system in reliance on consistent application of that\nsystem; it is up to the author/donor to decide if he or she is willing\nto distribute software through any other system and a licensee cannot\nimpose that choice.\n\nThis section is intended to make thoroughly clear what is believed to\nbe a consequence of the rest of this License.\n\n 12. If the distribution and/or use of the Library is restricted in\ncertain countries either by patents or by copyrighted interfaces, the\noriginal copyright holder who places the Library under this License may add\nan explicit geographical distribution limitation excluding those countries,\nso that distribution is permitted only in or among countries not thus\nexcluded. In such case, this License incorporates the limitation as if\nwritten in the body of this License.\n\n 13. The Free Software Foundation may publish revised and/or new\nversions of the Lesser General Public License from time to time.\nSuch new versions will be similar in spirit to the present version,\nbut may differ in detail to address new problems or concerns.\n\nEach version is given a distinguishing version number. If the Library\nspecifies a version number of this License which applies to it and\n\"any later version\", you have the option of following the terms and\nconditions either of that version or of any later version published by\nthe Free Software Foundation. If the Library does not specify a\nlicense version number, you may choose any version ever published by\nthe Free Software Foundation.\n\n 14. If you wish to incorporate parts of the Library into other free\nprograms whose distribution conditions are incompatible with these,\nwrite to the author to ask for permission. For software which is\ncopyrighted by the Free Software Foundation, write to the Free\nSoftware Foundation; we sometimes make exceptions for this. Our\ndecision will be guided by the two goals of preserving the free status\nof all derivatives of our free software and of promoting the sharing\nand reuse of software generally.\n\n NO WARRANTY\n\n 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO\nWARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.\nEXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR\nOTHER PARTIES PROVIDE THE LIBRARY \"AS IS\" WITHOUT WARRANTY OF ANY\nKIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE\nIMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\nPURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE\nLIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME\nTHE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.\n\n 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN\nWRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY\nAND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU\nFOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR\nCONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE\nLIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING\nRENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A\nFAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF\nSUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH\nDAMAGES.\n\n END OF TERMS AND CONDITIONS\n\n How to Apply These Terms to Your New Libraries\n\n If you develop a new library, and you want it to be of the greatest\npossible use to the public, we recommend making it free software that\neveryone can redistribute and change. You can do so by permitting\nredistribution under these terms (or, alternatively, under the terms of the\nordinary General Public License).\n\n To apply these terms, attach the following notices to the library. It is\nsafest to attach them to the start of each source file to most effectively\nconvey the exclusion of warranty; and each file should have at least the\n\"copyright\" line and a pointer to where the full notice is found.\n\n \n Copyright (C) \n\n This library is free software; you can redistribute it and/or\n modify it under the terms of the GNU Lesser General Public\n License as published by the Free Software Foundation; either\n version 2.1 of the License, or (at your option) any later version.\n\n This library is distributed in the hope that it will be useful,\n but WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n Lesser General Public License for more details.\n\n You should have received a copy of the GNU Lesser General Public\n License along with this library; if not, see .\n\nAlso add information on how to contact you by electronic and paper mail.\n\nYou should also get your employer (if you work as a programmer) or your\nschool, if any, to sign a \"copyright disclaimer\" for the library, if\nnecessary. Here is a sample; alter the names:\n\n Yoyodyne, Inc., hereby disclaims all copyright interest in the\n library `Frob' (a library for tweaking knobs) written by James Random Hacker.\n\n , 1 April 1990\n Moe Ghoul, President of Vice\n\nThat's all there is to it! GNU LESSER GENERAL PUBLIC LICENSE\n Version 2.1, February 1999\n\n Copyright (C) 1991, 1999 Free Software Foundation, Inc.\n \n Everyone is permitted to copy and distribute verbatim copies\n of this license document, but changing it is not allowed.\n\n[This is the first released version of the Lesser GPL. It also counts\n as the successor of the GNU Library Public License, version 2, hence\n the version number 2.1.]\n\n Preamble\n\n The licenses for most software are designed to take away your\nfreedom to share and change it. By contrast, the GNU General Public\nLicenses are intended to guarantee your freedom to share and change\nfree software--to make sure the software is free for all its users.\n\n This license, the Lesser General Public License, applies to some\nspecially designated software packages--typically libraries--of the\nFree Software Foundation and other authors who decide to use it. You\ncan use it too, but we suggest you first think carefully about whether\nthis license or the ordinary General Public License is the better\nstrategy to use in any particular case, based on the explanations below.\n\n When we speak of free software, we are referring to freedom of use,\nnot price. Our General Public Licenses are designed to make sure that\nyou have the freedom to distribute copies of free software (and charge\nfor this service if you wish); that you receive source code or can get\nit if you want it; that you can change the software and use pieces of\nit in new free programs; and that you are informed that you can do\nthese things.\n\n To protect your rights, we need to make restrictions that forbid\ndistributors to deny you these rights or to ask you to surrender these\nrights. These restrictions translate to certain responsibilities for\nyou if you distribute copies of the library or if you modify it.\n\n For example, if you distribute copies of the library, whether gratis\nor for a fee, you must give the recipients all the rights that we gave\nyou. You must make sure that they, too, receive or can get the source\ncode. If you link other code with the library, you must provide\ncomplete object files to the recipients, so that they can relink them\nwith the library after making changes to the library and recompiling\nit. And you must show them these terms so they know their rights.\n\n We protect your rights with a two-step method: (1) we copyright the\nlibrary, and (2) we offer you this license, which gives you legal\npermission to copy, distribute and/or modify the library.\n\n To protect each distributor, we want to make it very clear that\nthere is no warranty for the free library. Also, if the library is\nmodified by someone else and passed on, the recipients should know\nthat what they have is not the original version, so that the original\nauthor's reputation will not be affected by problems that might be\nintroduced by others.\n\n Finally, software patents pose a constant threat to the existence of\nany free program. We wish to make sure that a company cannot\neffectively restrict the users of a free program by obtaining a\nrestrictive license from a patent holder. Therefore, we insist that\nany patent license obtained for a version of the library must be\nconsistent with the full freedom of use specified in this license.\n\n Most GNU software, including some libraries, is covered by the\nordinary GNU General Public License. This license, the GNU Lesser\nGeneral Public License, applies to certain designated libraries, and\nis quite different from the ordinary General Public License. We use\nthis license for certain libraries in order to permit linking those\nlibraries into non-free programs.\n\n When a program is linked with a library, whether statically or using\na shared library, the combination of the two is legally speaking a\ncombined work, a derivative of the original library. The ordinary\nGeneral Public License therefore permits such linking only if the\nentire combination fits its criteria of freedom. The Lesser General\nPublic License permits more lax criteria for linking other code with\nthe library.\n\n We call this license the \"Lesser\" General Public License because it\ndoes Less to protect the user's freedom than the ordinary General\nPublic License. It also provides other free software developers Less\nof an advantage over competing non-free programs. These disadvantages\nare the reason we use the ordinary General Public License for many\nlibraries. However, the Lesser license provides advantages in certain\nspecial circumstances.\n\n For example, on rare occasions, there may be a special need to\nencourage the widest possible use of a certain library, so that it becomes\na de-facto standard. To achieve this, non-free programs must be\nallowed to use the library. A more frequent case is that a free\nlibrary does the same job as widely used non-free libraries. In this\ncase, there is little to gain by limiting the free library to free\nsoftware only, so we use the Lesser General Public License.\n\n In other cases, permission to use a particular library in non-free\nprograms enables a greater number of people to use a large body of\nfree software. For example, permission to use the GNU C Library in\nnon-free programs enables many more people to use the whole GNU\noperating system, as well as its variant, the GNU/Linux operating\nsystem.\n\n Although the Lesser General Public License is Less protective of the\nusers' freedom, it does ensure that the user of a program that is\nlinked with the Library has the freedom and the wherewithal to run\nthat program using a modified version of the Library.\n\n The precise terms and conditions for copying, distribution and\nmodification follow. Pay close attention to the difference between a\n\"work based on the library\" and a \"work that uses the library\". The\nformer contains code derived from the library, whereas the latter must\nbe combined with the library in order to run.\n\n GNU LESSER GENERAL PUBLIC LICENSE\n TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION\n\n 0. This License Agreement applies to any software library or other\nprogram which contains a notice placed by the copyright holder or\nother authorized party saying it may be distributed under the terms of\nthis Lesser General Public License (also called \"this License\").\nEach licensee is addressed as \"you\".\n\n A \"library\" means a collection of software functions and/or data\nprepared so as to be conveniently linked with application programs\n(which use some of those functions and data) to form executables.\n\n The \"Library\", below, refers to any such software library or work\nwhich has been distributed under these terms. A \"work based on the\nLibrary\" means either the Library or any derivative work under\ncopyright law: that is to say, a work containing the Library or a\nportion of it, either verbatim or with modifications and/or translated\nstraightforwardly into another language. (Hereinafter, translation is\nincluded without limitation in the term \"modification\".)\n\n \"Source code\" for a work means the preferred form of the work for\nmaking modifications to it. For a library, complete source code means\nall the source code for all modules it contains, plus any associated\ninterface definition files, plus the scripts used to control compilation\nand installation of the library.\n\n Activities other than copying, distribution and modification are not\ncovered by this License; they are outside its scope. The act of\nrunning a program using the Library is not restricted, and output from\nsuch a program is covered only if its contents constitute a work based\non the Library (independent of the use of the Library in a tool for\nwriting it). Whether that is true depends on what the Library does\nand what the program that uses the Library does.\n\n 1. You may copy and distribute verbatim copies of the Library's\ncomplete source code as you receive it, in any medium, provided that\nyou conspicuously and appropriately publish on each copy an\nappropriate copyright notice and disclaimer of warranty; keep intact\nall the notices that refer to this License and to the absence of any\nwarranty; and distribute a copy of this License along with the\nLibrary.\n\n You may charge a fee for the physical act of transferring a copy,\nand you may at your option offer warranty protection in exchange for a\nfee.\n\n 2. You may modify your copy or copies of the Library or any portion\nof it, thus forming a work based on the Library, and copy and\ndistribute such modifications or work under the terms of Section 1\nabove, provided that you also meet all of these conditions:\n\n a) The modified work must itself be a software library.\n\n b) You must cause the files modified to carry prominent notices\n stating that you changed the files and the date of any change.\n\n c) You must cause the whole of the work to be licensed at no\n charge to all third parties under the terms of this License.\n\n d) If a facility in the modified Library refers to a function or a\n table of data to be supplied by an application program that uses\n the facility, other than as an argument passed when the facility\n is invoked, then you must make a good faith effort to ensure that,\n in the event an application does not supply such function or\n table, the facility still operates, and performs whatever part of\n its purpose remains meaningful.\n\n (For example, a function in a library to compute square roots has\n a purpose that is entirely well-defined independent of the\n application. Therefore, Subsection 2d requires that any\n application-supplied function or table used by this function must\n be optional: if the application does not supply it, the square\n root function must still compute square roots.)\n\nThese requirements apply to the modified work as a whole. If\nidentifiable sections of that work are not derived from the Library,\nand can be reasonably considered independent and separate works in\nthemselves, then this License, and its terms, do not apply to those\nsections when you distribute them as separate works. But when you\ndistribute the same sections as part of a whole which is a work based\non the Library, the distribution of the whole must be on the terms of\nthis License, whose permissions for other licensees extend to the\nentire whole, and thus to each and every part regardless of who wrote\nit.\n\nThus, it is not the intent of this section to claim rights or contest\nyour rights to work written entirely by you; rather, the intent is to\nexercise the right to control the distribution of derivative or\ncollective works based on the Library.\n\nIn addition, mere aggregation of another work not based on the Library\nwith the Library (or with a work based on the Library) on a volume of\na storage or distribution medium does not bring the other work under\nthe scope of this License.\n\n 3. You may opt to apply the terms of the ordinary GNU General Public\nLicense instead of this License to a given copy of the Library. To do\nthis, you must alter all the notices that refer to this License, so\nthat they refer to the ordinary GNU General Public License, version 2,\ninstead of to this License. (If a newer version than version 2 of the\nordinary GNU General Public License has appeared, then you can specify\nthat version instead if you wish.) Do not make any other change in\nthese notices.\n\n Once this change is made in a given copy, it is irreversible for\nthat copy, so the ordinary GNU General Public License applies to all\nsubsequent copies and derivative works made from that copy.\n\n This option is useful when you wish to copy part of the code of\nthe Library into a program that is not a library.\n\n 4. You may copy and distribute the Library (or a portion or\nderivative of it, under Section 2) in object code or executable form\nunder the terms of Sections 1 and 2 above provided that you accompany\nit with the complete corresponding machine-readable source code, which\nmust be distributed under the terms of Sections 1 and 2 above on a\nmedium customarily used for software interchange.\n\n If distribution of object code is made by offering access to copy\nfrom a designated place, then offering equivalent access to copy the\nsource code from the same place satisfies the requirement to\ndistribute the source code, even though third parties are not\ncompelled to copy the source along with the object code.\n\n 5. A program that contains no derivative of any portion of the\nLibrary, but is designed to work with the Library by being compiled or\nlinked with it, is called a \"work that uses the Library\". Such a\nwork, in isolation, is not a derivative work of the Library, and\ntherefore falls outside the scope of this License.\n\n However, linking a \"work that uses the Library\" with the Library\ncreates an executable that is a derivative of the Library (because it\ncontains portions of the Library), rather than a \"work that uses the\nlibrary\". The executable is therefore covered by this License.\nSection 6 states terms for distribution of such executables.\n\n When a \"work that uses the Library\" uses material from a header file\nthat is part of the Library, the object code for the work may be a\nderivative work of the Library even though the source code is not.\nWhether this is true is especially significant if the work can be\nlinked without the Library, or if the work is itself a library. The\nthreshold for this to be true is not precisely defined by law.\n\n If such an object file uses only numerical parameters, data\nstructure layouts and accessors, and small macros and small inline\nfunctions (ten lines or less in length), then the use of the object\nfile is unrestricted, regardless of whether it is legally a derivative\nwork. (Executables containing this object code plus portions of the\nLibrary will still fall under Section 6.)\n\n Otherwise, if the work is a derivative of the Library, you may\ndistribute the object code for the work under the terms of Section 6.\nAny executables containing that work also fall under Section 6,\nwhether or not they are linked directly with the Library itself.\n\n 6. As an exception to the Sections above, you may also combine or\nlink a \"work that uses the Library\" with the Library to produce a\nwork containing portions of the Library, and distribute that work\nunder terms of your choice, provided that the terms permit\nmodification of the work for the customer's own use and reverse\nengineering for debugging such modifications.\n\n You must give prominent notice with each copy of the work that the\nLibrary is used in it and that the Library and its use are covered by\nthis License. You must supply a copy of this License. If the work\nduring execution displays copyright notices, you must include the\ncopyright notice for the Library among them, as well as a reference\ndirecting the user to the copy of this License. Also, you must do one\nof these things:\n\n a) Accompany the work with the complete corresponding\n machine-readable source code for the Library including whatever\n changes were used in the work (which must be distributed under\n Sections 1 and 2 above); and, if the work is an executable linked\n with the Library, with the complete machine-readable \"work that\n uses the Library\", as object code and/or source code, so that the\n user can modify the Library and then relink to produce a modified\n executable containing the modified Library. (It is understood\n that the user who changes the contents of definitions files in the\n Library will not necessarily be able to recompile the application\n to use the modified definitions.)\n\n b) Use a suitable shared library mechanism for linking with the\n Library. A suitable mechanism is one that (1) uses at run time a\n copy of the library already present on the user's computer system,\n rather than copying library functions into the executable, and (2)\n will operate properly with a modified version of the library, if\n the user installs one, as long as the modified version is\n interface-compatible with the version that the work was made with.\n\n c) Accompany the work with a written offer, valid for at\n least three years, to give the same user the materials\n specified in Subsection 6a, above, for a charge no more\n than the cost of performing this distribution.\n\n d) If distribution of the work is made by offering access to copy\n from a designated place, offer equivalent access to copy the above\n specified materials from the same place.\n\n e) Verify that the user has already received a copy of these\n materials or that you have already sent this user a copy.\n\n For an executable, the required form of the \"work that uses the\nLibrary\" must include any data and utility programs needed for\nreproducing the executable from it. However, as a special exception,\nthe materials to be distributed need not include anything that is\nnormally distributed (in either source or binary form) with the major\ncomponents (compiler, kernel, and so on) of the operating system on\nwhich the executable runs, unless that component itself accompanies\nthe executable.\n\n It may happen that this requirement contradicts the license\nrestrictions of other proprietary libraries that do not normally\naccompany the operating system. Such a contradiction means you cannot\nuse both them and the Library together in an executable that you\ndistribute.\n\n 7. You may place library facilities that are a work based on the\nLibrary side-by-side in a single library together with other library\nfacilities not covered by this License, and distribute such a combined\nlibrary, provided that the separate distribution of the work based on\nthe Library and of the other library facilities is otherwise\npermitted, and provided that you do these two things:\n\n a) Accompany the combined library with a copy of the same work\n based on the Library, uncombined with any other library\n facilities. This must be distributed under the terms of the\n Sections above.\n\n b) Give prominent notice with the combined library of the fact\n that part of it is a work based on the Library, and explaining\n where to find the accompanying uncombined form of the same work.\n\n 8. You may not copy, modify, sublicense, link with, or distribute\nthe Library except as expressly provided under this License. Any\nattempt otherwise to copy, modify, sublicense, link with, or\ndistribute the Library is void, and will automatically terminate your\nrights under this License. However, parties who have received copies,\nor rights, from you under this License will not have their licenses\nterminated so long as such parties remain in full compliance.\n\n 9. You are not required to accept this License, since you have not\nsigned it. However, nothing else grants you permission to modify or\ndistribute the Library or its derivative works. These actions are\nprohibited by law if you do not accept this License. Therefore, by\nmodifying or distributing the Library (or any work based on the\nLibrary), you indicate your acceptance of this License to do so, and\nall its terms and conditions for copying, distributing or modifying\nthe Library or works based on it.\n\n 10. Each time you redistribute the Library (or any work based on the\nLibrary), the recipient automatically receives a license from the\noriginal licensor to copy, distribute, link with or modify the Library\nsubject to these terms and conditions. You may not impose any further\nrestrictions on the recipients' exercise of the rights granted herein.\nYou are not responsible for enforcing compliance by third parties with\nthis License.\n\n 11. If, as a consequence of a court judgment or allegation of patent\ninfringement or for any other reason (not limited to patent issues),\nconditions are imposed on you (whether by court order, agreement or\notherwise) that contradict the conditions of this License, they do not\nexcuse you from the conditions of this License. If you cannot\ndistribute so as to satisfy simultaneously your obligations under this\nLicense and any other pertinent obligations, then as a consequence you\nmay not distribute the Library at all. For example, if a patent\nlicense would not permit royalty-free redistribution of the Library by\nall those who receive copies directly or indirectly through you, then\nthe only way you could satisfy both it and this License would be to\nrefrain entirely from distribution of the Library.\n\nIf any portion of this section is held invalid or unenforceable under any\nparticular circumstance, the balance of the section is intended to apply,\nand the section as a whole is intended to apply in other circumstances.\n\nIt is not the purpose of this section to induce you to infringe any\npatents or other property right claims or to contest validity of any\nsuch claims; this section has the sole purpose of protecting the\nintegrity of the free software distribution system which is\nimplemented by public license practices. Many people have made\ngenerous contributions to the wide range of software distributed\nthrough that system in reliance on consistent application of that\nsystem; it is up to the author/donor to decide if he or she is willing\nto distribute software through any other system and a licensee cannot\nimpose that choice.\n\nThis section is intended to make thoroughly clear what is believed to\nbe a consequence of the rest of this License.\n\n 12. If the distribution and/or use of the Library is restricted in\ncertain countries either by patents or by copyrighted interfaces, the\noriginal copyright holder who places the Library under this License may add\nan explicit geographical distribution limitation excluding those countries,\nso that distribution is permitted only in or among countries not thus\nexcluded. In such case, this License incorporates the limitation as if\nwritten in the body of this License.\n\n 13. The Free Software Foundation may publish revised and/or new\nversions of the Lesser General Public License from time to time.\nSuch new versions will be similar in spirit to the present version,\nbut may differ in detail to address new problems or concerns.\n\nEach version is given a distinguishing version number. If the Library\nspecifies a version number of this License which applies to it and\n\"any later version\", you have the option of following the terms and\nconditions either of that version or of any later version published by\nthe Free Software Foundation. If the Library does not specify a\nlicense version number, you may choose any version ever published by\nthe Free Software Foundation.\n\n 14. If you wish to incorporate parts of the Library into other free\nprograms whose distribution conditions are incompatible with these,\nwrite to the author to ask for permission. For software which is\ncopyrighted by the Free Software Foundation, write to the Free\nSoftware Foundation; we sometimes make exceptions for this. Our\ndecision will be guided by the two goals of preserving the free status\nof all derivatives of our free software and of promoting the sharing\nand reuse of software generally.\n\n NO WARRANTY\n\n 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO\nWARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.\nEXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR\nOTHER PARTIES PROVIDE THE LIBRARY \"AS IS\" WITHOUT WARRANTY OF ANY\nKIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE\nIMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\nPURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE\nLIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME\nTHE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.\n\n 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN\nWRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY\nAND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU\nFOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR\nCONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE\nLIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING\nRENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A\nFAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF\nSUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH\nDAMAGES.\n\n END OF TERMS AND CONDITIONS\n\n How to Apply These Terms to Your New Libraries\n\n If you develop a new library, and you want it to be of the greatest\npossible use to the public, we recommend making it free software that\neveryone can redistribute and change. You can do so by permitting\nredistribution under these terms (or, alternatively, under the terms of the\nordinary General Public License).\n\n To apply these terms, attach the following notices to the library. It is\nsafest to attach them to the start of each source file to most effectively\nconvey the exclusion of warranty; and each file should have at least the\n\"copyright\" line and a pointer to where the full notice is found.\n\n \n Copyright (C) \n\n This library is free software; you can redistribute it and/or\n modify it under the terms of the GNU Lesser General Public\n License as published by the Free Software Foundation; either\n version 2.1 of the License, or (at your option) any later version.\n\n This library is distributed in the hope that it will be useful,\n but WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n Lesser General Public License for more details.\n\n You should have received a copy of the GNU Lesser General Public\n License along with this library; if not, see .\n\nAlso add information on how to contact you by electronic and paper mail.\n\nYou should also get your employer (if you work as a programmer) or your\nschool, if any, to sign a \"copyright disclaimer\" for the library, if\nnecessary. Here is a sample; alter the names:\n\n Yoyodyne, Inc., hereby disclaims all copyright interest in the\n library `Frob' (a library for tweaking knobs) written by James Random Hacker.\n\n , 1 April 1990\n Moe Ghoul, President of Vice\n\nThat's all there is to it!" }, { "path": "MANIFEST.in", "content": "include Changes.rst\ninclude LICENSE\ngraft doc/html\ngraft Include\ngraft examples\ngraft rst\ngraft util\ngraft test\nprune test/.cache\nprune .github\nexclude MANIFEST.in\nexclude .git*\nexclude .readthedocs.yaml\nrecursive-include src *.pyx *.pyi *.py *.pxi *.pxd *.c *.h\nglobal-exclude *.pyc\n" }, { "path": "README.rst", "content": "..\n NOTE: We cannot use sophisticated ReST syntax (like\n e.g. :file:`foo`) here because this isn't rendered correctly\n by PyPi.\n\n\nThe pyfuse3 Module\n==================\n\n.. start-intro\n\npyfuse3 is a set of Python 3 bindings for `libfuse 3`_. It provides an\nasynchronous API compatible with Trio_ and asyncio_, and enables you\nto easily write a full-featured Linux filesystem in Python.\n\npyfuse3 releases can be downloaded from PyPi_. The documentation\ncan be `read online`__ and is also included in the ``doc/html``\ndirectory of the pyfuse3 tarball.\n\n\nGetting Help\n------------\n\nPlease report any bugs on the `issue tracker`_. For discussion and\nquestions, please use the general `FUSE mailing list`_ or \n`GitHub Discussions `_.\n\nDevelopment Status\n------------------\n\npyfuse3 is stable when used with Trio. The current maintainers ensure that bugs\nare addressed and pyfuse3 continues to work with new Python and libfuse\nversions. There is no plan to add new features or other non-bugfix work.\nHowever, pull requests for new features or other improvements may be accepted.\n\nUsing pyfuse3 with asyncio (rather than Trio) support is less well tested,\nthere may be bugs, and some of them may not be easily fixable.\n\nIf you need a synchronous (non async) implementation, `mfusepy `_\nis a maintained alternative.\n\n\nContributing\n------------\n\nThe pyfuse3 source code is available on GitHub_.\n\n\n.. __: https://pyfuse3.readthedocs.io/\n.. _`libfuse 3`: http://github.com/libfuse/libfuse\n.. _FUSE mailing list: https://lists.sourceforge.net/lists/listinfo/fuse-devel\n.. _issue tracker: https://github.com/libfuse/pyfuse3/issues\n.. _mailing list archive: http://dir.gmane.org/gmane.comp.file-systems.fuse.devel\n.. _Gmane: http://www.gmane.org/\n.. _PyPi: https://pypi.python.org/pypi/pyfuse3/\n.. _GitHub: https://github.com/libfuse/pyfuse3\n.. _Trio: https://github.com/python-trio/trio\n.. _asyncio: https://docs.python.org/3/library/asyncio.html\n" }, { "path": "developer-notes/FUSEError Performance.html", "content": "\n\n\nFUSEError Performance\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n \n \n \n \n\n
\n
\n\n
\n
\n
In [1]:
\n
\n
\n
%load_ext cython\n
\n\n
\n
\n
\n\n
\n
\n
\n
\n
\n
\n

Regular class vs extensions class

\n
\n
\n
\n
\n
\n
In [12]:
\n
\n
\n
%%cython\ncimport cython\n\ncdef class FUSEErrorExt(Exception):\n    '''\n    This exception may be raised by request handlers to indicate that\n    the requested operation could not be carried out. The system call\n    that resulted in the request (if any) will then fail with error\n    code *errno_*.\n    '''\n\n    # If we call this variable "errno", we will get syntax errors\n    # during C compilation (maybe something else declares errno as\n    # a macro?)\n    cdef int errno_\n\n    property errno:\n        '''Error code to return to client process'''\n        def __get__(self):\n            return self.errno_\n        def __set__(self, val):\n            self.errno_ = val\n\n    def __init__(self, errno):\n        self.errno_ = errno\n
\n\n
\n
\n
\n\n
\n
\n\n\n
\n
\n
warning: /home/nikratio/.cache/ipython/cython/_cython_magic_f3365cad4f189403d0322b37c637671e.pyx:8:5: freelists cannot be used on subtypes, only the base class can manage them\n
\n
\n
\n\n
\n
\n\n
\n
\n
\n
In [4]:
\n
\n
\n
class FUSEErrorInt(Exception):\n    def __init__(self, errno):\n        self.errno = errno\n
\n\n
\n
\n
\n\n
\n
\n
\n
In [5]:
\n
\n
\n
def test_ext():\n    a = 0\n    for i in range(100):\n        try:\n            raise FUSEErrorExt(i)\n        except FUSEErrorExt as exc:\n            a += exc.errno\n        except:\n            print('This should not happen')\n    return a\n\ndef test_int():\n    a = 0\n    for i in range(100):\n        try:\n            raise FUSEErrorInt(i)\n        except FUSEErrorInt as exc:\n            a += exc.errno\n        except:\n            print('This should not happen')\n    return a\n
\n\n
\n
\n
\n\n
\n
\n
\n
In [6]:
\n
\n
\n
assert test_ext() == test_int()\n%timeit test_ext()\n%timeit test_int()\n
\n\n
\n
\n
\n\n
\n
\n\n\n
\n
\n
The slowest run took 8.54 times longer than the fastest. This could mean that an intermediate result is being cached.\n10000 loops, best of 3: 36 µs per loop\n10000 loops, best of 3: 57.9 µs per loop\n
\n
\n
\n\n
\n
\n\n
\n
\n
\n
\n
\n
\n

Instantiation vs Factory Function with Cache

\n
\n
\n
\n
\n
\n
\n
\n
\n

(Unfortunately we cannot use @cython.freelist for derived classes)

\n\n
\n
\n
\n
\n
\n
In [7]:
\n
\n
\n
cache = dict()\ndef getError(errno):\n    try:\n        return cache[errno]\n    except KeyError:\n        cache[errno] = FUSEErrorExt(errno)\n        return cache[errno]\n    \ndef test_ext_cached():\n    a = 0\n    for i in range(100):\n        try:\n            raise getError(i)\n        except FUSEErrorExt as exc:\n            a += exc.errno\n        except:\n            print('This should not happen')\n    return a\n
\n\n
\n
\n
\n\n
\n
\n
\n
In [8]:
\n
\n
\n
assert test_ext() == test_ext_cached()\n%timeit test_ext()\n%timeit test_ext_cached()\n
\n\n
\n
\n
\n\n
\n
\n\n\n
\n
\n
10000 loops, best of 3: 32.7 µs per loop\n10000 loops, best of 3: 32.4 µs per loop\n
\n
\n
\n\n
\n
\n\n
\n
\n
\n
\n
\n
\n

Catching Exception vs Ordinary Return

\n
\n
\n
\n
\n
\n
In [9]:
\n
\n
\n
def handler(i):\n    return getError(i)\n\ndef test_ext_direct():\n    a = 0\n    for i in range(100):\n        res = handler(i)\n        if isinstance(res, FUSEErrorExt):\n            a += res.errno\n    return a\n
\n\n
\n
\n
\n\n
\n
\n
\n
In [10]:
\n
\n
\n
assert test_ext_cached() == test_ext_direct()\n%timeit test_ext_cached()\n%timeit test_ext_direct()\n
\n\n
\n
\n
\n\n
\n
\n\n\n
\n
\n
The slowest run took 5.52 times longer than the fastest. This could mean that an intermediate result is being cached.\n10000 loops, best of 3: 32.4 µs per loop\n10000 loops, best of 3: 28.4 µs per loop\n
\n
\n
\n\n
\n
\n\n
\n
\n
\n
In [ ]:
\n
\n
\n
 \n
\n\n
\n
\n
\n\n
\n
\n
\n\n\n" }, { "path": "developer-notes/FUSEError Performance.ipynb", "content": "{\n \"cells\": [\n {\n \"cell_type\": \"code\",\n \"execution_count\": 1,\n \"metadata\": {\n \"collapsed\": false\n },\n \"outputs\": [],\n \"source\": [\n \"%load_ext cython\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Regular class vs extensions class\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": 12,\n \"metadata\": {\n \"collapsed\": false\n },\n \"outputs\": [\n {\n \"name\": \"stderr\",\n \"output_type\": \"stream\",\n \"text\": [\n \"warning: /home/nikratio/.cache/ipython/cython/_cython_magic_f3365cad4f189403d0322b37c637671e.pyx:8:5: freelists cannot be used on subtypes, only the base class can manage them\\n\"\n ]\n }\n ],\n \"source\": [\n \"%%cython\\n\",\n \"cimport cython\\n\",\n \"\\n\",\n \"cdef class FUSEErrorExt(Exception):\\n\",\n \" '''\\n\",\n \" This exception may be raised by request handlers to indicate that\\n\",\n \" the requested operation could not be carried out. The system call\\n\",\n \" that resulted in the request (if any) will then fail with error\\n\",\n \" code *errno_*.\\n\",\n \" '''\\n\",\n \"\\n\",\n \" # If we call this variable \\\"errno\\\", we will get syntax errors\\n\",\n \" # during C compilation (maybe something else declares errno as\\n\",\n \" # a macro?)\\n\",\n \" cdef int errno_\\n\",\n \"\\n\",\n \" property errno:\\n\",\n \" '''Error code to return to client process'''\\n\",\n \" def __get__(self):\\n\",\n \" return self.errno_\\n\",\n \" def __set__(self, val):\\n\",\n \" self.errno_ = val\\n\",\n \"\\n\",\n \" def __init__(self, errno):\\n\",\n \" self.errno_ = errno\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": 4,\n \"metadata\": {\n \"collapsed\": false\n },\n \"outputs\": [],\n \"source\": [\n \"class FUSEErrorInt(Exception):\\n\",\n \" def __init__(self, errno):\\n\",\n \" self.errno = errno\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": 5,\n \"metadata\": {\n \"collapsed\": false\n },\n \"outputs\": [],\n \"source\": [\n \"def test_ext():\\n\",\n \" a = 0\\n\",\n \" for i in range(100):\\n\",\n \" try:\\n\",\n \" raise FUSEErrorExt(i)\\n\",\n \" except FUSEErrorExt as exc:\\n\",\n \" a += exc.errno\\n\",\n \" except:\\n\",\n \" print(\\\"This should not happen\\\")\\n\",\n \" return a\\n\",\n \"\\n\",\n \"\\n\",\n \"def test_int():\\n\",\n \" a = 0\\n\",\n \" for i in range(100):\\n\",\n \" try:\\n\",\n \" raise FUSEErrorInt(i)\\n\",\n \" except FUSEErrorInt as exc:\\n\",\n \" a += exc.errno\\n\",\n \" except:\\n\",\n \" print(\\\"This should not happen\\\")\\n\",\n \" return a\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": 6,\n \"metadata\": {\n \"collapsed\": false\n },\n \"outputs\": [\n {\n \"name\": \"stdout\",\n \"output_type\": \"stream\",\n \"text\": [\n \"The slowest run took 8.54 times longer than the fastest. This could mean that an intermediate result is being cached.\\n\",\n \"10000 loops, best of 3: 36 µs per loop\\n\",\n \"10000 loops, best of 3: 57.9 µs per loop\\n\"\n ]\n }\n ],\n \"source\": [\n \"assert test_ext() == test_int()\\n\",\n \"%timeit test_ext()\\n\",\n \"%timeit test_int()\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Instantiation vs Factory Function with Cache\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"(Unfortunately we cannot use @cython.freelist for derived classes)\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": 7,\n \"metadata\": {\n \"collapsed\": false\n },\n \"outputs\": [],\n \"source\": [\n \"cache = dict()\\n\",\n \"\\n\",\n \"\\n\",\n \"def getError(errno):\\n\",\n \" try:\\n\",\n \" return cache[errno]\\n\",\n \" except KeyError:\\n\",\n \" cache[errno] = FUSEErrorExt(errno)\\n\",\n \" return cache[errno]\\n\",\n \"\\n\",\n \"\\n\",\n \"def test_ext_cached():\\n\",\n \" a = 0\\n\",\n \" for i in range(100):\\n\",\n \" try:\\n\",\n \" raise getError(i)\\n\",\n \" except FUSEErrorExt as exc:\\n\",\n \" a += exc.errno\\n\",\n \" except:\\n\",\n \" print(\\\"This should not happen\\\")\\n\",\n \" return a\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": 8,\n \"metadata\": {\n \"collapsed\": false\n },\n \"outputs\": [\n {\n \"name\": \"stdout\",\n \"output_type\": \"stream\",\n \"text\": [\n \"10000 loops, best of 3: 32.7 µs per loop\\n\",\n \"10000 loops, best of 3: 32.4 µs per loop\\n\"\n ]\n }\n ],\n \"source\": [\n \"assert test_ext() == test_ext_cached()\\n\",\n \"%timeit test_ext()\\n\",\n \"%timeit test_ext_cached()\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Catching Exception vs Ordinary Return\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": 9,\n \"metadata\": {\n \"collapsed\": false\n },\n \"outputs\": [],\n \"source\": [\n \"def handler(i):\\n\",\n \" return getError(i)\\n\",\n \"\\n\",\n \"\\n\",\n \"def test_ext_direct():\\n\",\n \" a = 0\\n\",\n \" for i in range(100):\\n\",\n \" res = handler(i)\\n\",\n \" if isinstance(res, FUSEErrorExt):\\n\",\n \" a += res.errno\\n\",\n \" return a\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": 10,\n \"metadata\": {\n \"collapsed\": false\n },\n \"outputs\": [\n {\n \"name\": \"stdout\",\n \"output_type\": \"stream\",\n \"text\": [\n \"The slowest run took 5.52 times longer than the fastest. This could mean that an intermediate result is being cached.\\n\",\n \"10000 loops, best of 3: 32.4 µs per loop\\n\",\n \"10000 loops, best of 3: 28.4 µs per loop\\n\"\n ]\n }\n ],\n \"source\": [\n \"assert test_ext_cached() == test_ext_direct()\\n\",\n \"%timeit test_ext_cached()\\n\",\n \"%timeit test_ext_direct()\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"collapsed\": false\n },\n \"outputs\": [],\n \"source\": []\n }\n ],\n \"metadata\": {\n \"kernelspec\": {\n \"display_name\": \"Python 3\",\n \"language\": \"python\",\n \"name\": \"python3\"\n },\n \"language_info\": {\n \"codemirror_mode\": {\n \"name\": \"ipython\",\n \"version\": 3\n },\n \"file_extension\": \".py\",\n \"mimetype\": \"text/x-python\",\n \"name\": \"python\",\n \"nbconvert_exporter\": \"python\",\n \"pygments_lexer\": \"ipython3\",\n \"version\": \"3.5.3\"\n }\n },\n \"nbformat\": 4,\n \"nbformat_minor\": 0\n}\n" }, { "path": "developer-notes/Namedtuple.html", "content": "\n\n\nNamedtuple\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n \n \n \n \n\n
\n
\n\n
\n
\n
\n
\n
\n

Namedtuple vs Extension Class

\n
\n
\n
\n
\n
\n
In [1]:
\n
\n
\n
%load_ext Cython\n
\n\n
\n
\n
\n\n
\n
\n
\n
In [2]:
\n
\n
\n
%%cython\n\ncdef class InvalRequestExt:\n    cdef int ino\n    cdef char attr_only\n    \n    def __cinit__(self, ino, attr_only):\n        self.ino = ino\n        self.attr_only = bool(attr_only)\n
\n\n
\n
\n
\n\n
\n
\n
\n
In [3]:
\n
\n
\n
from collections import namedtuple\nInvalRequestTup = namedtuple('InvalRequestTup', [ 'inode', 'attr_only' ])\n
\n\n
\n
\n
\n\n
\n
\n
\n
In [4]:
\n
\n
\n
def test(cls):\n    inst = []\n    for i in range(500):\n        inst.append(cls(i, False))\n    return inst\n
\n\n
\n
\n
\n\n
\n
\n
\n
In [5]:
\n
\n
\n
assert len(test(InvalRequestExt)) == len(test(InvalRequestTup))\n
\n\n
\n
\n
\n\n
\n
\n
\n
In [6]:
\n
\n
\n
%timeit test(InvalRequestExt)\n%timeit test(InvalRequestTup)\n
\n\n
\n
\n
\n\n
\n
\n\n\n
\n
\n
10000 loops, best of 3: 63.3 µs per loop\n1000 loops, best of 3: 204 µs per loop\n
\n
\n
\n\n
\n
\n\n
\n
\n
\n
In [ ]:
\n
\n
\n
 \n
\n\n
\n
\n
\n\n
\n
\n
\n\n\n" }, { "path": "developer-notes/Namedtuple.ipynb", "content": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Namedtuple vs Extension Class\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": 1,\n \"metadata\": {\n \"collapsed\": false\n },\n \"outputs\": [],\n \"source\": [\n \"%load_ext Cython\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": 2,\n \"metadata\": {\n \"collapsed\": false\n },\n \"outputs\": [],\n \"source\": [\n \"%%cython\\n\",\n \"\\n\",\n \"cdef class InvalRequestExt:\\n\",\n \" cdef int ino\\n\",\n \" cdef char attr_only\\n\",\n \" \\n\",\n \" def __cinit__(self, ino, attr_only):\\n\",\n \" self.ino = ino\\n\",\n \" self.attr_only = bool(attr_only)\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": 3,\n \"metadata\": {\n \"collapsed\": false\n },\n \"outputs\": [],\n \"source\": [\n \"from collections import namedtuple\\n\",\n \"\\n\",\n \"InvalRequestTup = namedtuple(\\\"InvalRequestTup\\\", [\\\"inode\\\", \\\"attr_only\\\"])\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": 4,\n \"metadata\": {\n \"collapsed\": false\n },\n \"outputs\": [],\n \"source\": [\n \"def test(cls):\\n\",\n \" inst = []\\n\",\n \" for i in range(500):\\n\",\n \" inst.append(cls(i, False))\\n\",\n \" return inst\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": 5,\n \"metadata\": {\n \"collapsed\": false\n },\n \"outputs\": [],\n \"source\": [\n \"assert len(test(InvalRequestExt)) == len(test(InvalRequestTup))\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": 6,\n \"metadata\": {\n \"collapsed\": false\n },\n \"outputs\": [\n {\n \"name\": \"stdout\",\n \"output_type\": \"stream\",\n \"text\": [\n \"10000 loops, best of 3: 63.3 µs per loop\\n\",\n \"1000 loops, best of 3: 204 µs per loop\\n\"\n ]\n }\n ],\n \"source\": [\n \"%timeit test(InvalRequestExt)\\n\",\n \"%timeit test(InvalRequestTup)\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"collapsed\": false\n },\n \"outputs\": [],\n \"source\": []\n }\n ],\n \"metadata\": {\n \"kernelspec\": {\n \"display_name\": \"Python 3\",\n \"language\": \"python\",\n \"name\": \"python3\"\n },\n \"language_info\": {\n \"codemirror_mode\": {\n \"name\": \"ipython\",\n \"version\": 3\n },\n \"file_extension\": \".py\",\n \"mimetype\": \"text/x-python\",\n \"name\": \"python\",\n \"nbconvert_exporter\": \"python\",\n \"pygments_lexer\": \"ipython3\",\n \"version\": \"3.5.3\"\n }\n },\n \"nbformat\": 4,\n \"nbformat_minor\": 0\n}\n" }, { "path": "developer-notes/lookup_counts.rst", "content": "===========================================\n Move Lookup Count Management into PYFUSE3?\n===========================================\n\nIt would be nice if PYFUSE3 could keep track of the lookup count\nmanagement. That way its users wouldn't need to worry about which\nhandlers increase the lookup count, and `forget` would only be called\nwhen the lookup count reaches zero.\n\n\nUnfortunately, this is only possible when serializing all Python\nrequest handlers. The reason is the following:\n\nIf an application wants to distinguish between \"active\" and forgotten\ninodes it generally wants to establish some internal lstate that\nsurvives as long as the corresponding inode is active. However, in\norder to maintain that state, it has to be protected by the same lock\nas the lookup count. This makes it impossible to update the lookup\ncount in PYFUSE3 after the python handler method has returned.\n\nExample::\n\n class WontWork:\n def lookup(self, name):\n inode = get_inode(name)\n lookup_count[inode] += 1 # for simplicity, assume this is atomic\n cache[inode] = get_state(inode)\n\n def forget(self, inode):\n lookup_count[inode] -= 1 # for simplicity, assume this is atomic\n if lookup_count[inode] == 0:\n del cache[inode]\n\n def open(self, inode):\n # This works, because lookup() must have returned before\n # open() can be called.\n assert lookup_count[inode] > 0\n\n # This won't work, because forget() may have been\n interrupted by lookup() # between `if` and `del`\n assert cache[inode]\n\n\n class WouldWork:\n def lookup(self, name):\n inode = get_inode(name)\n with lock(inode):\n lookup_count[inode] += 1\n cache[inode] = get_state(inode)\n\n def forget(self, inode):\n with lock(inode):\n lookup_count[inode] -= 1\n if lookup_count[inode] == 0:\n del cache[inode]\n\n def open(self, inode):\n assert lookup_count[inode] > 0\n assert cache[inode]\n\n\nA slightly less complex situation arises if the application does not\nwant to keep state, but is just using lookup counts to postpone inode\nremoval until `forget`. In this case, one correct implementation is::\n\n class SimpleOps:\n\n def lookup(self, name):\n inode = get_inode(name)\n with lookup_lock:\n lookup_count[inode] += 1\n\n def forget(self, inode):\n with lookup_lock:\n lookup_count[inode] -= 1\n if lookup_count[inode] > 0:\n return\n del lookup_count[inode]\n\n self.maybe_remove_inode(inode)\n\n\n def maybe_remove_inode(self, inode):\n with lock(inode):\n if refcount_of(inode) > 0:\n return\n\n if inode in lookup_count:\n # may have been looked up before refcount became zero\n return\n\n # Inode is not referenced by any directory entries (so it cannot be\n # looked up), and it is not known to the kernel (so it cannot be\n # passed to any other handlers). The lock on inode is required not\n # just because increment/decrement of the reference count may not be\n # atomic, but also because an `unlink` handler may have already\n # decreased the reference count, but still want to do something with\n # the inode.\n delete_inode(inode)\n\n def unlink_entry(self, name):\n delete_name(name)\n inode = get_inode(name)\n with lock(inode):\n decr_refcount_for(inode)\n return inode\n\n def unlink(self, name):\n inode = self.unlink_entry(name)\n if inode not in lookup_count:\n self.maybe_remove_inode(inode)\n\n\nHere, the operations that modify lookup_count as well as the complete\nforget() function could be moved into pyfuse3. The price of this is\nthat the application can no longer tell for sure if an inode is known\nto the kernel. This is a problem if e.g. inode numbers are generated\ndynamically - without forget(), how does the file system know when it\ncan re-use an inode?\n\n\nTherefore, I've decided not to implement this feature. Applications\nhave to keep track of the lookup count manually.\n" }, { "path": "developer-notes/release_process.rst", "content": "Steps for Releasing a New Version\n---------------------------------\n\n * `export NEWVER=XX.YY.Z`\n * Add release date and version to `Changes.rst`\n * `git commit --all -m \"Released $NEWVER\"`\n * `git tag v$NEWVER`\n * `uv sync --locked`\n * `uv run sphinx-build -b html rst doc/html`\n * `uv build --sdist`\n * `gpg --detach-sign --armor --output dist/pyfuse3-$NEWVER.tar.gz.asc dist/pyfuse3-$NEWVER.targ.nz` (or `util/sdist-sign $NEWVER`)\n * `uv run twine upload dist/pyfuse3-$NEWVER.tar.gz` (or `util/upload-pypi $NEWVER`)\n * Create release on GitHub (https://github.com/libfuse/pyfuse3/releases/)\n * Send announcement to mailing list\n * Get contributors: `git log --pretty=\"format:%an <%aE>\" \"${PREV_TAG}..v${NEWVER}\" | sort -u`\n\n\nAnnouncement template:\n----------------------\n\nDear all,\n\nI'm happy to announce a new release of pyfuse3, version .\n\npyfuse3 is a set of Python 3 bindings for `libfuse 3`_. It provides an\nasynchronous API compatible with Trio_ and asyncio_, and enables you to easily\nwrite a full-featured Linux filesystem in Python.\n\nFrom the changelog:\n\n\n\nThe following people have contributed code to this release:\n\n[PASTE HERE]\n\nAs usual, the newest release can be downloaded from PyPi at\nhttps://pypi.python.org/pypi/pyfuse3/.\n\nPlease report any bugs on the issue tracker at\nhttps://github.com/libfuse/pyfuse3/issues. For discussion and questions, please\nuse the general FUSE mailing list (i.e., this list) or the GitHub discussion\nforum at https://github.com/libfuse/pyfuse3/discussions.\n" }, { "path": "developer-notes/setup.md", "content": "# How to run/develop pyfuse3 from Git\n\nTo run unit tests, build the documentation, and make changes to pyfuse3, the recommended procedure is\nto create a virtual environment and install pyfuse3, build dependencies, and development tools into\nthis environment.\n\nYou can do this using a tool like [uv](https://docs.astral.sh/uv/getting-started/installation/) or\nby hand as follows:\n\n```sh\n$ python3 -m venv .venv # create the venv\n$ . .venv/bin/activate # activate it\n$ pip install --upgrade pip # upgrade pip\n$ pip install \".[dev]\" # install build dependencies\n$ pip install --no-build-isolation --editable . # install pyfuse3 in editable mode\n```\n\nAs long as the venv is active, you can run tests with\n\n```sh\n$ pytest test/\n```\n\nand build the HTML documentation and manpages with:\n```sh\n$ sphinx-build -b html rst doc/html\n```\n\n" }, { "path": "developer-notes/valgrind.md", "content": "To run tests under valgrind:\n\n- Build python `--with-valgrind --with-pydebug`.\n- Run `valgrind --trace-children=yes \"--trace-children-skip=*mount*\" python-dbg -m pytest test/`\n" }, { "path": "doc/.placeholder", "content": "" }, { "path": "examples/hello.py", "content": "#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n'''\nhello.py - Example file system for pyfuse3.\n\nThis program presents a static file system containing a single file.\n\nCopyright © 2015 Nikolaus Rath \nCopyright © 2015 Gerion Entrup.\n\nPermission is hereby granted, free of charge, to any person obtaining a copy of\nthis software and associated documentation files (the \"Software\"), to deal in\nthe Software without restriction, including without limitation the rights to\nuse, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\nthe Software, and to permit persons to whom the Software is furnished to do so.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\nFOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\nCOPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\nIN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\nCONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n'''\n\nimport errno\nimport logging\nimport os\nimport stat\nfrom argparse import ArgumentParser, Namespace\nfrom typing import cast\n\nimport trio\n\nimport pyfuse3\nfrom pyfuse3 import EntryAttributes, FileHandleT, FileInfo, InodeT, ReaddirToken, RequestContext\n\ntry:\n import faulthandler\nexcept ImportError:\n pass\nelse:\n faulthandler.enable()\n\nlog = logging.getLogger(__name__)\n\n\nclass TestFs(pyfuse3.Operations):\n def __init__(self) -> None:\n super(TestFs, self).__init__()\n self.hello_name = b\"message\"\n self.hello_inode = cast(InodeT, pyfuse3.ROOT_INODE + 1)\n self.hello_data = b\"hello world\\n\"\n\n async def getattr(self, inode: InodeT, ctx: RequestContext | None = None) -> EntryAttributes:\n entry = EntryAttributes()\n if inode == pyfuse3.ROOT_INODE:\n entry.st_mode = stat.S_IFDIR | 0o755\n entry.st_size = 0\n elif inode == self.hello_inode:\n entry.st_mode = stat.S_IFREG | 0o644\n entry.st_size = len(self.hello_data)\n else:\n raise pyfuse3.FUSEError(errno.ENOENT)\n\n stamp = int(1438467123.985654 * 1e9)\n entry.st_atime_ns = stamp\n entry.st_ctime_ns = stamp\n entry.st_mtime_ns = stamp\n entry.st_gid = os.getgid()\n entry.st_uid = os.getuid()\n entry.st_ino = inode\n\n return entry\n\n async def lookup(\n self, parent_inode: InodeT, name: bytes, ctx: RequestContext\n ) -> EntryAttributes:\n if parent_inode != pyfuse3.ROOT_INODE or name != self.hello_name:\n raise pyfuse3.FUSEError(errno.ENOENT)\n return await self.getattr(self.hello_inode, ctx)\n\n async def opendir(self, inode: InodeT, ctx: RequestContext) -> FileHandleT:\n if inode != pyfuse3.ROOT_INODE:\n raise pyfuse3.FUSEError(errno.ENOENT)\n # For simplicity, we use the inode as file handle\n return FileHandleT(inode)\n\n async def readdir(self, fh: FileHandleT, start_id: int, token: ReaddirToken) -> None:\n assert fh == pyfuse3.ROOT_INODE\n\n # only one entry\n if start_id == 0:\n pyfuse3.readdir_reply(token, self.hello_name, await self.getattr(self.hello_inode), 1)\n return\n\n async def open(self, inode: InodeT, flags: int, ctx: RequestContext) -> FileInfo:\n if inode != self.hello_inode:\n raise pyfuse3.FUSEError(errno.ENOENT)\n if flags & os.O_RDWR or flags & os.O_WRONLY:\n raise pyfuse3.FUSEError(errno.EACCES)\n # For simplicity, we use the inode as file handle\n return FileInfo(fh=FileHandleT(inode))\n\n async def read(self, fh: FileHandleT, off: int, size: int) -> bytes:\n assert fh == self.hello_inode\n return self.hello_data[off : off + size]\n\n\ndef init_logging(debug: bool = False) -> None:\n formatter = logging.Formatter(\n '%(asctime)s.%(msecs)03d %(threadName)s: [%(name)s] %(message)s',\n datefmt=\"%Y-%m-%d %H:%M:%S\",\n )\n handler = logging.StreamHandler()\n handler.setFormatter(formatter)\n root_logger = logging.getLogger()\n if debug:\n handler.setLevel(logging.DEBUG)\n root_logger.setLevel(logging.DEBUG)\n else:\n handler.setLevel(logging.INFO)\n root_logger.setLevel(logging.INFO)\n root_logger.addHandler(handler)\n\n\ndef parse_args() -> Namespace:\n '''Parse command line'''\n\n parser = ArgumentParser()\n\n parser.add_argument('mountpoint', type=str, help='Where to mount the file system')\n parser.add_argument(\n '--debug', action='store_true', default=False, help='Enable debugging output'\n )\n parser.add_argument(\n '--debug-fuse', action='store_true', default=False, help='Enable FUSE debugging output'\n )\n return parser.parse_args()\n\n\ndef main() -> None:\n options = parse_args()\n init_logging(options.debug)\n\n testfs = TestFs()\n fuse_options = set(pyfuse3.default_options)\n fuse_options.add('fsname=hello')\n if options.debug_fuse:\n fuse_options.add('debug')\n pyfuse3.init(testfs, options.mountpoint, fuse_options)\n try:\n trio.run(pyfuse3.main)\n except:\n pyfuse3.close(unmount=False)\n raise\n\n pyfuse3.close()\n\n\nif __name__ == '__main__':\n main()\n" }, { "path": "examples/hello_asyncio.py", "content": "#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n'''\nhello_asyncio.py - Example file system for pyfuse3 using asyncio.\n\nThis program presents a static file system containing a single file.\n\nCopyright © 2015 Nikolaus Rath \nCopyright © 2015 Gerion Entrup.\n\nPermission is hereby granted, free of charge, to any person obtaining a copy of\nthis software and associated documentation files (the \"Software\"), to deal in\nthe Software without restriction, including without limitation the rights to\nuse, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\nthe Software, and to permit persons to whom the Software is furnished to do so.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\nFOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\nCOPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\nIN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\nCONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n'''\n\nimport asyncio\nimport errno\nimport logging\nimport os\nimport stat\nfrom argparse import ArgumentParser, Namespace\nfrom typing import cast\n\nimport pyfuse3\nimport pyfuse3.asyncio\nfrom pyfuse3 import EntryAttributes, FileHandleT, FileInfo, InodeT, ReaddirToken, RequestContext\n\ntry:\n import faulthandler\nexcept ImportError:\n pass\nelse:\n faulthandler.enable()\n\nlog = logging.getLogger(__name__)\npyfuse3.asyncio.enable()\n\n\nclass TestFs(pyfuse3.Operations):\n def __init__(self) -> None:\n super(TestFs, self).__init__()\n self.hello_name = b\"message\"\n self.hello_inode = cast(InodeT, pyfuse3.ROOT_INODE + 1)\n self.hello_data = b\"hello world\\n\"\n\n async def getattr(self, inode: InodeT, ctx: RequestContext | None = None) -> EntryAttributes:\n entry = EntryAttributes()\n if inode == pyfuse3.ROOT_INODE:\n entry.st_mode = stat.S_IFDIR | 0o755\n entry.st_size = 0\n elif inode == self.hello_inode:\n entry.st_mode = stat.S_IFREG | 0o644\n entry.st_size = len(self.hello_data)\n else:\n raise pyfuse3.FUSEError(errno.ENOENT)\n\n stamp = int(1438467123.985654 * 1e9)\n entry.st_atime_ns = stamp\n entry.st_ctime_ns = stamp\n entry.st_mtime_ns = stamp\n entry.st_gid = os.getgid()\n entry.st_uid = os.getuid()\n entry.st_ino = inode\n\n return entry\n\n async def lookup(\n self, parent_inode: InodeT, name: bytes, ctx: RequestContext\n ) -> EntryAttributes:\n if parent_inode != pyfuse3.ROOT_INODE or name != self.hello_name:\n raise pyfuse3.FUSEError(errno.ENOENT)\n return await self.getattr(self.hello_inode, ctx)\n\n async def opendir(self, inode: InodeT, ctx: RequestContext) -> FileHandleT:\n if inode != pyfuse3.ROOT_INODE:\n raise pyfuse3.FUSEError(errno.ENOENT)\n # For simplicity, we use the inode as file handle\n return FileHandleT(inode)\n\n async def readdir(self, fh: FileHandleT, start_id: int, token: ReaddirToken) -> None:\n assert fh == pyfuse3.ROOT_INODE\n\n # only one entry\n if start_id == 0:\n pyfuse3.readdir_reply(token, self.hello_name, await self.getattr(self.hello_inode), 1)\n return\n\n async def setxattr(self, inode: InodeT, name: bytes, value: bytes, ctx: RequestContext) -> None:\n if inode != pyfuse3.ROOT_INODE or name != b'command':\n raise pyfuse3.FUSEError(errno.ENOTSUP)\n\n if value == b'terminate':\n pyfuse3.terminate()\n else:\n raise pyfuse3.FUSEError(errno.EINVAL)\n\n async def open(self, inode: InodeT, flags: int, ctx: RequestContext) -> FileInfo:\n if inode != self.hello_inode:\n raise pyfuse3.FUSEError(errno.ENOENT)\n if flags & os.O_RDWR or flags & os.O_WRONLY:\n raise pyfuse3.FUSEError(errno.EACCES)\n # For simplicity, we use the inode as file handle\n return FileInfo(fh=FileHandleT(inode))\n\n async def read(self, fh: FileHandleT, off: int, size: int) -> bytes:\n assert fh == self.hello_inode\n return self.hello_data[off : off + size]\n\n\ndef init_logging(debug: bool = False) -> None:\n formatter = logging.Formatter(\n '%(asctime)s.%(msecs)03d %(threadName)s: [%(name)s] %(message)s',\n datefmt=\"%Y-%m-%d %H:%M:%S\",\n )\n handler = logging.StreamHandler()\n handler.setFormatter(formatter)\n root_logger = logging.getLogger()\n if debug:\n handler.setLevel(logging.DEBUG)\n root_logger.setLevel(logging.DEBUG)\n else:\n handler.setLevel(logging.INFO)\n root_logger.setLevel(logging.INFO)\n root_logger.addHandler(handler)\n\n\ndef parse_args() -> Namespace:\n '''Parse command line'''\n\n parser = ArgumentParser()\n\n parser.add_argument('mountpoint', type=str, help='Where to mount the file system')\n parser.add_argument(\n '--debug', action='store_true', default=False, help='Enable debugging output'\n )\n parser.add_argument(\n '--debug-fuse', action='store_true', default=False, help='Enable FUSE debugging output'\n )\n return parser.parse_args()\n\n\ndef main() -> None:\n options = parse_args()\n init_logging(options.debug)\n\n testfs = TestFs()\n fuse_options = set(pyfuse3.default_options)\n fuse_options.add('fsname=hello_asyncio')\n if options.debug_fuse:\n fuse_options.add('debug')\n pyfuse3.init(testfs, options.mountpoint, fuse_options)\n try:\n asyncio.run(pyfuse3.main())\n except:\n pyfuse3.close(unmount=False)\n raise\n\n pyfuse3.close()\n\n\nif __name__ == '__main__':\n main()\n" }, { "path": "examples/passthroughfs.py", "content": "#!/usr/bin/env python3\n'''\npassthroughfs.py - Example file system for pyfuse3\n\nThis file system mirrors the contents of a specified directory tree.\n\nCaveats:\n\n * Inode generation numbers are not passed through but set to zero.\n\n * Block size (st_blksize) and number of allocated blocks (st_blocks) are not\n passed through.\n\n * Performance for large directories is not good, because the directory\n is always read completely.\n\n * There may be a way to break-out of the directory tree.\n\n * The readdir implementation is not fully POSIX compliant. If a directory\n contains hardlinks and is modified during a readdir call, readdir()\n may return some of the hardlinked files twice or omit them completely.\n\n * If you delete or rename files in the underlying file system, the\n passthrough file system will get confused.\n\nCopyright © Nikolaus Rath \n\nPermission is hereby granted, free of charge, to any person obtaining a copy of\nthis software and associated documentation files (the \"Software\"), to deal in\nthe Software without restriction, including without limitation the rights to\nuse, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\nthe Software, and to permit persons to whom the Software is furnished to do so.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\nFOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\nCOPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\nIN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\nCONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n'''\n\nimport errno\nimport faulthandler\nimport logging\nimport os\nimport stat as stat_m\nimport sys\nfrom argparse import ArgumentParser, Namespace\nfrom collections import defaultdict\nfrom collections.abc import Sequence\nfrom os import fsdecode, fsencode\nfrom typing import cast\n\nimport trio\n\nimport pyfuse3\nfrom pyfuse3 import (\n EntryAttributes,\n FileHandleT,\n FileInfo,\n FUSEError,\n InodeT,\n ReaddirToken,\n RequestContext,\n SetattrFields,\n StatvfsData,\n)\n\nfaulthandler.enable()\n\nlog = logging.getLogger(__name__)\n\n\nclass Operations(pyfuse3.Operations):\n def __init__(self, source: str, enable_writeback_cache: bool = False) -> None:\n super().__init__()\n self.enable_writeback_cache = enable_writeback_cache\n self._inode_path_map: dict[InodeT, str | set[str]] = {pyfuse3.ROOT_INODE: source}\n self._lookup_cnt: defaultdict[InodeT, int] = defaultdict(lambda: 0)\n self._fd_inode_map: dict[int, InodeT] = dict()\n self._inode_fd_map: dict[InodeT, int] = dict()\n self._fd_open_count: dict[int, int] = dict()\n\n def _inode_to_path(self, inode: InodeT) -> str:\n try:\n val = self._inode_path_map[inode]\n except KeyError:\n raise FUSEError(errno.ENOENT)\n\n if isinstance(val, set):\n # In case of hardlinks, pick any path\n val = next(iter(val))\n return val\n\n def _add_path(self, inode: InodeT, path: str) -> None:\n log.debug('_add_path for %d, %s', inode, path)\n self._lookup_cnt[inode] += 1\n\n # With hardlinks, one inode may map to multiple paths.\n if inode not in self._inode_path_map:\n self._inode_path_map[inode] = path\n return\n\n val = self._inode_path_map[inode]\n if isinstance(val, set):\n val.add(path)\n elif val != path:\n self._inode_path_map[inode] = {path, val}\n\n async def forget(self, inode_list: Sequence[tuple[InodeT, int]]) -> None:\n for inode, nlookup in inode_list:\n if self._lookup_cnt[inode] > nlookup:\n self._lookup_cnt[inode] -= nlookup\n continue\n log.debug('forgetting about inode %d', inode)\n assert inode not in self._inode_fd_map\n del self._lookup_cnt[inode]\n try:\n del self._inode_path_map[inode]\n except KeyError: # may have been deleted\n pass\n\n async def lookup(\n self, parent_inode: InodeT, name: bytes, ctx: RequestContext\n ) -> EntryAttributes:\n name_str = fsdecode(name)\n log.debug('lookup for %s in %d', name_str, parent_inode)\n path = os.path.join(self._inode_to_path(parent_inode), name_str)\n attr = self._getattr(path=path)\n if name_str != '.' and name_str != '..':\n self._add_path(InodeT(attr.st_ino), path)\n return attr\n\n async def getattr(self, inode: InodeT, ctx: RequestContext | None = None) -> EntryAttributes:\n if inode in self._inode_fd_map:\n return self._getattr(fd=self._inode_fd_map[inode])\n else:\n return self._getattr(path=self._inode_to_path(inode))\n\n def _getattr(self, path: str | None = None, fd: int | None = None) -> EntryAttributes:\n assert fd is None or path is None\n assert not (fd is None and path is None)\n try:\n if fd is None:\n assert path is not None\n stat = os.lstat(path)\n else:\n stat = os.fstat(fd)\n except OSError as exc:\n assert exc.errno is not None\n raise FUSEError(exc.errno)\n\n entry = EntryAttributes()\n for attr in (\n 'st_ino',\n 'st_mode',\n 'st_nlink',\n 'st_uid',\n 'st_gid',\n 'st_rdev',\n 'st_size',\n 'st_atime_ns',\n 'st_mtime_ns',\n 'st_ctime_ns',\n ):\n setattr(entry, attr, getattr(stat, attr))\n entry.generation = 0\n entry.entry_timeout = 0\n entry.attr_timeout = 0\n entry.st_blksize = 512\n entry.st_blocks = (entry.st_size + entry.st_blksize - 1) // entry.st_blksize\n\n return entry\n\n async def readlink(self, inode: InodeT, ctx: RequestContext) -> bytes:\n path = self._inode_to_path(inode)\n try:\n target = os.readlink(path)\n except OSError as exc:\n assert exc.errno is not None\n raise FUSEError(exc.errno)\n return fsencode(target)\n\n async def opendir(self, inode: InodeT, ctx: RequestContext) -> FileHandleT:\n # For simplicity, we use the inode as file handle\n return FileHandleT(inode)\n\n async def readdir(self, fh: FileHandleT, start_id: int, token: ReaddirToken) -> None:\n path = self._inode_to_path(InodeT(fh))\n log.debug('reading %s', path)\n entries: list[tuple[InodeT, str, EntryAttributes]] = []\n for name in os.listdir(path):\n if name == '.' or name == '..':\n continue\n attr = self._getattr(path=os.path.join(path, name))\n entries.append((InodeT(attr.st_ino), name, attr))\n\n log.debug('read %d entries, starting at %d', len(entries), start_id)\n\n # This is not fully posix compatible. If there are hardlinks\n # (two names with the same inode), we don't have a unique\n # offset to start in between them. Note that we cannot simply\n # count entries, because then we would skip over entries\n # (or return them more than once) if the number of directory\n # entries changes between two calls to readdir().\n for ino, name, attr in sorted(entries):\n if ino <= start_id:\n continue\n if not pyfuse3.readdir_reply(token, fsencode(name), attr, ino):\n break\n self._add_path(attr.st_ino, os.path.join(path, name))\n\n async def unlink(self, parent_inode: InodeT, name: bytes, ctx: RequestContext) -> None:\n name_str = fsdecode(name)\n parent = self._inode_to_path(parent_inode)\n path = os.path.join(parent, name_str)\n try:\n inode = os.lstat(path).st_ino\n os.unlink(path)\n except OSError as exc:\n assert exc.errno is not None\n raise FUSEError(exc.errno)\n if inode in self._lookup_cnt:\n self._forget_path(InodeT(inode), path)\n\n async def rmdir(self, parent_inode: InodeT, name: bytes, ctx: RequestContext) -> None:\n name_str = fsdecode(name)\n parent = self._inode_to_path(parent_inode)\n path = os.path.join(parent, name_str)\n try:\n inode = os.lstat(path).st_ino\n os.rmdir(path)\n except OSError as exc:\n assert exc.errno is not None\n raise FUSEError(exc.errno)\n if inode in self._lookup_cnt:\n self._forget_path(InodeT(inode), path)\n\n def _forget_path(self, inode: InodeT, path: str) -> None:\n log.debug('forget %s for %d', path, inode)\n val = self._inode_path_map[inode]\n if isinstance(val, set):\n val.remove(path)\n if len(val) == 1:\n self._inode_path_map[inode] = next(iter(val))\n else:\n del self._inode_path_map[inode]\n\n async def symlink(\n self, parent_inode: InodeT, name: bytes, target: bytes, ctx: RequestContext\n ) -> EntryAttributes:\n name_str = fsdecode(name)\n target_str = fsdecode(target)\n parent = self._inode_to_path(parent_inode)\n path = os.path.join(parent, name_str)\n try:\n os.symlink(target_str, path)\n os.lchown(path, ctx.uid, ctx.gid)\n except OSError as exc:\n assert exc.errno is not None\n raise FUSEError(exc.errno)\n inode = InodeT(os.lstat(path).st_ino)\n self._add_path(inode, path)\n return await self.getattr(inode, ctx)\n\n async def rename(\n self,\n parent_inode_old: InodeT,\n name_old: bytes,\n parent_inode_new: InodeT,\n name_new: bytes,\n flags: int,\n ctx: RequestContext,\n ) -> None:\n if flags != 0:\n raise FUSEError(errno.EINVAL)\n\n name_old_str = fsdecode(name_old)\n name_new_str = fsdecode(name_new)\n parent_old = self._inode_to_path(parent_inode_old)\n parent_new = self._inode_to_path(parent_inode_new)\n path_old = os.path.join(parent_old, name_old_str)\n path_new = os.path.join(parent_new, name_new_str)\n try:\n os.rename(path_old, path_new)\n inode = cast(InodeT, os.lstat(path_new).st_ino)\n except OSError as exc:\n assert exc.errno is not None\n raise FUSEError(exc.errno)\n if inode not in self._lookup_cnt:\n return\n\n val = self._inode_path_map[inode]\n if isinstance(val, set):\n assert len(val) > 1\n val.add(path_new)\n val.remove(path_old)\n else:\n assert val == path_old\n self._inode_path_map[inode] = path_new\n\n async def link(\n self, inode: InodeT, new_parent_inode: InodeT, new_name: bytes, ctx: RequestContext\n ) -> EntryAttributes:\n new_name_str = fsdecode(new_name)\n parent = self._inode_to_path(new_parent_inode)\n path = os.path.join(parent, new_name_str)\n try:\n os.link(self._inode_to_path(inode), path, follow_symlinks=False)\n except OSError as exc:\n assert exc.errno is not None\n raise FUSEError(exc.errno)\n self._add_path(inode, path)\n return await self.getattr(inode, ctx)\n\n async def setattr(\n self,\n inode: InodeT,\n attr: EntryAttributes,\n fields: SetattrFields,\n fh: FileHandleT | None,\n ctx: RequestContext,\n ) -> EntryAttributes:\n try:\n if fields.update_size:\n if fh is None:\n os.truncate(self._inode_to_path(inode), attr.st_size)\n else:\n os.ftruncate(fh, attr.st_size)\n\n if fields.update_mode:\n # Under Linux, chmod always resolves symlinks so we should\n # actually never get a setattr() request for a symbolic\n # link.\n assert not stat_m.S_ISLNK(attr.st_mode)\n if fh is None:\n os.chmod(self._inode_to_path(inode), stat_m.S_IMODE(attr.st_mode))\n else:\n os.fchmod(fh, stat_m.S_IMODE(attr.st_mode))\n\n if fields.update_uid and fields.update_gid:\n if fh is None:\n os.chown(\n self._inode_to_path(inode), attr.st_uid, attr.st_gid, follow_symlinks=False\n )\n else:\n os.fchown(fh, attr.st_uid, attr.st_gid)\n\n elif fields.update_uid:\n if fh is None:\n os.chown(self._inode_to_path(inode), attr.st_uid, -1, follow_symlinks=False)\n else:\n os.fchown(fh, attr.st_uid, -1)\n\n elif fields.update_gid:\n if fh is None:\n os.chown(self._inode_to_path(inode), -1, attr.st_gid, follow_symlinks=False)\n else:\n os.fchown(fh, -1, attr.st_gid)\n\n if fields.update_atime and fields.update_mtime:\n if fh is None:\n os.utime(\n self._inode_to_path(inode),\n None,\n follow_symlinks=False,\n ns=(attr.st_atime_ns, attr.st_mtime_ns),\n )\n else:\n os.utime(fh, None, ns=(attr.st_atime_ns, attr.st_mtime_ns))\n elif fields.update_atime or fields.update_mtime:\n # We can only set both values, so we first need to retrieve the\n # one that we shouldn't be changing.\n if fh is None:\n path = self._inode_to_path(inode)\n oldstat = os.stat(path, follow_symlinks=False)\n else:\n oldstat = os.fstat(fh)\n if not fields.update_atime:\n attr.st_atime_ns = oldstat.st_atime_ns\n else:\n attr.st_mtime_ns = oldstat.st_mtime_ns\n if fh is None:\n os.utime(\n path, # pyright: ignore[reportPossiblyUnboundVariable]\n None,\n follow_symlinks=False,\n ns=(attr.st_atime_ns, attr.st_mtime_ns),\n )\n else:\n os.utime(fh, None, ns=(attr.st_atime_ns, attr.st_mtime_ns))\n\n except OSError as exc:\n assert exc.errno is not None\n raise FUSEError(exc.errno)\n\n return await self.getattr(inode, ctx)\n\n async def mknod(\n self, parent_inode: InodeT, name: bytes, mode: int, rdev: int, ctx: RequestContext\n ) -> EntryAttributes:\n path = os.path.join(self._inode_to_path(parent_inode), fsdecode(name))\n try:\n os.mknod(path, mode=(mode & ~ctx.umask), device=rdev)\n os.chown(path, ctx.uid, ctx.gid)\n except OSError as exc:\n assert exc.errno is not None\n raise FUSEError(exc.errno)\n attr = self._getattr(path=path)\n self._add_path(attr.st_ino, path)\n return attr\n\n async def mkdir(\n self, parent_inode: InodeT, name: bytes, mode: int, ctx: RequestContext\n ) -> EntryAttributes:\n path = os.path.join(self._inode_to_path(parent_inode), fsdecode(name))\n try:\n os.mkdir(path, mode=(mode & ~ctx.umask))\n os.chown(path, ctx.uid, ctx.gid)\n except OSError as exc:\n assert exc.errno is not None\n raise FUSEError(exc.errno)\n attr = self._getattr(path=path)\n self._add_path(attr.st_ino, path)\n return attr\n\n async def statfs(self, ctx: RequestContext) -> StatvfsData:\n root = self._inode_path_map[pyfuse3.ROOT_INODE]\n assert isinstance(root, str)\n stat_ = StatvfsData()\n try:\n statfs = os.statvfs(root)\n except OSError as exc:\n assert exc.errno is not None\n raise FUSEError(exc.errno)\n for attr in (\n 'f_bsize',\n 'f_frsize',\n 'f_blocks',\n 'f_bfree',\n 'f_bavail',\n 'f_files',\n 'f_ffree',\n 'f_favail',\n ):\n setattr(stat_, attr, getattr(statfs, attr))\n stat_.f_namemax = statfs.f_namemax - (len(root) + 1)\n return stat_\n\n async def open(self, inode: InodeT, flags: int, ctx: RequestContext) -> FileInfo:\n if inode in self._inode_fd_map:\n fd = self._inode_fd_map[inode]\n self._fd_open_count[fd] += 1\n return FileInfo(fh=FileHandleT(fd))\n assert flags & os.O_CREAT == 0\n try:\n fd = os.open(self._inode_to_path(inode), flags)\n except OSError as exc:\n assert exc.errno is not None\n raise FUSEError(exc.errno)\n self._inode_fd_map[inode] = fd\n self._fd_inode_map[fd] = inode\n self._fd_open_count[fd] = 1\n return FileInfo(fh=cast(FileHandleT, fd))\n\n async def create(\n self, parent_inode: InodeT, name: bytes, mode: int, flags: int, ctx: RequestContext\n ) -> tuple[FileInfo, EntryAttributes]:\n path = os.path.join(self._inode_to_path(parent_inode), fsdecode(name))\n try:\n fd = os.open(path, flags | os.O_CREAT | os.O_TRUNC)\n except OSError as exc:\n assert exc.errno is not None\n raise FUSEError(exc.errno)\n attr = self._getattr(fd=fd)\n self._add_path(attr.st_ino, path)\n self._inode_fd_map[attr.st_ino] = fd\n self._fd_inode_map[fd] = attr.st_ino\n self._fd_open_count[fd] = 1\n return (FileInfo(fh=cast(FileHandleT, fd)), attr)\n\n async def read(self, fh: FileHandleT, off: int, size: int) -> bytes:\n os.lseek(fh, off, os.SEEK_SET)\n return os.read(fh, size)\n\n async def write(self, fh: FileHandleT, off: int, buf: bytes) -> int:\n os.lseek(fh, off, os.SEEK_SET)\n return os.write(fh, buf)\n\n async def release(self, fh: FileHandleT) -> None:\n if self._fd_open_count[fh] > 1:\n self._fd_open_count[fh] -= 1\n return\n\n del self._fd_open_count[fh]\n inode = self._fd_inode_map[fh]\n del self._inode_fd_map[inode]\n del self._fd_inode_map[fh]\n try:\n os.close(fh)\n except OSError as exc:\n assert exc.errno is not None\n raise FUSEError(exc.errno)\n\n\ndef init_logging(debug: bool = False) -> None:\n formatter = logging.Formatter(\n '%(asctime)s.%(msecs)03d %(threadName)s: [%(name)s] %(message)s',\n datefmt=\"%Y-%m-%d %H:%M:%S\",\n )\n handler = logging.StreamHandler()\n handler.setFormatter(formatter)\n root_logger = logging.getLogger()\n if debug:\n handler.setLevel(logging.DEBUG)\n root_logger.setLevel(logging.DEBUG)\n else:\n handler.setLevel(logging.INFO)\n root_logger.setLevel(logging.INFO)\n root_logger.addHandler(handler)\n\n\ndef parse_args(args: list[str]) -> Namespace:\n '''Parse command line'''\n\n parser = ArgumentParser()\n\n parser.add_argument('source', type=str, help='Directory tree to mirror')\n parser.add_argument('mountpoint', type=str, help='Where to mount the file system')\n parser.add_argument(\n '--debug', action='store_true', default=False, help='Enable debugging output'\n )\n parser.add_argument(\n '--debug-fuse', action='store_true', default=False, help='Enable FUSE debugging output'\n )\n parser.add_argument(\n '--enable-writeback-cache',\n action='store_true',\n default=False,\n help='Enable writeback cache (default: disabled)',\n )\n\n return parser.parse_args(args)\n\n\ndef main() -> None:\n options = parse_args(sys.argv[1:])\n init_logging(options.debug)\n operations = Operations(options.source, enable_writeback_cache=options.enable_writeback_cache)\n\n log.debug('Mounting...')\n fuse_options = set(pyfuse3.default_options)\n fuse_options.add('fsname=passthroughfs')\n if options.debug_fuse:\n fuse_options.add('debug')\n pyfuse3.init(operations, options.mountpoint, fuse_options)\n\n try:\n log.debug('Entering main loop..')\n trio.run(pyfuse3.main)\n except:\n pyfuse3.close(unmount=False)\n raise\n\n log.debug('Unmounting..')\n pyfuse3.close()\n\n\nif __name__ == '__main__':\n main()\n" }, { "path": "examples/tmpfs.py", "content": "#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n'''\ntmpfs.py - Example file system for pyfuse3.\n\nThis file system stores all data in memory.\n\nCopyright © 2013 Nikolaus Rath \n\nPermission is hereby granted, free of charge, to any person obtaining a copy of\nthis software and associated documentation files (the \"Software\"), to deal in\nthe Software without restriction, including without limitation the rights to\nuse, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\nthe Software, and to permit persons to whom the Software is furnished to do so.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\nFOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\nCOPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\nIN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\nCONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n'''\n\nimport errno\nimport logging\nimport os\nimport sqlite3\nimport stat\nfrom argparse import ArgumentParser, Namespace\nfrom collections import defaultdict\nfrom time import time\nfrom typing import Any, cast\n\nimport trio\n\nimport pyfuse3\nfrom pyfuse3 import (\n EntryAttributes,\n FileHandleT,\n FileInfo,\n FUSEError,\n InodeT,\n ReaddirToken,\n RequestContext,\n SetattrFields,\n StatvfsData,\n)\n\ntry:\n import faulthandler\nexcept ImportError:\n pass\nelse:\n faulthandler.enable()\n\nlog = logging.getLogger()\n\n\nclass Operations(pyfuse3.Operations):\n '''An example filesystem that stores all data in memory\n\n This is a very simple implementation with terrible performance.\n Don't try to store significant amounts of data. Also, there are\n some other flaws that have not been fixed to keep the code easier\n to understand:\n\n * atime, mtime and ctime are not updated\n * generation numbers are not supported\n * lookup counts are not maintained\n '''\n\n enable_writeback_cache = True\n\n def __init__(self) -> None:\n super(Operations, self).__init__()\n self.db: sqlite3.Connection = sqlite3.connect(':memory:')\n self.db.text_factory = str\n self.db.row_factory = sqlite3.Row\n self.cursor: sqlite3.Cursor = self.db.cursor()\n self.inode_open_count: defaultdict[InodeT, int] = defaultdict(int)\n self.init_tables()\n\n def init_tables(self) -> None:\n '''Initialize file system tables'''\n\n self.cursor.execute(\"\"\"\n CREATE TABLE inodes (\n id INTEGER PRIMARY KEY,\n uid INT NOT NULL,\n gid INT NOT NULL,\n mode INT NOT NULL,\n mtime_ns INT NOT NULL,\n atime_ns INT NOT NULL,\n ctime_ns INT NOT NULL,\n target BLOB(256) ,\n size INT NOT NULL DEFAULT 0,\n rdev INT NOT NULL DEFAULT 0,\n data BLOB\n )\n \"\"\")\n\n self.cursor.execute(\"\"\"\n CREATE TABLE contents (\n rowid INTEGER PRIMARY KEY AUTOINCREMENT,\n name BLOB(256) NOT NULL,\n inode INT NOT NULL REFERENCES inodes(id),\n parent_inode INT NOT NULL REFERENCES inodes(id),\n\n UNIQUE (name, parent_inode)\n )\"\"\")\n\n # Insert root directory\n now_ns = int(time() * 1e9)\n self.cursor.execute(\n \"INSERT INTO inodes (id,mode,uid,gid,mtime_ns,atime_ns,ctime_ns) \"\n \"VALUES (?,?,?,?,?,?,?)\",\n (\n pyfuse3.ROOT_INODE,\n stat.S_IFDIR\n | stat.S_IRUSR\n | stat.S_IWUSR\n | stat.S_IXUSR\n | stat.S_IRGRP\n | stat.S_IXGRP\n | stat.S_IROTH\n | stat.S_IXOTH,\n os.getuid(),\n os.getgid(),\n now_ns,\n now_ns,\n now_ns,\n ),\n )\n self.cursor.execute(\n \"INSERT INTO contents (name, parent_inode, inode) VALUES (?,?,?)\",\n (b'..', pyfuse3.ROOT_INODE, pyfuse3.ROOT_INODE),\n )\n\n def get_row(self, *a: Any, **kw: Any) -> sqlite3.Row:\n self.cursor.execute(*a, **kw)\n try:\n row = next(self.cursor)\n except StopIteration:\n raise NoSuchRowError()\n try:\n next(self.cursor)\n except StopIteration:\n pass\n else:\n raise NoUniqueValueError()\n\n return row\n\n async def lookup(\n self, parent_inode: InodeT, name: bytes, ctx: RequestContext\n ) -> EntryAttributes:\n if name == b'.':\n inode = parent_inode\n elif name == b'..':\n inode = self.get_row(\"SELECT * FROM contents WHERE inode=?\", (parent_inode,))[\n 'parent_inode'\n ]\n else:\n try:\n inode = self.get_row(\n \"SELECT * FROM contents WHERE name=? AND parent_inode=?\", (name, parent_inode)\n )['inode']\n except NoSuchRowError:\n raise (pyfuse3.FUSEError(errno.ENOENT))\n\n return await self.getattr(InodeT(inode), ctx)\n\n async def getattr(self, inode: InodeT, ctx: RequestContext | None = None) -> EntryAttributes:\n try:\n row = self.get_row(\"SELECT * FROM inodes WHERE id=?\", (inode,))\n except NoSuchRowError:\n raise (pyfuse3.FUSEError(errno.ENOENT))\n\n entry = EntryAttributes()\n entry.st_ino = inode\n entry.generation = 0\n entry.entry_timeout = 300\n entry.attr_timeout = 300\n entry.st_mode = row['mode']\n entry.st_nlink = self.get_row(\"SELECT COUNT(inode) FROM contents WHERE inode=?\", (inode,))[\n 0\n ]\n entry.st_uid = row['uid']\n entry.st_gid = row['gid']\n entry.st_rdev = row['rdev']\n entry.st_size = row['size']\n\n entry.st_blksize = 512\n entry.st_blocks = 1\n entry.st_atime_ns = row['atime_ns']\n entry.st_mtime_ns = row['mtime_ns']\n entry.st_ctime_ns = row['ctime_ns']\n\n return entry\n\n async def readlink(self, inode: InodeT, ctx: RequestContext) -> bytes:\n return self.get_row('SELECT * FROM inodes WHERE id=?', (inode,))['target']\n\n async def opendir(self, inode: InodeT, ctx: RequestContext) -> FileHandleT:\n # For simplicity, we use the inode as file handle\n return FileHandleT(inode)\n\n async def readdir(self, fh: FileHandleT, start_id: int, token: ReaddirToken) -> None:\n if start_id == 0:\n off = -1\n else:\n off = start_id\n\n cursor2 = self.db.cursor()\n cursor2.execute(\n \"SELECT * FROM contents WHERE parent_inode=? AND rowid > ? ORDER BY rowid\", (fh, off)\n )\n\n for row in cursor2:\n pyfuse3.readdir_reply(\n token, row['name'], await self.getattr(InodeT(row['inode'])), row['rowid']\n )\n\n async def unlink(self, parent_inode: InodeT, name: bytes, ctx: RequestContext) -> None:\n entry = await self.lookup(parent_inode, name, ctx)\n\n if stat.S_ISDIR(entry.st_mode):\n raise pyfuse3.FUSEError(errno.EISDIR)\n\n self._remove(parent_inode, name, entry)\n\n async def rmdir(self, parent_inode: InodeT, name: bytes, ctx: RequestContext) -> None:\n entry = await self.lookup(parent_inode, name, ctx)\n\n if not stat.S_ISDIR(entry.st_mode):\n raise pyfuse3.FUSEError(errno.ENOTDIR)\n\n self._remove(parent_inode, name, entry)\n\n def _remove(self, parent_inode: InodeT, name: bytes, entry: EntryAttributes) -> None:\n if (\n self.get_row(\"SELECT COUNT(inode) FROM contents WHERE parent_inode=?\", (entry.st_ino,))[\n 0\n ]\n > 0\n ):\n raise pyfuse3.FUSEError(errno.ENOTEMPTY)\n\n self.cursor.execute(\n \"DELETE FROM contents WHERE name=? AND parent_inode=?\", (name, parent_inode)\n )\n\n if entry.st_nlink == 1 and entry.st_ino not in self.inode_open_count:\n self.cursor.execute(\"DELETE FROM inodes WHERE id=?\", (entry.st_ino,))\n\n async def symlink(\n self, parent_inode: InodeT, name: bytes, target: bytes, ctx: RequestContext\n ) -> EntryAttributes:\n mode = (\n stat.S_IFLNK\n | stat.S_IRUSR\n | stat.S_IWUSR\n | stat.S_IXUSR\n | stat.S_IRGRP\n | stat.S_IWGRP\n | stat.S_IXGRP\n | stat.S_IROTH\n | stat.S_IWOTH\n | stat.S_IXOTH\n )\n return await self._create(parent_inode, name, mode, ctx, target=target)\n\n async def rename(\n self,\n parent_inode_old: InodeT,\n name_old: bytes,\n parent_inode_new: InodeT,\n name_new: bytes,\n flags: int,\n ctx: RequestContext,\n ) -> None:\n if flags != 0:\n raise FUSEError(errno.EINVAL)\n\n entry_old = await self.lookup(parent_inode_old, name_old, ctx)\n\n entry_new = None\n try:\n entry_new = await self.lookup(\n parent_inode_new,\n name_new if isinstance(name_new, bytes) else name_new.encode(),\n ctx,\n )\n except pyfuse3.FUSEError as exc:\n if exc.errno != errno.ENOENT:\n raise\n\n if entry_new is not None:\n self._replace(\n parent_inode_old, name_old, parent_inode_new, name_new, entry_old, entry_new\n )\n else:\n self.cursor.execute(\n \"UPDATE contents SET name=?, parent_inode=? WHERE name=? AND parent_inode=?\",\n (name_new, parent_inode_new, name_old, parent_inode_old),\n )\n\n def _replace(\n self,\n parent_inode_old: InodeT,\n name_old: bytes,\n parent_inode_new: InodeT,\n name_new: bytes,\n entry_old: EntryAttributes,\n entry_new: EntryAttributes,\n ) -> None:\n if (\n self.get_row(\n \"SELECT COUNT(inode) FROM contents WHERE parent_inode=?\", (entry_new.st_ino,)\n )[0]\n > 0\n ):\n raise pyfuse3.FUSEError(errno.ENOTEMPTY)\n\n self.cursor.execute(\n \"UPDATE contents SET inode=? WHERE name=? AND parent_inode=?\",\n (entry_old.st_ino, name_new, parent_inode_new),\n )\n self.db.execute(\n 'DELETE FROM contents WHERE name=? AND parent_inode=?', (name_old, parent_inode_old)\n )\n\n if entry_new.st_nlink == 1 and entry_new.st_ino not in self.inode_open_count:\n self.cursor.execute(\"DELETE FROM inodes WHERE id=?\", (entry_new.st_ino,))\n\n async def link(\n self, inode: InodeT, new_parent_inode: InodeT, new_name: bytes, ctx: RequestContext\n ) -> EntryAttributes:\n entry_p = await self.getattr(new_parent_inode, ctx)\n if entry_p.st_nlink == 0:\n log.warning(\n 'Attempted to create entry %s with unlinked parent %d', new_name, new_parent_inode\n )\n raise FUSEError(errno.EINVAL)\n\n self.cursor.execute(\n \"INSERT INTO contents (name, inode, parent_inode) VALUES(?,?,?)\",\n (new_name, inode, new_parent_inode),\n )\n\n return await self.getattr(inode, ctx)\n\n async def setattr(\n self,\n inode: InodeT,\n attr: EntryAttributes,\n fields: SetattrFields,\n fh: FileHandleT | None,\n ctx: RequestContext,\n ) -> EntryAttributes:\n if fields.update_size:\n data = self.get_row('SELECT data FROM inodes WHERE id=?', (inode,))[0]\n if data is None:\n data = b''\n if len(data) < attr.st_size:\n data = data + b'\\0' * (attr.st_size - len(data))\n else:\n data = data[: attr.st_size]\n self.cursor.execute(\n 'UPDATE inodes SET data=?, size=? WHERE id=?',\n (memoryview(data), attr.st_size, inode),\n )\n if fields.update_mode:\n self.cursor.execute('UPDATE inodes SET mode=? WHERE id=?', (attr.st_mode, inode))\n\n if fields.update_uid:\n self.cursor.execute('UPDATE inodes SET uid=? WHERE id=?', (attr.st_uid, inode))\n\n if fields.update_gid:\n self.cursor.execute('UPDATE inodes SET gid=? WHERE id=?', (attr.st_gid, inode))\n\n if fields.update_atime:\n self.cursor.execute(\n 'UPDATE inodes SET atime_ns=? WHERE id=?', (attr.st_atime_ns, inode)\n )\n\n if fields.update_mtime:\n self.cursor.execute(\n 'UPDATE inodes SET mtime_ns=? WHERE id=?', (attr.st_mtime_ns, inode)\n )\n\n if fields.update_ctime:\n self.cursor.execute(\n 'UPDATE inodes SET ctime_ns=? WHERE id=?', (attr.st_ctime_ns, inode)\n )\n else:\n self.cursor.execute(\n 'UPDATE inodes SET ctime_ns=? WHERE id=?', (int(time() * 1e9), inode)\n )\n\n return await self.getattr(inode, ctx)\n\n async def mknod(\n self, parent_inode: InodeT, name: bytes, mode: int, rdev: int, ctx: RequestContext\n ) -> EntryAttributes:\n return await self._create(parent_inode, name, mode, ctx, rdev=rdev)\n\n async def mkdir(\n self, parent_inode: InodeT, name: bytes, mode: int, ctx: RequestContext\n ) -> EntryAttributes:\n return await self._create(parent_inode, name, mode, ctx)\n\n async def statfs(self, ctx: RequestContext) -> StatvfsData:\n stat_ = StatvfsData()\n\n stat_.f_bsize = 512\n stat_.f_frsize = 512\n\n size = self.get_row('SELECT SUM(size) FROM inodes')[0]\n stat_.f_blocks = size // stat_.f_frsize\n stat_.f_bfree = max(size // stat_.f_frsize, 1024)\n stat_.f_bavail = stat_.f_bfree\n\n inodes = self.get_row('SELECT COUNT(id) FROM inodes')[0]\n stat_.f_files = inodes\n stat_.f_ffree = max(inodes, 100)\n stat_.f_favail = stat_.f_ffree\n\n return stat_\n\n async def open(self, inode: InodeT, flags: int, ctx: RequestContext) -> FileInfo:\n self.inode_open_count[inode] += 1\n\n # For simplicity, we use the inode as file handle\n return FileInfo(fh=FileHandleT(inode))\n\n async def access(self, inode: InodeT, mode: int, ctx: RequestContext) -> bool:\n # Yeah, could be a function and has unused arguments\n # pylint: disable=R0201,W0613\n return True\n\n async def create(\n self, parent_inode: InodeT, name: bytes, mode: int, flags: int, ctx: RequestContext\n ) -> tuple[FileInfo, EntryAttributes]:\n # pylint: disable=W0612\n entry = await self._create(parent_inode, name, mode, ctx)\n self.inode_open_count[entry.st_ino] += 1\n # For simplicity, we use the inode as file handle\n return (FileInfo(fh=FileHandleT(entry.st_ino)), entry)\n\n async def _create(\n self,\n parent_inode: InodeT,\n name: bytes,\n mode: int,\n ctx: RequestContext,\n rdev: int = 0,\n target: bytes | None = None,\n ) -> EntryAttributes:\n if (await self.getattr(parent_inode, ctx)).st_nlink == 0:\n log.warning('Attempted to create entry %s with unlinked parent %d', name, parent_inode)\n raise FUSEError(errno.EINVAL)\n\n now_ns = int(time() * 1e9)\n self.cursor.execute(\n 'INSERT INTO inodes (uid, gid, mode, mtime_ns, atime_ns, '\n 'ctime_ns, target, rdev) VALUES(?, ?, ?, ?, ?, ?, ?, ?)',\n (ctx.uid, ctx.gid, mode, now_ns, now_ns, now_ns, target, rdev),\n )\n\n inode = cast(InodeT, self.cursor.lastrowid)\n self.db.execute(\n \"INSERT INTO contents(name, inode, parent_inode) VALUES(?,?,?)\",\n (name, inode, parent_inode),\n )\n return await self.getattr(inode, ctx)\n\n async def read(self, fh: FileHandleT, off: int, size: int) -> bytes:\n data = self.get_row('SELECT data FROM inodes WHERE id=?', (fh,))[0]\n if data is None:\n data = b''\n return data[off : off + size]\n\n async def write(self, fh: FileHandleT, off: int, buf: bytes) -> int:\n data = self.get_row('SELECT data FROM inodes WHERE id=?', (fh,))[0]\n if data is None:\n data = b''\n data = data[:off] + buf + data[off + len(buf) :]\n\n self.cursor.execute(\n 'UPDATE inodes SET data=?, size=? WHERE id=?', (memoryview(data), len(data), fh)\n )\n return len(buf)\n\n async def release(self, fh: FileHandleT) -> None:\n inode = cast(InodeT, fh)\n self.inode_open_count[inode] -= 1\n\n if self.inode_open_count[inode] == 0:\n del self.inode_open_count[inode]\n if (await self.getattr(inode)).st_nlink == 0:\n self.cursor.execute(\"DELETE FROM inodes WHERE id=?\", (inode,))\n\n\nclass NoUniqueValueError(Exception):\n def __str__(self) -> str:\n return 'Query generated more than 1 result row'\n\n\nclass NoSuchRowError(Exception):\n def __str__(self) -> str:\n return 'Query produced 0 result rows'\n\n\ndef init_logging(debug: bool = False) -> None:\n formatter = logging.Formatter(\n '%(asctime)s.%(msecs)03d %(threadName)s: [%(name)s] %(message)s',\n datefmt=\"%Y-%m-%d %H:%M:%S\",\n )\n handler = logging.StreamHandler()\n handler.setFormatter(formatter)\n root_logger = logging.getLogger()\n if debug:\n handler.setLevel(logging.DEBUG)\n root_logger.setLevel(logging.DEBUG)\n else:\n handler.setLevel(logging.INFO)\n root_logger.setLevel(logging.INFO)\n root_logger.addHandler(handler)\n\n\ndef parse_args() -> Namespace:\n '''Parse command line'''\n\n parser = ArgumentParser()\n\n parser.add_argument('mountpoint', type=str, help='Where to mount the file system')\n parser.add_argument(\n '--debug', action='store_true', default=False, help='Enable debugging output'\n )\n parser.add_argument(\n '--debug-fuse', action='store_true', default=False, help='Enable FUSE debugging output'\n )\n\n return parser.parse_args()\n\n\nif __name__ == '__main__':\n options = parse_args()\n init_logging(options.debug)\n operations = Operations()\n\n fuse_options = set(pyfuse3.default_options)\n fuse_options.add('fsname=tmpfs')\n fuse_options.discard('default_permissions')\n if options.debug_fuse:\n fuse_options.add('debug')\n pyfuse3.init(operations, options.mountpoint, fuse_options)\n\n try:\n trio.run(pyfuse3.main)\n except:\n pyfuse3.close(unmount=False)\n raise\n\n pyfuse3.close()\n" }, { "path": "pyproject.toml", "content": "[build-system]\nrequires = [\"setuptools>=78.1.1\", \"setuptools_scm>=8.0\", \"Cython\"]\nbuild-backend = \"build_backend\"\nbackend-path = [\"util\"]\n\n[project]\nname = \"pyfuse3\"\ndynamic = [\"version\"]\ndescription = \"Python 3 bindings for libfuse 3 with async I/O support\"\nreadme = \"README.rst\"\nrequires-python = \">=3.10\"\nlicense = \"LGPL-2.1-or-later\"\nauthors = [\n {name = \"Nikolaus Rath\", email = \"Nikolaus@rath.org\"}\n]\nkeywords = [\"FUSE\", \"python\"]\nclassifiers = [\n \"Development Status :: 5 - Production/Stable\",\n \"Intended Audience :: Developers\",\n \"Programming Language :: Python\",\n \"Topic :: Software Development :: Libraries :: Python Modules\",\n \"Topic :: System :: Filesystems\",\n \"Operating System :: POSIX :: Linux\",\n \"Typing :: Typed\",\n]\ndependencies = [\n \"trio >= 0.15\",\n]\n\n[project.urls]\nHomepage = \"https://github.com/libfuse/pyfuse3\"\n\n[dependency-groups]\ndev = [\n \"pyright>=1.1.407\",\n \"mypy>=1.19.1\",\n \"pytest >= 3.4.0\",\n \"pytest-trio\",\n \"ruff>=0.14.10\",\n \"sphinx\",\n \"twine\",\n]\n\n[tool.setuptools_scm]\n\n[tool.setuptools]\ninclude-package-data = true\n\n[tool.setuptools.packages.find]\nwhere = [\"src\"]\n\n[tool.setuptools.package-data]\npyfuse3 = [\"py.typed\"]\n\n[tool.ruff]\nline-length = 100\nextend-exclude = [\n \"developer-notes/\",\n]\n\n[tool.ruff.lint.isort]\ncombine-as-imports = true\ncase-sensitive = false\n\n\n[tool.ruff.lint]\nignore = [\n \"E731\", # Do not assign a lambda expression, use a def\n]\nextend-select = [\n 'RUF100', # Warn about unused suppressions\n 'I', # Import ordering\n]\n\n[tool.mypy]\nexclude = [ \"^util/.+\", \"^rst/conf.py$\" ]\nwarn_unused_configs = true\ndisallow_untyped_defs = false\ncheck_untyped_defs = true\nwarn_redundant_casts = true\nwarn_unused_ignores = true\n\n[tool.pyright]\ntypeCheckingMode = \"standard\"\nexclude = [ \"**/__pycache__\",\n \"**/.*\",\n \"util/\",\n \"rst/conf.py\" ]\n\n# Need for pyright to resolve tests importing tests/util.py (when pytest runs the\n# test, it adds the tests/ directory to sys.path)\nextraPaths = ['test']\n\n[tool.codespell]\nskip = '.git,*.html,developer-notes/'\nignore-words-list = 're-use,re-used'\n\n[tool.ruff.format]\nquote-style = \"preserve\"\n" }, { "path": "rst/_static/.placeholder", "content": "" }, { "path": "rst/_templates/localtoc.html", "content": "

{{ _('Table Of Contents') }}

\n{{ toctree() }}\n" }, { "path": "rst/about.rst", "content": "=======\n About\n=======\n\n.. include:: ../README.rst\n :start-after: start-intro\n" }, { "path": "rst/asyncio.rst", "content": ".. _asyncio:\n\n=================\n asyncio Support\n=================\n\nBy default, pyfuse3 uses asynchronous I/O using Trio_ (and most of the\ndocumentation assumes that you are using Trio). If you'd rather use asyncio,\nimport the *pyfuse3.asyncio* module and call its *enable()* function before\nusing *pyfuse3*. For example::\n\n import pyfuse3\n import pyfuse3.asyncio\n\n pyfuse3.asyncio.enable()\n\n # Use pyfuse3 as usual from here on.\n\n.. _Trio: https://github.com/python-trio/trio\n" }, { "path": "rst/changes.rst", "content": ".. include:: ../Changes.rst\n" }, { "path": "rst/conf.py", "content": "# -*- coding: utf-8 -*-\n#\n# pyfuse3 documentation build configuration file, created by\n# sphinx-quickstart on Sat Oct 16 14:14:40 2010.\n#\n# This file is execfile()d with the current directory set to its containing dir.\n#\n# Note that not all possible configuration values are present in this\n# autogenerated file.\n#\n# All configuration values have a default; values that are commented out\n# serve to show the default.\n\n# If extensions (or modules to document with autodoc) are in another directory,\n# add these directories to sys.path here. If the directory is relative to the\n# documentation root, use os.path.abspath to make it absolute, like shown here.\n\n# -- General configuration -----------------------------------------------------\n\n# Add any Sphinx extension module names here, as strings. They can be extensions\n# coming with Sphinx (named 'sphinx.ext.*') or your custom ones.\nextensions = ['sphinx.ext.autodoc', 'sphinx.ext.intersphinx']\n\n# Link to Python standard library\nintersphinx_mapping = {\n 'python': ('https://docs.python.org/3/', None),\n 'trio': ('https://trio.readthedocs.io/en/stable/', None),\n}\n\n# Add any paths that contain templates here, relative to this directory.\ntemplates_path = ['_templates']\n\n# The suffix of source filenames.\nsource_suffix = '.rst'\n\nautodoc_docstring_signature = True\n\n# The encoding of source files.\nsource_encoding = 'utf-8'\n\n# The master toctree document.\nmaster_doc = 'index'\n\n# Warn about unresolved references\nnitpicky = True\n\n# General information about the project.\nproject = 'pyfuse3'\ncopyright = '2010-2025, Nikolaus Rath'\n\n# The version info for the project you're documenting, acts as replacement for\n# |version| and |release|, also used in various other places throughout the\n# built documents.\n#\n# The short X.Y version.\ntry:\n from importlib.metadata import version\n\n version = version('pyfuse3')\nexcept Exception:\n # Fallback version if package is not installed\n version = 'dev'\n# The full version, including alpha/beta/rc tags.\nrelease = version\n\n# The language for content autogenerated by Sphinx. Refer to documentation\n# for a list of supported languages.\n# language = None\n\n# There are two options for replacing |today|: either, you set today to some\n# non-false value, then it is used:\n# today = ''\n# Else, today_fmt is used as the format for a strftime call.\n# today_fmt = '%B %d, %Y'\n\n# List of documents that shouldn't be included in the build.\nunused_docs = []\n\n# List of directories, relative to source directory, that shouldn't be searched\n# for source files.\nexclude_trees = []\n\n# The reST default role (used for this markup: `text`) to use for all documents.\ndefault_role = 'py:obj'\nprimary_domain = 'py'\n\n# If true, '()' will be appended to :func: etc. cross-reference text.\nadd_function_parentheses = True\n\n# If true, the current module name will be prepended to all description\n# unit titles (such as .. function::).\nadd_module_names = True\n\n# If true, sectionauthor and moduleauthor directives will be shown in the\n# output. They are ignored by default.\nshow_authors = False\n\n# The name of the Pygments (syntax highlighting) style to use.\npygments_style = 'sphinx'\n# pygments_style = 'colorful'\nhighlight_language = 'python'\n\n# A list of ignored prefixes for module index sorting.\n# modindex_common_prefix = []\n\n\ndef setup(app):\n # Mangle NewTypes re-exported from pyfuse3._pyfuse3 so they appear to\n # come from their canonical location at the top of the package\n import pyfuse3\n\n for name in ('FileHandleT', 'InodeT'):\n getattr(pyfuse3, name).__module__ = 'pyfuse3'\n\n\n# -- Options for HTML output ---------------------------------------------------\n\n# The theme to use for HTML and HTML Help pages. Major themes that come with\n# Sphinx are currently 'default' and 'sphinxdoc'.\nhtml_theme = 'default'\n\n# Theme options are theme-specific and customize the look and feel of a theme\n# further. For a list of options available for each theme, see the\n# documentation.\n# html_theme_options = {}\n\n# Add any paths that contain custom themes here, relative to this directory.\n# html_theme_path = []\n\n# The name for this set of Sphinx documents. If None, it defaults to\n# \" v documentation\".\n# html_title = None\n\n# A shorter title for the navigation bar. Default is the same as html_title.\n# html_short_title = None\n\n# The name of an image file (relative to this directory) to place at the top\n# of the sidebar.\n# html_logo = None\n\n# The name of an image file (within the static path) to use as favicon of the\n# docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32\n# pixels large.\n# html_favicon = None\n\n# Add any paths that contain custom static files (such as style sheets) here,\n# relative to this directory. They are copied after the builtin static files,\n# so a file named \"default.css\" will overwrite the builtin \"default.css\".\nhtml_static_path = ['_static']\n\n# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,\n# using the given strftime format.\n# html_last_updated_fmt = '%b %d, %Y'\n\n# If true, SmartyPants will be used to convert quotes and dashes to\n# typographically correct entities.\n# html_use_smartypants = True\n\n# Custom sidebar templates, maps document names to template names.\n# html_sidebars = {}\n\n# Additional templates that should be rendered to pages, maps page names to\n# template names.\n# html_additional_pages = {}\n\n# If false, no module index is generated.\nhtml_use_modindex = False\n\n# If false, no index is generated.\nhtml_use_index = True\n\n# If true, the index is split into individual pages for each letter.\nhtml_split_index = False\n\n# If true, links to the reST sources are added to the pages.\nhtml_show_sourcelink = False\n\n# If true, an OpenSearch description file will be output, and all pages will\n# contain a tag referring to it. The value of this option must be the\n# base URL from which the finished HTML is served.\n# html_use_opensearch = ''\n\n# If nonempty, this is the file name suffix for HTML files (e.g. \".xhtml\").\n# html_file_suffix = ''\n\n# Output file base name for HTML help builder.\nhtmlhelp_basename = 'pyfuse3doc'\n" }, { "path": "rst/data.rst", "content": "=================\n Data Structures\n=================\n\n.. currentmodule:: pyfuse3\n\n.. py:data:: ENOATTR\n\n This errorcode is unfortunately missing in the `errno` module,\n so it is provided by pyfuse3 instead.\n\n.. py:data:: ROOT_INODE\n\n The inode of the root directory, i.e. the mount point of the file\n system.\n\n.. py:data:: RENAME_EXCHANGE\n\n A flag that may be passed to the `~Operations.rename` handler. When\n passed, the handler must atomically exchange the two paths (which\n must both exist).\n\n.. py:data:: RENAME_NOREPLACE\n\n A flag that may be passed to the `~Operations.rename` handler. When\n passed, the handler must not replace an existing target.\n\n.. py:data:: default_options\n\n This is a recommended set of options that should be passed to\n `pyfuse3.init` to get reasonable behavior and\n performance. pyfuse3 is compatible with any other combination\n of options as well, but you should only deviate from the defaults\n with good reason.\n\n (The :samp:`fsname=` option is guaranteed never to be included in the\n default options, so you can always safely add it to the set).\n\n The default options are:\n\n * ``default_permissions`` enables permission checking by kernel.\n Without this any umask (or uid/gid) would not have an effect.\n\n.. autoexception:: FUSEError\n\n.. autoclass currently doesn't work for NewTypes\n.. https://github.com/sphinx-doc/sphinx/issues/11552\n\n.. class:: FileHandleT\n\n A subclass of `int`, representing an integer file handle produced by a\n `~Operations.create`, `~Operations.open`, or `~Operations.opendir` call.\n\n.. class:: FileNameT\n\n A subclass of `bytes`, representing a file name, with no embedded\n zero-bytes (``\\0``).\n\n.. class:: FlagT\n\n A subclass of `int`, representing flags modifying the behavior of an\n operation.\n\n.. class:: InodeT\n\n A subclass of `int`, representing an inode number.\n\n.. class:: ModeT\n\n A subclass of `int`, representing a file mode.\n\n.. class:: XAttrNameT\n\n A subclass of `bytes`, representing an extended attribute name, with no\n embedded zero-bytes (``\\0``).\n\n.. autoclass:: RequestContext\n\n .. attribute:: pid\n\n .. attribute:: uid\n\n .. attribute:: gid\n\n .. attribute:: umask\n\n.. autoclass:: StatvfsData\n\n .. attribute:: f_bsize\n\n .. attribute:: f_frsize\n\n .. attribute:: f_blocks\n\n .. attribute:: f_bfree\n\n .. attribute:: f_bavail\n\n .. attribute:: f_files\n\n .. attribute:: f_ffree\n\n .. attribute:: f_favail\n\n .. attribute:: f_namemax\n\n.. autoclass:: EntryAttributes\n\n .. autoattribute:: st_ino\n\n .. autoattribute:: generation\n\n .. autoattribute:: entry_timeout\n\n .. autoattribute:: attr_timeout\n\n .. autoattribute:: st_mode\n\n .. autoattribute:: st_nlink\n\n .. autoattribute:: st_uid\n\n .. autoattribute:: st_gid\n\n .. autoattribute:: st_rdev\n\n .. autoattribute:: st_size\n\n .. autoattribute:: st_blksize\n\n .. autoattribute:: st_blocks\n\n .. autoattribute:: st_atime_ns\n\n .. autoattribute:: st_ctime_ns\n\n .. autoattribute:: st_mtime_ns\n\n.. autoclass:: FileInfo\n\n .. autoattribute:: fh\n\n This attribute must be set to the file handle to be returned from\n `Operations.open`.\n\n .. autoattribute:: direct_io\n\n If true, signals to the kernel that this file should not be cached\n or buffered.\n\n .. autoattribute:: keep_cache\n\n If true, signals to the kernel that previously cached data for this\n inode is still valid, and should not be invalidated.\n\n .. autoattribute:: nonseekable\n\n If true, indicates that the file does not support seeking.\n\n.. autoclass:: SetattrFields\n\n .. attribute:: update_atime\n\n If this attribute is true, it signals the `Operations.setattr`\n method that the `~EntryAttributes.st_atime_ns` field contains an\n updated value.\n\n .. attribute:: update_mtime\n\n If this attribute is true, it signals the `Operations.setattr`\n method that the `~EntryAttributes.st_mtime_ns` field contains an\n updated value.\n\n .. attribute:: update_mode\n\n If this attribute is true, it signals the `Operations.setattr`\n method that the `~EntryAttributes.st_mode` field contains an\n updated value.\n\n .. attribute:: update_uid\n\n If this attribute is true, it signals the `Operations.setattr`\n method that the `~EntryAttributes.st_uid` field contains an\n updated value.\n\n .. attribute:: update_gid\n\n If this attribute is true, it signals the `Operations.setattr`\n method that the `~EntryAttributes.st_gid` field contains an\n updated value.\n\n .. attribute:: update_size\n\n If this attribute is true, it signals the `Operations.setattr`\n method that the `~EntryAttributes.st_size` field contains an\n updated value.\n\n.. autoclass:: ReaddirToken\n\n An identifier for a particular `~Operations.readdir` invocation.\n" }, { "path": "rst/example.rst", "content": ".. _example file system:\n\n======================\n Example File Systems\n======================\n\npyfuse3 comes with several example file systems in the\n:file:`examples` directory of the release tarball. For completeness,\nthese examples are also included here.\n\nSingle-file, Read-only File System\n==================================\n\n(shipped as :file:`examples/lltest.py`)\n\n.. literalinclude:: ../examples/hello.py\n :linenos:\n :language: python\n\nIn-memory File System\n=====================\n\n(shipped as :file:`examples/tmpfs.py`)\n\n.. literalinclude:: ../examples/tmpfs.py\n :linenos:\n :language: python\n\n\nPassthrough / Overlay File System\n=================================\n\n(shipped as :file:`examples/passthroughfs.py`)\n\n.. literalinclude:: ../examples/passthroughfs.py\n :linenos:\n :language: python\n" }, { "path": "rst/fuse_api.rst", "content": "====================\n FUSE API Functions\n====================\n\n.. currentmodule:: pyfuse3\n\n.. autofunction:: init\n.. autofunction:: main\n.. autofunction:: terminate\n.. autofunction:: close\n.. autofunction:: invalidate_inode\n.. autofunction:: invalidate_entry\n.. autofunction:: invalidate_entry_async\n.. autofunction:: notify_store\n.. autofunction:: readdir_reply\n\n.. py:data:: trio_token\n\n Set to the value returned by `trio.lowlevel.current_trio_token` while `main` is\n running. Can be used by other threads to run code in the main loop through\n `trio.from_thread.run`.\n" }, { "path": "rst/general.rst", "content": "=====================\n General Information\n=====================\n\n.. currentmodule:: pyfuse3\n\n.. _getting_started:\n\nGetting started\n===============\n\nA file system is implemented by subclassing the `pyfuse3.Operations`\nclass and implementing the various request handlers. The handlers\nrespond to requests received from the FUSE kernel module and perform\nfunctions like looking up the inode given a file name, looking up\nattributes of an inode, opening a (file) inode for reading or writing\nor listing the contents of a (directory) inode.\n\nBy default, pyfuse3 uses asynchronous I/O using Trio_, and most of the\ndocumentation assumes that you are using Trio. If you'd rather use\nasyncio, take a look at :ref:`asyncio Support `. If you would\nlike to use Trio (which is recommended) but you have not yet used Trio\nbefore, please read the `Trio tutorial`_ first.\n\nAn instance of the operations class is passed to `pyfuse3.init` to\nmount the file system. To enter the request handling loop, run\n`pyfuse3.main` in a trio event loop. This function will return when\nthe file system should be unmounted again, which is done by calling\n`pyfuse3.close`.\n\nAll character data (directory entry names, extended attribute names\nand values, symbolic link targets etc) are passed as `bytes` and must\nbe returned as `bytes`.\n\nFor easier debugging, it is strongly recommended that applications\nusing pyfuse3 also make use of the faulthandler_ module.\n\n.. _faulthandler: http://docs.python.org/3/library/faulthandler.html\n.. _Trio tutorial: https://trio.readthedocs.io/en/latest/tutorial.html\n.. _Trio: https://github.com/python-trio/trio\n\nLookup Counts\n=============\n\nMost file systems need to keep track which inodes are currently known\nto the kernel. This is, for example, necessary to correctly implement\nthe *unlink* system call: when unlinking a directory entry whose\nassociated inode is currently opened, the file system must defer\nremoval of the inode (and thus the file contents) until it is no\nlonger in use by any process.\n\nFUSE file systems achieve this by using \"lookup counts\". A lookup\ncount is a number that's associated with an inode. An inode with a\nlookup count of zero is currently not known to the kernel. This means\nthat if there are no directory entries referring to such an inode it\ncan be safely removed, or (if a file system implements dynamic inode\nnumbers), the inode number can be safely recycled.\n\nThe lookup count of an inode is increased by every operation that\ncould make the inode \"known\" to the kernel. This includes e.g.\n`~Operations.lookup`, `~Operations.create` and `~Operations.readdir`\n(to determine if a given request handler affects the lookup count,\nplease refer to its description in the `Operations` class). The\nlookup count is decreased by calls to the `~Operations.forget`\nhandler.\n\n\nFUSE and VFS Locking\n====================\n\nFUSE and the kernel's VFS layer provide some basic locking that FUSE\nfile systems automatically take advantage of. Specifically:\n\n* Calls to `~Operations.rename`, `~Operations.create`,\n `~Operations.symlink`, `~Operations.mknod`, `~Operations.link` and\n `~Operations.mkdir` acquire a write-lock on the inode of the\n directory in which the respective operation takes place (two in case\n of rename).\n\n* Calls to `~Operations.lookup` acquire a read-lock on the inode of the\n parent directory (meaning that lookups in the same directory may run\n concurrently, but never at the same time as e.g. a rename or mkdir\n operation).\n\n* Unless writeback caching is enabled, calls to `~Operations.write`\n for the same inode are automatically serialized (i.e., there are\n never concurrent calls for the same inode even when multithreading\n is enabled).\n" }, { "path": "rst/gotchas.rst", "content": "================\n Common Gotchas\n================\n\n.. currentmodule:: pyfuse3\n\nThis chapter lists some common gotchas that should be avoided.\n\n\nRemoving inodes in unlink handler\n=================================\n\nIf your file system is mounted at :file:`mnt`, the following code\nshould complete without errors::\n\n with open('mnt/file_one', 'w+') as fh1:\n fh1.write('foo')\n fh1.flush()\n with open('mnt/file_one', 'a') as fh2:\n os.unlink('mnt/file_one')\n assert 'file_one' not in os.listdir('mnt')\n fh2.write('bar')\n os.close(os.dup(fh1.fileno()))\n fh1.seek(0)\n assert fh1.read() == 'foobar'\n\nIf you're getting an error, then you probably did a mistake when\nimplementing the `~Operations.unlink` handler and are removing the\nfile contents when you should be deferring removal to the\n`~Operations.forget` handler.\n" }, { "path": "rst/index.rst", "content": "=============================\n pyfuse3 Documentation\n=============================\n\nTable of Contents\n-----------------\n\n.. module:: pyfuse3\n\n.. toctree::\n :maxdepth: 1\n\n about.rst\n install.rst\n general.rst\n asyncio.rst\n fuse_api.rst\n data.rst\n operations.rst\n util.rst\n gotchas.rst\n example.rst\n changes.rst\n\nIndices and tables\n------------------\n\n* :ref:`genindex`\n* :ref:`search`\n" }, { "path": "rst/install.rst", "content": "==============\n Installation\n==============\n\n.. highlight:: sh\n\n\nDependencies\n============\n\nAs usual, Python dependencies are specified in :file:`pyproject.toml`. However, to build pyfuse3 you\nalso need the following additional dependencies installed on your system:\n\n* libfuse_, version 3.3.0 or newer, including development\n headers (typically distributions provide them in a *libfuse3-devel*\n or *libfuse3-dev* package).\n* the `pkg-config`_ tool\n* the `attr`_ library\n* Python development headers (for example, the *python3-dev* or\n *python3-devel* package on many Linux distributions)\n* A C compiler\n\n\nStable releases\n===============\n\nTo install a stable pyfuse3 release, ensure you have the non-Python dependencies\ninstalled and then use your favorite Python package manager to install pyfuse3 from\nPyPI (e.g. ``pip install pyfuse3``).\n\n\nInstalling from Git / Developing pyfuse3\n========================================\n\nClone the pyfuse3_ repository and take a look at :file:`developer_notes/setup.md`.\n\n\n\n.. _libfuse: http://github.com/libfuse/libfuse\n.. _attr: http://savannah.nongnu.org/projects/attr/\n.. _`pkg-config`: http://www.freedesktop.org/wiki/Software/pkg-config\n.. _pyfuse3: https://github.com/libfuse/pyfuse3/\n" }, { "path": "rst/operations.rst", "content": "==================\n Request Handlers\n==================\n\n(You can use the :ref:`genindex` to directly jump to a specific handler).\n\n.. currentmodule:: pyfuse3\n\n.. autoclass:: Operations\n :members:\n\n .. attribute:: supports_dot_lookup = True\n\n If set, indicates that the filesystem supports lookup of the\n ``.`` and ``..`` entries. This is required if the file system\n will be shared over NFS.\n\n .. attribute:: enable_writeback_cache = True\n\n Enables write-caching in the kernel if available. This means that\n individual write request may be buffered and merged in the kernel\n before they are send to the filesystem.\n\n .. attribute:: enable_acl = False\n\n Enable ACL support. When enabled, the kernel will cache and have\n responsibility for enforcing ACLs. ACL will be stored as xattrs\n and passed to userspace, which is responsible for updating the\n ACLs in the filesystem, keeping the file mode in sync with the\n ACL, and ensuring inheritance of default ACLs when new filesystem\n nodes are created. Note that this requires that the file system\n is able to parse and interpret the xattr representation of ACLs.\n\n Enabling this feature implicitly turns on the\n ``default_permissions`` option.\n" }, { "path": "rst/util.rst", "content": "====================\n Utility Functions\n====================\n\nThe following functions do not necessarily translate to calls to the\nFUSE library. They are provided because they're potentially useful\nwhen implementing file systems in Python.\n\n.. currentmodule:: pyfuse3\n\n.. autofunction:: setxattr\n.. autofunction:: getxattr\n.. autofunction:: listdir\n.. autofunction:: get_sup_groups\n.. autofunction:: syncfs\n" }, { "path": "src/pyfuse3/__init__.pyi", "content": "'''\n__init__.pyi\n\nType annotation stubs for the external API in __init__.pyx.\n\nCopyright © 2021 Oliver Galvin\n\nThis file is part of pyfuse3. This work may be distributed under\nthe terms of the GNU LGPL.\n'''\n\nfrom typing import List, Literal, Mapping, Optional, Union\n\nfrom trio.lowlevel import TrioToken\n\n# Need to explicitly import with the same name to prevent mypy from\n# complaining that these types do not exist.\nfrom ._pyfuse3 import (\n FileHandleT as FileHandleT,\n FileNameT as FileNameT,\n FlagT as FlagT,\n InodeT as InodeT,\n ModeT as ModeT,\n Operations as Operations,\n XAttrNameT as XAttrNameT,\n)\n\nENOATTR: int\nRENAME_EXCHANGE: FlagT\nRENAME_NOREPLACE: FlagT\nROOT_INODE: InodeT\ntrio_token: Optional[TrioToken]\n__version__: str\n_NANOS_PER_SEC: int\n\nNamespaceT = Literal[\"system\", \"user\"]\nStatDict = Mapping[str, int]\n\ndefault_options: frozenset[str]\n\nclass ReaddirToken:\n pass\n\nclass RequestContext:\n @property\n def uid(self) -> int: ...\n @property\n def pid(self) -> int: ...\n @property\n def gid(self) -> int: ...\n @property\n def umask(self) -> int: ...\n def __getstate__(self) -> None: ...\n\nclass SetattrFields:\n @property\n def update_atime(self) -> bool: ...\n @property\n def update_mtime(self) -> bool: ...\n @property\n def update_ctime(self) -> bool: ...\n @property\n def update_mode(self) -> bool: ...\n @property\n def update_uid(self) -> bool: ...\n @property\n def update_gid(self) -> bool: ...\n @property\n def update_size(self) -> bool: ...\n def __init__(self) -> None: ...\n def __getstate__(self) -> None: ...\n\nclass EntryAttributes:\n st_ino: InodeT\n generation: int\n entry_timeout: Union[float, int]\n attr_timeout: Union[float, int]\n st_mode: ModeT\n st_nlink: int\n st_uid: int\n st_gid: int\n st_rdev: int\n st_size: int\n st_blksize: int\n st_blocks: int\n st_atime_ns: int\n st_ctime_ns: int\n st_mtime_ns: int\n st_birthtime_ns: int\n\n def __init__(self) -> None: ...\n def __getstate__(self) -> StatDict: ...\n def __setstate__(self, state: StatDict) -> None: ...\n\nclass FileInfo:\n fh: FileHandleT\n direct_io: bool\n keep_cache: bool\n nonseekable: bool\n\n def __init__(\n self,\n fh: FileHandleT = ...,\n direct_io: bool = ...,\n keep_cache: bool = ...,\n nonseekable: bool = ...,\n ) -> None: ...\n\nclass StatvfsData:\n f_bsize: int\n f_frsize: int\n f_blocks: int\n f_bfree: int\n f_bavail: int\n f_files: int\n f_ffree: int\n f_favail: int\n f_namemax: int\n\n def __init__(self) -> None: ...\n def __getstate__(self) -> StatDict: ...\n def __setstate__(self, state: StatDict) -> None: ...\n\nclass FUSEError(Exception):\n @property\n def errno(self) -> int: ...\n @property\n def errno_(self) -> int: ...\n def __init__(self, errno: int) -> None: ...\n def __str__(self) -> str: ...\n\nclass PollHandle:\n def __getstate__(self) -> None: ...\n def notify(self) -> None: ...\n\ndef listdir(path: str) -> List[str]: ...\ndef syncfs(path: str) -> str: ...\ndef setxattr(path: str, name: str, value: bytes, namespace: NamespaceT = ...) -> None: ...\ndef getxattr(path: str, name: str, size_guess: int = ..., namespace: NamespaceT = ...) -> bytes: ...\ndef init(ops: Operations, mountpoint: str, options: set[str] = ...) -> None: ...\nasync def main(min_tasks: int = ..., max_tasks: int = ...) -> None: ...\ndef terminate() -> None: ...\ndef close(unmount: bool = ...) -> None: ...\ndef invalidate_inode(inode: InodeT, attr_only: bool = ...) -> None: ...\ndef invalidate_entry(inode_p: InodeT, name: FileNameT, deleted: InodeT = ...) -> None: ...\ndef invalidate_entry_async(\n inode_p: InodeT, name: FileNameT, deleted: InodeT = ..., ignore_enoent: bool = ...\n) -> None: ...\ndef notify_store(inode: InodeT, offset: int, data: bytes) -> None: ...\ndef get_sup_groups(pid: int) -> set[int]: ...\ndef readdir_reply(\n token: ReaddirToken, name: FileNameT, attr: EntryAttributes, next_id: int\n) -> bool: ...\n" }, { "path": "src/pyfuse3/__init__.pyx", "content": "'''\n__init__.pyx\n\nCopyright © 2013 Nikolaus Rath \n\nThis file is part of pyfuse3. This work may be distributed under\nthe terms of the GNU LGPL.\n'''\n\ncdef extern from \"pyfuse3.h\":\n int PLATFORM\n enum:\n PLATFORM_LINUX\n PLATFORM_BSD\n PLATFORM_DARWIN\n\n###########\n# C IMPORTS\n###########\n\nfrom fuse_lowlevel cimport *\nfrom .macros cimport *\nfrom posix.stat cimport struct_stat, S_IFMT, S_IFDIR, S_IFREG\nfrom posix.types cimport mode_t, dev_t, off_t\nfrom libc.stdint cimport uint32_t\nfrom libc.stdlib cimport const_char\nfrom libc cimport stdlib, string, errno\nfrom posix cimport unistd\nfrom libc.errno cimport EACCES, ETIMEDOUT, EPROTO, EINVAL, ENOMSG, ENOATTR\nfrom posix.unistd cimport getpid\nfrom posix.time cimport timespec\nfrom cpython.bytes cimport (PyBytes_AsStringAndSize, PyBytes_FromStringAndSize,\n PyBytes_AsString, PyBytes_FromString, PyBytes_AS_STRING)\nfrom cpython.buffer cimport (PyObject_GetBuffer, PyBuffer_Release,\n PyBUF_CONTIG_RO, PyBUF_CONTIG)\ncimport cpython.exc\ncimport cython\ncimport libc_extra\n\n\n########################\n# EXTERNAL DEFINITIONS #\n########################\n\n\ncdef extern from \"\" nogil:\n enum:\n RENAME_EXCHANGE\n RENAME_NOREPLACE\n\ncdef extern from \"Python.h\" nogil:\n int PY_SSIZE_T_MAX\n\n################\n# PYTHON IMPORTS\n################\n\nfrom pickle import PicklingError\nfrom queue import Queue\nimport logging\nimport os\nimport os.path\nimport sys\nimport trio\nimport threading\nimport typing\n\nfrom . import _pyfuse3\n_pyfuse3.FUSEError = FUSEError\n\nfrom ._pyfuse3 import (Operations, async_wrapper, FileHandleT, FileNameT,\n FlagT, InodeT, ModeT, XAttrNameT)\n\n\n##################\n# GLOBAL VARIABLES\n##################\n\nlog = logging.getLogger(\"pyfuse3\")\nfse = sys.getfilesystemencoding()\n\ncdef object operations\ncdef object mountpoint_b\ncdef fuse_session* session = NULL\ncdef fuse_lowlevel_ops fuse_ops\ncdef int session_fd\ncdef object py_retval\n\ncdef object _notify_queue = None\n\nROOT_INODE = FUSE_ROOT_ID\n__version__ = _pyfuse3.__version__\n\n_NANOS_PER_SEC = 1000000000\n\n# In the Cython source, we want the names to refer to the\n# C constants. Therefore, we assign through globals().\ng = globals()\ng['ENOATTR'] = ENOATTR\ng['RENAME_EXCHANGE'] = RENAME_EXCHANGE\ng['RENAME_NOREPLACE'] = RENAME_NOREPLACE\n\ntrio_token = None\n\n\n#######################\n# FUSE REQUEST HANDLERS\n#######################\n\ninclude \"handlers.pxi\"\n\n\n########################################\n# INTERNAL FUNCTIONS & DATA STRUCTURES #\n########################################\n\ninclude \"internal.pxi\"\n\n\n######################\n# EXTERNAL API #\n######################\n\n@cython.freelist(10)\ncdef class RequestContext:\n '''\n Instances of this class are passed to some `Operations` methods to\n provide information about the caller of the syscall that initiated\n the request.\n '''\n\n cdef readonly uid_t uid\n cdef readonly pid_t pid\n cdef readonly gid_t gid\n cdef readonly mode_t umask\n\n def __getstate__(self):\n raise PicklingError(\"RequestContext instances can't be pickled\")\n\n\n@cython.freelist(10)\ncdef class SetattrFields:\n '''\n `SetattrFields` instances are passed to the `~Operations.setattr` handler\n to specify which attributes should be updated.\n '''\n\n cdef readonly object update_atime\n cdef readonly object update_mtime\n cdef readonly object update_ctime\n cdef readonly object update_mode\n cdef readonly object update_uid\n cdef readonly object update_gid\n cdef readonly object update_size\n\n def __cinit__(self):\n self.update_atime = False\n self.update_mtime = False\n self.update_ctime = False\n self.update_mode = False\n self.update_uid = False\n self.update_gid = False\n self.update_size = False\n\n def __getstate__(self):\n raise PicklingError(\"SetattrFields instances can't be pickled\")\n\n\n@cython.freelist(30)\ncdef class EntryAttributes:\n '''\n Instances of this class store attributes of directory entries.\n Most of the attributes correspond to the elements of the ``stat``\n C struct as returned by e.g. ``fstat`` and should be\n self-explanatory.\n '''\n\n # Attributes are documented in rst/data.rst\n\n cdef fuse_entry_param fuse_param\n cdef struct_stat *attr\n\n def __cinit__(self):\n string.memset(&self.fuse_param, 0, sizeof(fuse_entry_param))\n self.attr = &self.fuse_param.attr\n self.fuse_param.generation = 0\n self.fuse_param.entry_timeout = 300\n self.fuse_param.attr_timeout = 300\n\n self.attr.st_mode = S_IFREG\n self.attr.st_blksize = 4096\n self.attr.st_nlink = 1\n\n @property\n def st_ino(self):\n return self.fuse_param.ino\n @st_ino.setter\n def st_ino(self, val):\n self.fuse_param.ino = val\n self.attr.st_ino = val\n\n @property\n def generation(self):\n '''The inode generation number'''\n return self.fuse_param.generation\n @generation.setter\n def generation(self, val):\n self.fuse_param.generation = val\n\n @property\n def attr_timeout(self):\n '''Validity timeout for the attributes of the directory entry\n\n Floating point numbers may be used. Units are seconds.\n '''\n return self.fuse_param.attr_timeout\n @attr_timeout.setter\n def attr_timeout(self, val):\n self.fuse_param.attr_timeout = val\n\n @property\n def entry_timeout(self):\n '''Validity timeout for the name/existence of the directory entry\n\n Floating point numbers may be used. Units are seconds.\n '''\n return self.fuse_param.entry_timeout\n @entry_timeout.setter\n def entry_timeout(self, val):\n self.fuse_param.entry_timeout = val\n\n @property\n def st_mode(self):\n return self.attr.st_mode\n @st_mode.setter\n def st_mode(self, val):\n self.attr.st_mode = val\n\n @property\n def st_nlink(self):\n return self.attr.st_nlink\n @st_nlink.setter\n def st_nlink(self, val):\n self.attr.st_nlink = val\n\n @property\n def st_uid(self):\n return self.attr.st_uid\n @st_uid.setter\n def st_uid(self, val):\n self.attr.st_uid = val\n\n @property\n def st_gid(self):\n return self.attr.st_gid\n @st_gid.setter\n def st_gid(self, val):\n self.attr.st_gid = val\n\n @property\n def st_rdev(self):\n return self.attr.st_rdev\n @st_rdev.setter\n def st_rdev(self, val):\n self.attr.st_rdev = val\n\n @property\n def st_size(self):\n return self.attr.st_size\n @st_size.setter\n def st_size(self, val):\n self.attr.st_size = val\n\n @property\n def st_blocks(self):\n return self.attr.st_blocks\n @st_blocks.setter\n def st_blocks(self, val):\n self.attr.st_blocks = val\n\n @property\n def st_blksize(self):\n return self.attr.st_blksize\n @st_blksize.setter\n def st_blksize(self, val):\n self.attr.st_blksize = val\n\n @property\n def st_atime_ns(self):\n '''Time of last access in (integer) nanoseconds'''\n return (int(self.attr.st_atime) * _NANOS_PER_SEC + GET_ATIME_NS(self.attr))\n @st_atime_ns.setter\n def st_atime_ns(self, val):\n self.attr.st_atime = val // _NANOS_PER_SEC\n SET_ATIME_NS(self.attr, val % _NANOS_PER_SEC)\n\n @property\n def st_mtime_ns(self):\n '''Time of last modification in (integer) nanoseconds'''\n return (int(self.attr.st_mtime) * _NANOS_PER_SEC + GET_MTIME_NS(self.attr))\n @st_mtime_ns.setter\n def st_mtime_ns(self, val):\n self.attr.st_mtime = val // _NANOS_PER_SEC\n SET_MTIME_NS(self.attr, val % _NANOS_PER_SEC)\n\n @property\n def st_ctime_ns(self):\n '''Time of last inode modification in (integer) nanoseconds'''\n return (int(self.attr.st_ctime) * _NANOS_PER_SEC + GET_CTIME_NS(self.attr))\n @st_ctime_ns.setter\n def st_ctime_ns(self, val):\n self.attr.st_ctime = val // _NANOS_PER_SEC\n SET_CTIME_NS(self.attr, val % _NANOS_PER_SEC)\n\n @property\n def st_birthtime_ns(self):\n '''Time of inode creation in (integer) nanoseconds.\n\n Only available under BSD and OS X. Will be zero on Linux.\n '''\n\n # Use C macro to prevent compiler error on Linux\n # (where st_birthtime does not exist)\n return int(GET_BIRTHTIME(self.attr) * _NANOS_PER_SEC\n + GET_BIRTHTIME_NS(self.attr))\n\n @st_birthtime_ns.setter\n def st_birthtime_ns(self, val):\n # Use C macro to prevent compiler error on Linux\n # (where st_birthtime does not exist)\n SET_BIRTHTIME(self.attr, val // _NANOS_PER_SEC)\n SET_BIRTHTIME_NS(self.attr, val % _NANOS_PER_SEC)\n\n # Pickling and copy support\n def __getstate__(self):\n state = dict()\n for k in ('st_ino', 'generation', 'entry_timeout', 'attr_timeout',\n 'st_mode', 'st_nlink', 'st_uid', 'st_gid', 'st_rdev',\n 'st_size', 'st_blksize', 'st_blocks', 'st_atime_ns',\n 'st_ctime_ns', 'st_mtime_ns', 'st_birthtime_ns'):\n state[k] = getattr(self, k)\n return state\n\n def __setstate__(self, state):\n for (k,v) in state.items():\n setattr(self, k, v)\n\n\n@cython.freelist(10)\ncdef class FileInfo:\n '''\n Instances of this class store options and data that `Operations.open`\n returns. The attributes correspond to the elements of the ``fuse_file_info``\n struct that are relevant to the `Operations.open` function.\n '''\n\n cdef public uint64_t fh\n cdef public bint direct_io\n cdef public bint keep_cache\n cdef public bint nonseekable\n\n def __cinit__(self, fh=0, direct_io=0, keep_cache=1, nonseekable=0):\n self.fh = fh\n self.direct_io = direct_io\n self.keep_cache = keep_cache\n self.nonseekable = nonseekable\n\n cdef _copy_to_fuse(self, fuse_file_info *out):\n out.fh = self.fh\n\n # Due to how Cython generates its C code, GCC will complain about\n # assigning to the bitfields in the fuse_file_info struct.\n # This is the workaround.\n if self.direct_io:\n out.direct_io = 1\n else:\n out.direct_io = 0\n\n if self.keep_cache:\n out.keep_cache = 1\n else:\n out.keep_cache = 0\n\n if self.nonseekable:\n out.nonseekable = 1\n else:\n out.nonseekable = 0\n\n\n@cython.freelist(1)\ncdef class StatvfsData:\n '''\n Instances of this class store information about the file system.\n The attributes correspond to the elements of the ``statvfs``\n struct, see :manpage:`statvfs(2)` for details.\n '''\n\n cdef statvfs stat\n\n def __cinit__(self):\n string.memset(&self.stat, 0, sizeof(statvfs))\n\n @property\n def f_bsize(self):\n return self.stat.f_bsize\n @f_bsize.setter\n def f_bsize(self, val):\n self.stat.f_bsize = val\n\n @property\n def f_frsize(self):\n return self.stat.f_frsize\n @f_frsize.setter\n def f_frsize(self, val):\n self.stat.f_frsize = val\n\n @property\n def f_blocks(self):\n return self.stat.f_blocks\n @f_blocks.setter\n def f_blocks(self, val):\n self.stat.f_blocks = val\n\n @property\n def f_bfree(self):\n return self.stat.f_bfree\n @f_bfree.setter\n def f_bfree(self, val):\n self.stat.f_bfree = val\n\n @property\n def f_bavail(self):\n return self.stat.f_bavail\n @f_bavail.setter\n def f_bavail(self, val):\n self.stat.f_bavail = val\n\n @property\n def f_files(self):\n return self.stat.f_files\n @f_files.setter\n def f_files(self, val):\n self.stat.f_files = val\n\n @property\n def f_ffree(self):\n return self.stat.f_ffree\n @f_ffree.setter\n def f_ffree(self, val):\n self.stat.f_ffree = val\n\n @property\n def f_favail(self):\n return self.stat.f_favail\n @f_favail.setter\n def f_favail(self, val):\n self.stat.f_favail = val\n\n @property\n def f_namemax(self):\n return self.stat.f_namemax\n @f_namemax.setter\n def f_namemax(self, val):\n self.stat.f_namemax = val\n\n # Pickling and copy support\n def __getstate__(self):\n state = dict()\n for k in ('f_bsize', 'f_frsize', 'f_blocks', 'f_bfree',\n 'f_bavail', 'f_files', 'f_ffree', 'f_favail',\n 'f_namemax'):\n state[k] = getattr(self, k)\n return state\n\n def __setstate__(self, state):\n for (k,v) in state.items():\n setattr(self, k, v)\n\n\n# As of Cython 0.28.1, @cython.freelist cannot be used for\n# classes that derive from a builtin type.\ncdef class FUSEError(Exception):\n '''\n This exception may be raised by request handlers to indicate that\n the requested operation could not be carried out. The system call\n that resulted in the request (if any) will then fail with error\n code *errno_*.\n '''\n\n # If we call this variable \"errno\", we will get syntax errors\n # during C compilation (maybe something else declares errno as\n # a macro?)\n cdef readonly int errno_\n\n @property\n def errno(self):\n '''Error code to return to client process'''\n return self.errno_\n\n def __cinit__(self, errno):\n self.errno_ = errno\n\n def __str__(self):\n return strerror(self.errno_)\n\n\n@cython.freelist(10)\ncdef class PollHandle:\n '''\n Opaque handle for delivering poll(2) readiness notifications.\n\n Instances of this class are created by pyfuse3 and passed to\n `Operations.poll`. The filesystem may keep a reference and later\n call `PollHandle.notify` on the handle to wake up any process currently\n blocked in :manpage:`poll(2)`, :manpage:`select(2)` or\n :manpage:`epoll_wait(2)` for the corresponding file descriptor.\n\n A single notification is sufficient to clear all pending waiters;\n filesystems should normally discard the handle after notifying.\n\n The underlying ``fuse_pollhandle`` is automatically destroyed when\n the Python object is garbage collected, so filesystems should simply\n drop the reference when the notification is no longer needed.\n '''\n\n cdef fuse_pollhandle *_ph\n\n def __cinit__(self):\n self._ph = NULL\n\n def __init__(self):\n raise TypeError('PollHandle cannot be instantiated directly')\n\n @staticmethod\n cdef PollHandle from_ptr(fuse_pollhandle *ph):\n cdef PollHandle self\n\n if ph == NULL:\n raise ValueError('NULL fuse_pollhandle')\n\n self = PollHandle.__new__(PollHandle)\n self._ph = ph\n return self\n\n def __dealloc__(self):\n if self._ph is not NULL:\n fuse_pollhandle_destroy(self._ph)\n self._ph = NULL\n\n def __getstate__(self):\n raise PicklingError(\"PollHandle instances can't be pickled\")\n\n def notify(self):\n '''\n Notify IO readiness for this poll handle.\n\n After this returns, any process waiting in :manpage:`poll(2)`,\n :manpage:`select(2)` or :manpage:`epoll_wait(2)` on the\n corresponding file descriptor will be woken so it can re-poll\n the filesystem for the current readiness mask.\n\n Each `PollHandle` is intended for a single notification. After a\n successful call, the filesystem should not call `notify_poll` again on\n the same handle and should discard it.\n '''\n\n cdef int ret\n\n if self._ph == NULL:\n raise RuntimeError('PollHandle is no longer valid')\n\n with nogil:\n ret = fuse_lowlevel_notify_poll(self._ph)\n\n if ret != 0:\n raise OSError(-ret, 'fuse_lowlevel_notify_poll returned: ' + strerror(-ret))\n\n\ndef listdir(path):\n '''Like `os.listdir`, but releases the GIL.\n\n This function returns an iterator over the directory entries in *path*.\n\n The returned values are of type :ref:`str `. Surrogate\n escape coding (cf. `PEP 383 `_)\n is used for directory names that do not have a string representation.\n '''\n\n if not isinstance(path, str):\n raise TypeError('*path* argument must be of type str')\n\n cdef libc_extra.DIR* dirp\n cdef libc_extra.dirent* res\n cdef char* buf\n\n path_b = str2bytes(path)\n buf = path_b\n\n with nogil:\n dirp = libc_extra.opendir(buf)\n\n if dirp == NULL:\n raise OSError(errno.errno, strerror(errno.errno), path)\n\n names = list()\n while True:\n errno.errno = 0\n with nogil:\n res = libc_extra.readdir(dirp)\n\n if res is NULL:\n if errno.errno != 0:\n raise OSError(errno.errno, strerror(errno.errno), path)\n else:\n break\n if string.strcmp(res.d_name, b'.') == 0 or \\\n string.strcmp(res.d_name, b'..') == 0:\n continue\n\n names.append(bytes2str(PyBytes_FromString(res.d_name)))\n\n with nogil:\n libc_extra.closedir(dirp)\n\n return names\n\n\ndef syncfs(path):\n '''Sync filesystem mounted at *path*\n\n This is a Python interface to the syncfs(2) system call. There is no\n particular relation to libfuse, it is provided by pyfuse3 as a convenience.\n '''\n\n cdef int ret\n\n fd = os.open(path, flags=os.O_DIRECTORY)\n try:\n ret = libc_extra.syncfs(fd)\n\n if ret != 0:\n raise OSError(errno.errno, strerror(errno.errno), path)\n finally:\n os.close(fd)\n\n\ndef setxattr(path, name, bytes value, namespace='user'):\n '''Set extended attribute\n\n *path* and *name* have to be of type `str`. In Python 3.x, they may\n contain surrogates. *value* has to be of type `bytes`.\n\n Under FreeBSD, the *namespace* parameter may be set to *system* or *user* to\n select the namespace for the extended attribute. For other platforms, this\n parameter is ignored.\n\n In contrast to the `os.setxattr` function from the standard library, the\n method provided by pyfuse3 is also available for non-Linux systems.\n '''\n\n if not isinstance(path, str):\n raise TypeError('*path* argument must be of type str')\n\n if not isinstance(name, str):\n raise TypeError('*name* argument must be of type str')\n\n if namespace not in ('system', 'user'):\n raise ValueError('*namespace* parameter must be \"system\" or \"user\", not %s'\n % namespace)\n\n cdef int ret\n cdef Py_ssize_t len_\n cdef char *cvalue\n cdef char *cpath\n cdef char *cname\n cdef int cnamespace\n\n if namespace == 'system':\n cnamespace = libc_extra.EXTATTR_NAMESPACE_SYSTEM\n else:\n cnamespace = libc_extra.EXTATTR_NAMESPACE_USER\n\n path_b = str2bytes(path)\n name_b = str2bytes(name)\n PyBytes_AsStringAndSize(value, &cvalue, &len_)\n cpath = path_b\n cname = name_b\n\n with nogil:\n # len_ is guaranteed positive\n ret = libc_extra.setxattr_p(\n cpath, cname, cvalue, len_, cnamespace)\n\n if ret != 0:\n raise OSError(errno.errno, strerror(errno.errno), path)\n\n\ndef getxattr(path, name, size_t size_guess=128, namespace='user'):\n '''Get extended attribute\n\n *path* and *name* have to be of type `str`. In Python 3.x, they may\n contain surrogates. Returns a value of type `bytes`.\n\n If the caller knows the approximate size of the attribute value,\n it should be supplied in *size_guess*. If the guess turns out\n to be wrong, the system call has to be carried out three times\n (the first call will fail, the second determines the size and\n the third finally gets the value).\n\n Under FreeBSD, the *namespace* parameter may be set to *system* or *user* to\n select the namespace for the extended attribute. For other platforms, this\n parameter is ignored.\n\n In contrast to the `os.getxattr` function from the standard library, the\n method provided by pyfuse3 is also available for non-Linux systems.\n '''\n\n if not isinstance(path, str):\n raise TypeError('*path* argument must be of type str')\n\n if not isinstance(name, str):\n raise TypeError('*name* argument must be of type str')\n\n if namespace not in ('system', 'user'):\n raise ValueError('*namespace* parameter must be \"system\" or \"user\", not %s'\n % namespace)\n\n cdef ssize_t ret\n cdef char *buf\n cdef char *cpath\n cdef char *cname\n cdef size_t bufsize\n cdef int cnamespace\n\n if namespace == 'system':\n cnamespace = libc_extra.EXTATTR_NAMESPACE_SYSTEM\n else:\n cnamespace = libc_extra.EXTATTR_NAMESPACE_USER\n\n path_b = str2bytes(path)\n name_b = str2bytes(name)\n cpath = path_b\n cname = name_b\n\n bufsize = size_guess\n buf = stdlib.malloc(bufsize * sizeof(char))\n\n if buf is NULL:\n cpython.exc.PyErr_NoMemory()\n\n try:\n with nogil:\n ret = libc_extra.getxattr_p(cpath, cname, buf, bufsize, cnamespace)\n\n if ret < 0 and errno.errno == errno.ERANGE:\n with nogil:\n ret = libc_extra.getxattr_p(cpath, cname, NULL, 0, cnamespace)\n if ret < 0:\n raise OSError(errno.errno, strerror(errno.errno), path)\n bufsize = ret\n stdlib.free(buf)\n buf = stdlib.malloc(bufsize * sizeof(char))\n if buf is NULL:\n cpython.exc.PyErr_NoMemory()\n\n with nogil:\n ret = libc_extra.getxattr_p(cpath, cname, buf, bufsize, cnamespace)\n\n if ret < 0:\n raise OSError(errno.errno, strerror(errno.errno), path)\n\n return PyBytes_FromStringAndSize(buf, ret)\n\n finally:\n stdlib.free(buf)\n\n\ndefault_options = frozenset(('default_permissions',))\n\ndef init(ops, mountpoint, options=default_options):\n '''Initialize and mount FUSE file system\n\n *ops* has to be an instance of the `Operations` class (or another\n class defining the same methods).\n\n *args* has to be a set of strings. `default_options` provides some\n reasonable defaults. It is recommended to use these options as a basis and\n add or remove options as necessary. For example::\n\n my_opts = set(pyfuse3.default_options)\n my_opts.add('allow_other')\n my_opts.discard('default_permissions')\n pyfuse3.init(ops, mountpoint, my_opts)\n\n Valid options are listed under ``struct\n fuse_opt fuse_mount_opts[]``\n (in `mount.c `_)\n and ``struct fuse_opt fuse_ll_opts[]``\n (in `fuse_lowlevel_c `_).\n '''\n\n log.debug('Initializing pyfuse3')\n cdef fuse_args f_args\n cdef int res\n\n if not isinstance(mountpoint, str):\n raise TypeError('*mountpoint_* argument must be of type str')\n\n global operations\n global fuse_ops\n global mountpoint_b\n global session\n global session_fd\n global worker_data\n\n worker_data = _WorkerData()\n mountpoint_b = str2bytes(os.path.abspath(mountpoint))\n operations = ops\n\n make_fuse_args(options, &f_args)\n\n log.debug('Calling fuse_session_new')\n init_fuse_ops()\n session = fuse_session_new(&f_args, &fuse_ops, sizeof(fuse_ops), NULL)\n if not session:\n raise RuntimeError(\"fuse_session_new() failed\")\n\n log.debug('Calling fuse_session_mount')\n res = fuse_session_mount(session, mountpoint_b)\n if res != 0:\n raise RuntimeError('fuse_session_mount failed')\n\n session_fd = fuse_session_fd(session)\n\n\n@async_wrapper\nasync def main(int min_tasks=1, int max_tasks=99):\n '''Run FUSE main loop'''\n\n if session == NULL:\n raise RuntimeError('Need to call init() before main()')\n\n global trio_token\n trio_token = trio.lowlevel.current_trio_token()\n\n try:\n async with trio.open_nursery() as nursery:\n worker_data.task_count = 1\n worker_data.task_serial = 1\n nursery.start_soon(_session_loop, nursery, min_tasks, max_tasks,\n name=worker_data.get_name())\n finally:\n trio_token = None\n if _notify_queue is not None:\n _notify_queue.put(None)\n\n\ndef terminate():\n '''Terminate FUSE main loop.\n\n This function gracefully terminates the FUSE main loop (resulting in the call to\n main() to return).\n\n When called by a thread different from the one that runs the main loop, the call must\n be wrapped with `trio.from_thread.run_sync`. The necessary *trio_token* argument can\n (for convenience) be retrieved from the `trio_token` module attribute.\n '''\n\n fuse_session_exit(session)\n trio.lowlevel.notify_closing(session_fd)\n\n\ndef close(unmount=True):\n '''Clean up and ensure filesystem is unmounted\n\n If *unmount* is False, only clean up operations are performed, but the file\n system is not explicitly unmounted.\n\n Normally, the filesystem is unmounted by the user calling umount(8) or\n fusermount(1), which then terminates the FUSE main loop. However, the loop\n may also terminate as a result of an exception or a signal. In this case the\n filesystem remains mounted, but any attempt to access it will block (while\n the filesystem process is still running) or (after the filesystem process\n has terminated) return an error. If *unmount* is True, this function will\n ensure that the filesystem is properly unmounted.\n\n Note: if the connection to the kernel is terminated via the\n ``/sys/fs/fuse/connections/`` interface, this function will *not* unmount\n the filesystem even if *unmount* is True.\n '''\n\n global mountpoint_b\n global session\n\n if unmount:\n log.debug('Calling fuse_session_unmount')\n fuse_session_unmount(session)\n\n log.debug('Calling fuse_session_destroy')\n fuse_session_destroy(session)\n\n mountpoint_b = None\n session = NULL\n\n\ndef invalidate_inode(fuse_ino_t inode, attr_only=False):\n '''Invalidate cache for *inode*\n\n Instructs the FUSE kernel module to forget cached attributes and\n data (unless *attr_only* is True) for *inode*.\n\n **This operation may block** if writeback caching is active and there is\n dirty data for the inode that is to be invalidated. Unfortunately there is\n no way to return control to the event loop until writeback is complete\n (leading to a deadlock if the necessary write() requests cannot be processed\n by the filesystem). Unless writeback caching is disabled, this function\n should therefore be called from a separate thread.\n\n If the operation is not supported by the kernel, raises `OSError`\n with errno ENOSYS.\n '''\n\n cdef int ret\n if attr_only:\n with nogil:\n ret = fuse_lowlevel_notify_inval_inode(session, inode, -1, 0)\n else:\n with nogil:\n ret = fuse_lowlevel_notify_inval_inode(session, inode, 0, 0)\n\n if ret != 0:\n raise OSError(-ret, 'fuse_lowlevel_notify_inval_inode returned: ' + strerror(-ret))\n\n\ndef invalidate_entry(fuse_ino_t inode_p, bytes name, fuse_ino_t deleted=0):\n '''Invalidate directory entry\n\n Instructs the FUSE kernel module to forget about the directory entry *name*\n in the directory with inode *inode_p*.\n\n If the inode passed as *deleted* matches the inode that is currently\n associated with *name* by the kernel, any inotify watchers of this inode are\n informed that the entry has been deleted.\n\n If there is a pending filesystem operation that is related to the parent\n directory or directory entry, this function will block until that operation\n has completed. Therefore, to avoid a deadlock this function must not be\n called while handling a related request, nor while holding a lock that could\n be needed for handling such a request.\n\n As for kernel 4.18, a \"related operation\" is a `~Operations.lookup`,\n `~Operations.symlink`, `~Operations.mknod`, `~Operations.mkdir`,\n `~Operations.unlink`, `~Operations.rename`, `~Operations.link` or\n `~Operations.create` request for the parent, and a `~Operations.setattr`,\n `~Operations.unlink`, `~Operations.rmdir`, `~Operations.rename`,\n `~Operations.setxattr`, `~Operations.removexattr` or `~Operations.readdir`\n request for the inode itself.\n\n For technical reasons, this function can also not return control to the main\n event loop but will actually block. To return control to the event loop\n while this function is running, call it in a separate thread using\n `trio.run_sync_in_worker_thread\n `_.\n A less complicated alternative is to use the `invalidate_entry_async` function\n instead.\n '''\n\n cdef char *cname\n cdef ssize_t slen\n cdef size_t len_\n cdef int ret\n\n PyBytes_AsStringAndSize(name, &cname, &slen)\n # len_ is guaranteed positive\n len_ = slen\n\n if deleted:\n with nogil: # might block!\n ret = fuse_lowlevel_notify_delete(session, inode_p, deleted, cname, len_)\n if ret != 0:\n raise OSError(-ret, 'fuse_lowlevel_notify_delete returned: '\n + strerror(-ret))\n else:\n with nogil: # might block!\n ret = fuse_lowlevel_notify_inval_entry(session, inode_p, cname, len_)\n if ret != 0:\n raise OSError(-ret, 'fuse_lowlevel_notify_inval_entry returned: '\n + strerror(-ret))\n\n\ndef invalidate_entry_async(inode_p, name, deleted=0, ignore_enoent=False):\n '''Asynchronously invalidate directory entry\n\n This function performs the same operation as `invalidate_entry`, but does so\n asynchronously in a separate thread. This avoids the deadlocks that may\n occur when using `invalidate_entry` from within a request handler, but means\n that the function generally returns before the kernel has actually\n invalidated the entry, and that no errors can be reported (they will be\n logged though).\n\n The directory entries that are to be invalidated are put in an unbounded\n queue which is processed by a single thread. This means that if the entry at\n the beginning of the queue cannot be invalidated yet because a related file\n system operation is still in progress, none of the other entries will be\n processed and repeated calls to this function will result in continued\n growth of the queue.\n\n If there are errors, an exception is logged using the `logging` module.\n\n If *ignore_enoent* is True, ignore ENOENT errors (which occur if the\n kernel doesn't actually have knowledge of the entry that is to be\n removed).\n '''\n\n global _notify_queue\n\n if _notify_queue is None:\n log.debug('Starting notify worker.')\n _notify_queue = Queue()\n t = threading.Thread(target=_notify_loop)\n t.daemon = True\n t.start()\n\n _notify_queue.put((inode_p, name, deleted, ignore_enoent))\n\n\ndef notify_store(inode, offset, data):\n '''Store data in kernel page cache\n\n Sends *data* for the kernel to store it in the page cache for *inode* at\n *offset*. If this provides data beyond the current file size, the file is\n automatically extended.\n\n If this function raises an exception, the store may still have completed\n partially.\n\n If the operation is not supported by the kernel, raises `OSError`\n with errno ENOSYS.\n '''\n\n # This should not block, but the kernel may need to do some work so release\n # the GIL to give other threads a chance to run.\n\n cdef int ret\n cdef fuse_ino_t ino\n cdef off_t off\n cdef Py_buffer pybuf\n cdef fuse_bufvec bufvec\n cdef fuse_buf *buf\n\n PyObject_GetBuffer(data, &pybuf, PyBUF_CONTIG_RO)\n bufvec.count = 1\n bufvec.idx = 0\n bufvec.off = 0\n\n buf = bufvec.buf\n buf[0].flags = 0\n buf[0].mem = pybuf.buf\n buf[0].size = pybuf.len # guaranteed positive\n\n ino = inode\n off = offset\n with nogil:\n ret = fuse_lowlevel_notify_store(session, ino, off, &bufvec, 0)\n\n PyBuffer_Release(&pybuf)\n if ret != 0:\n raise OSError(-ret, 'fuse_lowlevel_notify_store returned: ' + strerror(-ret))\n\n\ndef get_sup_groups(pid):\n '''Return supplementary group ids of *pid*\n\n This function is relatively expensive because it has to read the group ids\n from ``/proc/[pid]/status``. For the same reason, it will also not work on\n systems that do not provide a ``/proc`` file system.\n\n Returns a set.\n '''\n\n with open('/proc/%d/status' % pid, 'r') as fh:\n for line in fh:\n if line.startswith('Groups:'):\n break\n else:\n raise RuntimeError(\"Unable to parse %s\" % fh.name)\n gids = set()\n for x in line.split()[1:]:\n gids.add(int(x))\n\n return gids\n\n\ndef readdir_reply(ReaddirToken token, name, EntryAttributes attr, off_t next_id):\n '''Report a directory entry in response to a `~Operations.readdir` request.\n\n This function should be called by the `~Operations.readdir` handler to\n provide the list of directory entries. The function should be called\n once for each directory entry, until it returns False.\n\n *token* must be the token received by the `~Operations.readdir` handler.\n\n *name* and must be the name of the directory entry and *attr* an\n `EntryAttributes` instance holding its attributes.\n\n *next_id* must be a 64-bit integer value that uniquely identifies the\n current position in the list of directory entries. It may be passed back\n to a later `~Operations.readdir` call to start another listing at the\n right position. This value should be robust in the presence of file\n removals and creations, i.e. if files are created or removed after a\n call to `~Operations.readdir` and `~Operations.readdir` is called again\n with *start_id* set to any previously supplied *next_id* values, under\n no circumstances must any file be reported twice or skipped over.\n '''\n\n cdef char *cname\n\n if token.buf_start == NULL:\n token.buf_start = calloc_or_raise(token.size, sizeof(char))\n token.buf = token.buf_start\n\n cname = PyBytes_AsString(name)\n len_ = fuse_add_direntry_plus(token.req, token.buf, token.size,\n cname, &attr.fuse_param, next_id)\n if len_ > token.size:\n return False\n\n token.size -= len_\n token.buf = &token.buf[len_]\n return True\n" }, { "path": "src/pyfuse3/_pyfuse3.py", "content": "'''\n_pyfuse3.py\n\nPure-Python components of pyfuse3.\n\nCopyright © 2018 Nikolaus Rath \n\nThis file is part of pyfuse3. This work may be distributed under\nthe terms of the GNU LGPL.\n'''\n\nimport errno\nimport functools\nimport logging\nfrom importlib.metadata import PackageNotFoundError, version as package_version\nfrom typing import TYPE_CHECKING, Any, Callable, NewType, Optional, Sequence, Tuple\n\n# Version information\ntry:\n __version__ = package_version('pyfuse3')\nexcept PackageNotFoundError:\n __version__ = 'unknown'\n\n# These types are specific instances of builtin types:\nFileHandleT = NewType(\"FileHandleT\", int)\nFileNameT = bytes\nFlagT = int\nInodeT = NewType(\"InodeT\", int)\nModeT = int\nXAttrNameT = bytes\n\nif TYPE_CHECKING:\n # These types are defined elsewhere in the C code\n from pyfuse3 import (\n EntryAttributes,\n FileInfo,\n FUSEError,\n PollHandle,\n ReaddirToken,\n RequestContext,\n SetattrFields,\n StatvfsData,\n )\nelse:\n # Will be injected by pyfuse3 extension module\n FUSEError = None\n\n__all__ = ['Operations', 'async_wrapper']\n\nlog = logging.getLogger(__name__)\n\n\n# Any top level trio coroutines (i.e., coroutines that are passed\n# to trio.run) must be pure-Python. This wrapper ensures that this\n# is the case for Cython-defined async functions.\ndef async_wrapper(fn: Callable[..., Any]) -> Callable[..., Any]:\n @functools.wraps(fn)\n async def wrapper(*args, **kwargs):\n await fn(*args, **kwargs)\n\n return wrapper\n\n\nclass Operations:\n '''\n This class defines the request handler methods that an pyfuse3 file system\n may implement. If a particular request handler has not been implemented, it\n must raise `FUSEError` with an errorcode of `errno.ENOSYS`. Further requests\n of this type will then be handled directly by the FUSE kernel module without\n calling the handler again.\n\n The only exception that request handlers are allowed to raise is\n `FUSEError`. This will cause the specified errno to be returned by the\n syscall that is being handled.\n\n It is recommended that file systems are derived from this class and only\n overwrite the handlers that they actually implement. (The methods defined in\n this class all just raise ``FUSEError(ENOSYS)`` or do nothing).\n '''\n\n supports_dot_lookup: bool = True\n enable_writeback_cache: bool = False\n enable_acl: bool = False\n\n def init(self) -> None:\n '''Initialize operations.\n\n This method will be called just before the file system starts handling\n requests. It must not raise any exceptions (not even `FUSEError`), since\n it is not handling a particular client request.\n '''\n\n pass\n\n async def lookup(\n self, parent_inode: InodeT, name: FileNameT, ctx: \"RequestContext\"\n ) -> \"EntryAttributes\":\n '''Look up a directory entry by name and get its attributes.\n\n This method should return an `EntryAttributes` instance for the\n directory entry *name* in the directory with inode *parent_inode*.\n\n If there is no such entry, the method should either return an\n `EntryAttributes` instance with zero ``st_ino`` value (in which case\n the negative lookup will be cached as specified by ``entry_timeout``),\n or it should raise `FUSEError` with an errno of `errno.ENOENT` (in this\n case the negative result will not be cached).\n\n *ctx* will be a `RequestContext` instance.\n\n The file system must be able to handle lookups for :file:`.` and\n :file:`..`, no matter if these entries are returned by `readdir` or not.\n\n (Successful) execution of this handler increases the lookup count for\n the returned inode by one.\n '''\n\n raise FUSEError(errno.ENOSYS)\n\n async def forget(self, inode_list: Sequence[Tuple[InodeT, int]]) -> None:\n '''Decrease lookup counts for inodes in *inode_list*.\n\n *inode_list* is a list of ``(inode, nlookup)`` tuples. This method\n should reduce the lookup count for each *inode* by *nlookup*.\n\n If the lookup count reaches zero, the inode is currently not known to\n the kernel. In this case, the file system will typically check if there\n are still directory entries referring to this inode and, if not, remove\n the inode.\n\n If the file system is unmounted, it may not have received `forget` calls\n to bring all lookup counts to zero. The filesystem needs to take care to\n clean up inodes that at that point still have non-zero lookup count\n (e.g. by explicitly calling `forget` with the current lookup count for\n every such inode after `main` has returned).\n\n This method must not raise any exceptions (not even `FUSEError`), since\n it is not handling a particular client request.\n '''\n\n pass\n\n async def getattr(self, inode: InodeT, ctx: \"RequestContext\") -> \"EntryAttributes\":\n '''Get attributes for *inode*.\n\n *ctx* will be a `RequestContext` instance.\n\n This method should return an `EntryAttributes` instance with the\n attributes of *inode*. The `~EntryAttributes.entry_timeout` attribute is\n ignored in this context.\n '''\n\n raise FUSEError(errno.ENOSYS)\n\n async def setattr(\n self,\n inode: InodeT,\n attr: \"EntryAttributes\",\n fields: \"SetattrFields\",\n fh: Optional[FileHandleT],\n ctx: \"RequestContext\",\n ) -> \"EntryAttributes\":\n '''Change attributes of *inode*.\n\n *fields* will be an `SetattrFields` instance that specifies which\n attributes are to be updated. *attr* will be an `EntryAttributes`\n instance for *inode* that contains the new values for changed\n attributes, and undefined values for all other attributes.\n\n Most file systems will additionally set the\n `~EntryAttributes.st_ctime_ns` attribute to the current time (to\n indicate that the inode metadata was changed).\n\n If the syscall that is being processed received a file descriptor\n argument (like e.g. :manpage:`ftruncate(2)` or :manpage:`fchmod(2)`),\n *fh* will be the file handle returned by the corresponding call to the\n `open` handler. If the syscall was path based (like\n e.g. :manpage:`truncate(2)` or :manpage:`chmod(2)`), *fh* will be\n `None`.\n\n *ctx* will be a `RequestContext` instance.\n\n The method should return an `EntryAttributes` instance (containing both\n the changed and unchanged values).\n '''\n\n raise FUSEError(errno.ENOSYS)\n\n async def readlink(self, inode: InodeT, ctx: \"RequestContext\") -> FileNameT:\n '''Return target of symbolic link *inode*.\n\n *ctx* will be a `RequestContext` instance.\n '''\n\n raise FUSEError(errno.ENOSYS)\n\n async def mknod(\n self,\n parent_inode: InodeT,\n name: FileNameT,\n mode: ModeT,\n rdev: int,\n ctx: \"RequestContext\",\n ) -> \"EntryAttributes\":\n '''Create (possibly special) file.\n\n This method must create a (special or regular) file *name* in the\n directory with inode *parent_inode*. Whether the file is special or\n regular is determined by its *mode*. If the file is neither a block nor\n character device, *rdev* can be ignored. *ctx* will be a\n `RequestContext` instance.\n\n The method must return an `EntryAttributes` instance with the attributes\n of the newly created directory entry.\n\n (Successful) execution of this handler increases the lookup count for\n the returned inode by one.\n '''\n\n raise FUSEError(errno.ENOSYS)\n\n async def mkdir(\n self, parent_inode: InodeT, name: FileNameT, mode: ModeT, ctx: \"RequestContext\"\n ) -> \"EntryAttributes\":\n '''Create a directory.\n\n This method must create a new directory *name* with mode *mode* in the\n directory with inode *parent_inode*. *ctx* will be a `RequestContext`\n instance.\n\n This method must return an `EntryAttributes` instance with the\n attributes of the newly created directory entry.\n\n (Successful) execution of this handler increases the lookup count for\n the returned inode by one.\n '''\n\n raise FUSEError(errno.ENOSYS)\n\n async def unlink(self, parent_inode: InodeT, name: FileNameT, ctx: \"RequestContext\") -> None:\n '''Remove a (possibly special) file.\n\n This method must remove the (special or regular) file *name* from the\n directory with inode *parent_inode*. *ctx* will be a `RequestContext`\n instance.\n\n If the inode associated with *file* (i.e., not the *parent_inode*) has a\n non-zero lookup count, or if there are still other directory entries\n referring to this inode (due to hardlinks), the file system must remove\n only the directory entry (so that future calls to `readdir` for\n *parent_inode* will no longer include *name*, but e.g. calls to\n `getattr` for *file*'s inode still succeed). (Potential) removal of the\n associated inode with the file contents and metadata must be deferred to\n the `forget` method to be carried out when the lookup count reaches zero\n (and of course only if at that point there are no more directory entries\n associated with the inode either).\n '''\n\n raise FUSEError(errno.ENOSYS)\n\n async def rmdir(self, parent_inode: InodeT, name: FileNameT, ctx: \"RequestContext\") -> None:\n '''Remove directory *name*.\n\n This method must remove the directory *name* from the directory with\n inode *parent_inode*. *ctx* will be a `RequestContext` instance. If\n there are still entries in the directory, the method should raise\n ``FUSEError(errno.ENOTEMPTY)``.\n\n If the inode associated with *name* (i.e., not the *parent_inode*) has a\n non-zero lookup count, the file system must remove only the directory\n entry (so that future calls to `readdir` for *parent_inode* will no\n longer include *name*, but e.g. calls to `getattr` for *file*'s inode\n still succeed). Removal of the associated inode holding the directory\n contents and metadata must be deferred to the `forget` method to be\n carried out when the lookup count reaches zero.\n\n (Since hard links to directories are not allowed by POSIX, this method\n is not required to check if there are still other directory entries\n referring to the same inode. This conveniently avoids the ambiguities\n associated with the ``.`` and ``..`` entries).\n '''\n\n raise FUSEError(errno.ENOSYS)\n\n async def symlink(\n self,\n parent_inode: InodeT,\n name: FileNameT,\n target: FileNameT,\n ctx: \"RequestContext\",\n ) -> \"EntryAttributes\":\n '''Create a symbolic link.\n\n This method must create a symbolink link named *name* in the directory\n with inode *parent_inode*, pointing to *target*. *ctx* will be a\n `RequestContext` instance.\n\n The method must return an `EntryAttributes` instance with the attributes\n of the newly created directory entry.\n\n (Successful) execution of this handler increases the lookup count for\n the returned inode by one.\n '''\n\n raise FUSEError(errno.ENOSYS)\n\n async def rename(\n self,\n parent_inode_old: InodeT,\n name_old: FileNameT,\n parent_inode_new: InodeT,\n name_new: FileNameT,\n flags: FlagT,\n ctx: \"RequestContext\",\n ) -> None:\n '''Rename a directory entry.\n\n This method must rename *name_old* in the directory with inode\n *parent_inode_old* to *name_new* in the directory with inode\n *parent_inode_new*. If *name_new* already exists, it should be\n overwritten.\n\n *flags* may be `RENAME_EXCHANGE` or `RENAME_NOREPLACE`. If\n `RENAME_NOREPLACE` is specified, the filesystem must not overwrite\n *name_new* if it exists and return an error instead. If\n `RENAME_EXCHANGE` is specified, the filesystem must atomically exchange\n the two files, i.e. both must exist and neither may be deleted.\n\n *ctx* will be a `RequestContext` instance.\n\n Let the inode associated with *name_old* in *parent_inode_old* be\n *inode_moved*, and the inode associated with *name_new* in\n *parent_inode_new* (if it exists) be called *inode_deref*.\n\n If *inode_deref* exists and has a non-zero lookup count, or if there are\n other directory entries referring to *inode_deref*), the file system\n must update only the directory entry for *name_new* to point to\n *inode_moved* instead of *inode_deref*. (Potential) removal of\n *inode_deref* (containing the previous contents of *name_new*) must be\n deferred to the `forget` method to be carried out when the lookup count\n reaches zero (and of course only if at that point there are no more\n directory entries associated with *inode_deref* either).\n '''\n\n raise FUSEError(errno.ENOSYS)\n\n async def link(\n self,\n inode: InodeT,\n new_parent_inode: InodeT,\n new_name: FileNameT,\n ctx: \"RequestContext\",\n ) -> \"EntryAttributes\":\n '''Create directory entry *name* in *parent_inode* referring to *inode*.\n\n *ctx* will be a `RequestContext` instance.\n\n The method must return an `EntryAttributes` instance with the\n attributes of the newly created directory entry.\n\n (Successful) execution of this handler increases the lookup count for\n the returned inode by one.\n '''\n\n raise FUSEError(errno.ENOSYS)\n\n async def open(self, inode: InodeT, flags: FlagT, ctx: \"RequestContext\") -> \"FileInfo\":\n '''Open a inode *inode* with *flags*.\n\n *ctx* will be a `RequestContext` instance.\n\n *flags* will be a bitwise or of the open flags described in the\n :manpage:`open(2)` manpage and defined in the `os` module (with the\n exception of ``O_CREAT``, ``O_EXCL``, ``O_NOCTTY`` and ``O_TRUNC``)\n\n This method must return a `FileInfo` instance. The `FileInfo.fh` field\n must contain an integer file handle, which will be passed to the `read`,\n `write`, `flush`, `fsync` and `release` methods to identify the open\n file. The `FileInfo` instance may also have relevant configuration\n attributes set; see the `FileInfo` documentation for more information.\n '''\n\n raise FUSEError(errno.ENOSYS)\n\n async def read(self, fh: FileHandleT, off: int, size: int) -> bytes:\n '''Read *size* bytes from *fh* at position *off*.\n\n *fh* will be an integer filehandle returned by a prior `open` or\n `create` call.\n\n This function should return exactly the number of bytes requested except\n on EOF or error, otherwise the rest of the data will be substituted with\n zeroes.\n '''\n\n raise FUSEError(errno.ENOSYS)\n\n async def write(self, fh: FileHandleT, off: int, buf: bytes) -> int:\n '''Write *buf* into *fh* at *off*.\n\n *fh* will be an integer filehandle returned by a prior `open` or\n `create` call.\n\n This method must return the number of bytes written. However, unless the\n file system has been mounted with the ``direct_io`` option, the file\n system *must* always write *all* the provided data (i.e., return\n ``len(buf)``).\n '''\n\n raise FUSEError(errno.ENOSYS)\n\n async def flush(self, fh: FileHandleT) -> None:\n '''Handle close() syscall.\n\n *fh* will be an integer filehandle returned by a prior `open` or\n `create` call.\n\n This method is called whenever a file descriptor is closed. It may be\n called multiple times for the same open file (e.g. if the file handle\n has been duplicated).\n '''\n\n raise FUSEError(errno.ENOSYS)\n\n async def release(self, fh: FileHandleT) -> None:\n '''Release open file.\n\n This method will be called when the last file descriptor of *fh* has\n been closed, i.e. when the file is no longer opened by any client\n process.\n\n *fh* will be an integer filehandle returned by a prior `open` or\n `create` call. Once `release` has been called, no future requests for\n *fh* will be received (until the value is re-used in the return value of\n another `open` or `create` call).\n\n This method may return an error by raising `FUSEError`, but the error\n will be discarded because there is no corresponding client request.\n '''\n\n raise FUSEError(errno.ENOSYS)\n\n async def fsync(self, fh: FileHandleT, datasync: bool) -> None:\n '''Flush buffers for open file *fh*.\n\n If *datasync* is true, only the file contents should be\n flushed (in contrast to the metadata about the file).\n\n *fh* will be an integer filehandle returned by a prior `open` or\n `create` call.\n '''\n\n raise FUSEError(errno.ENOSYS)\n\n async def poll(\n self,\n inode: InodeT,\n fh: FileHandleT,\n poll_handle: Optional[\"PollHandle\"],\n ctx: \"RequestContext\",\n ) -> int:\n '''Check IO readiness on an open file.\n\n This method is called when a process performs :manpage:`poll(2)`,\n :manpage:`select(2)` or :manpage:`epoll_wait(2)` on a file descriptor\n backed by *fh* (returned by a prior `open` or `create` call). *inode*\n identifies the inode that *fh* refers to.\n\n The method will return the bitwise-or of the currently active poll\n events, for example `select.POLLIN`, `select.POLLOUT` or\n `select.POLLPRI`. If no events are currently ready, it will return `0`.\n\n If *poll_handle* is `None`, the kernel has not provided a notification\n handle for this request. The filesystem should only return the current\n readiness mask and must not attempt to store a handle or arrange a later\n `PollHandle.notify` call for this poll request.\n\n If *poll_handle* is not `None`, the kernel has provided a notification\n handle that may be used to wake waiters if readiness changes after this\n method returns. The filesystem may store the handle and later call\n `PollHandle.notify` when a relevant event becomes available. Each\n `~Operations.poll` call produces a fresh handle; storing a new handle\n should replace any previously held one, allowing the old handle to be\n destroyed.\n\n If this method raises `FUSEError(errno.ENOSYS)` (the default), the\n kernel will fall back to a default poll implementation and will not call\n this handler again for the lifetime of the mount.\n '''\n\n raise FUSEError(errno.ENOSYS)\n\n async def opendir(self, inode: InodeT, ctx: \"RequestContext\") -> FileHandleT:\n '''Open the directory with inode *inode*.\n\n *ctx* will be a `RequestContext` instance.\n\n This method should return an integer file handle. The file handle will\n be passed to the `readdir`, `fsyncdir` and `releasedir` methods to\n identify the directory.\n '''\n\n raise FUSEError(errno.ENOSYS)\n\n async def readdir(self, fh: FileHandleT, start_id: int, token: \"ReaddirToken\") -> None:\n '''Read entries in open directory *fh*.\n\n This method should list the contents of directory *fh* (as returned by a\n prior `opendir` call), starting at the entry identified by *start_id*.\n\n Instead of returning the directory entries directly, the method must\n call `readdir_reply` for each directory entry. If `readdir_reply`\n returns True, the file system must increase the lookup count for the\n provided directory entry by one and call `readdir_reply` again for the\n next entry (if any). If `readdir_reply` returns False, the lookup count\n must *not* be increased and the method should return without further\n calls to `readdir_reply`.\n\n The *start_id* parameter will be either zero (in which case listing\n should begin with the first entry) or it will correspond to a value that\n was previously passed by the file system to the `readdir_reply`\n function in the *next_id* parameter.\n\n If entries are added or removed during a `readdir` cycle, they may or\n may not be returned. However, they must not cause other entries to be\n skipped or returned more than once.\n\n :file:`.` and :file:`..` entries may be included but are not\n required. However, if they are reported the filesystem *must not*\n increase the lookup count for the corresponding inodes (even if\n `readdir_reply` returns True).\n '''\n\n raise FUSEError(errno.ENOSYS)\n\n async def releasedir(self, fh: FileHandleT) -> None:\n '''Release open directory.\n\n This method will be called exactly once for each `opendir` call. After\n *fh* has been released, no further `readdir` requests will be received\n for it (until it is opened again with `opendir`).\n '''\n\n raise FUSEError(errno.ENOSYS)\n\n async def fsyncdir(self, fh: FileHandleT, datasync: bool) -> None:\n '''Flush buffers for open directory *fh*.\n\n If *datasync* is true, only the directory contents should be\n flushed (in contrast to metadata about the directory itself).\n '''\n\n raise FUSEError(errno.ENOSYS)\n\n async def statfs(self, ctx: \"RequestContext\") -> \"StatvfsData\":\n '''Get file system statistics.\n\n *ctx* will be a `RequestContext` instance.\n\n The method must return an appropriately filled `StatvfsData` instance.\n '''\n\n raise FUSEError(errno.ENOSYS)\n\n def stacktrace(self) -> None:\n '''Asynchronous debugging.\n\n This method will be called when the ``fuse_stacktrace`` extended\n attribute is set on the mountpoint. The default implementation logs the\n current stack trace of every running Python thread. This can be quite\n useful to debug file system deadlocks.\n '''\n\n import sys\n import traceback\n from os.path import basename\n\n code = list()\n for threadId, frame in sys._current_frames().items():\n code.append(f\"\\n# ThreadID: {threadId}\")\n for filename, lineno, name, line in traceback.extract_stack(frame):\n code.append(f'{basename(filename)}:{lineno}, in {name}')\n if line:\n code.append(f\" {line.strip()}\")\n\n log.error(\"\\n\".join(code))\n\n async def setxattr(\n self, inode: InodeT, name: XAttrNameT, value: bytes, ctx: \"RequestContext\"\n ) -> None:\n '''Set extended attribute *name* of *inode* to *value*.\n\n *ctx* will be a `RequestContext` instance.\n\n The attribute may or may not exist already. Both *name* and *value* will\n be of type `bytes`. *name* is guaranteed not to contain zero-bytes\n (``\\\\0``).\n '''\n\n raise FUSEError(errno.ENOSYS)\n\n async def getxattr(self, inode: InodeT, name: XAttrNameT, ctx: \"RequestContext\") -> bytes:\n '''Return extended attribute *name* of *inode*.\n\n *ctx* will be a `RequestContext` instance.\n\n If the attribute does not exist, the method must raise `FUSEError` with\n an error code of `ENOATTR`. *name* will be of type `bytes`, but is\n guaranteed not to contain zero-bytes (``\\\\0``).\n '''\n\n raise FUSEError(errno.ENOSYS)\n\n async def listxattr(self, inode: InodeT, ctx: \"RequestContext\") -> Sequence[XAttrNameT]:\n '''Get list of extended attributes for *inode*.\n\n *ctx* will be a `RequestContext` instance.\n\n This method must return a sequence of `bytes` objects. The objects must\n not include zero-bytes (``\\\\0``).\n '''\n\n raise FUSEError(errno.ENOSYS)\n\n async def removexattr(self, inode: InodeT, name: XAttrNameT, ctx: \"RequestContext\") -> None:\n '''Remove extended attribute *name* of *inode*.\n\n *ctx* will be a `RequestContext` instance.\n\n If the attribute does not exist, the method must raise `FUSEError` with\n an error code of `ENOATTR`. *name* will be of type `bytes`, but is\n guaranteed not to contain zero-bytes (``\\\\0``).\n '''\n\n raise FUSEError(errno.ENOSYS)\n\n async def access(self, inode: InodeT, mode: ModeT, ctx: \"RequestContext\") -> bool:\n '''Check if requesting process has *mode* rights on *inode*.\n\n *ctx* will be a `RequestContext` instance.\n\n The method must return a boolean value.\n\n If the ``default_permissions`` mount option is given, this method is not\n called.\n\n When implementing this method, the `get_sup_groups` function may be\n useful.\n '''\n\n raise FUSEError(errno.ENOSYS)\n\n async def create(\n self,\n parent_inode: InodeT,\n name: FileNameT,\n mode: ModeT,\n flags: FlagT,\n ctx: \"RequestContext\",\n ) -> Tuple[\"FileInfo\", \"EntryAttributes\"]:\n '''Create a file with permissions *mode* and open it with *flags*.\n\n *ctx* will be a `RequestContext` instance.\n\n The method must return a tuple of the form *(fi, attr)*, where *fi* is a\n FileInfo instance handle like the one returned by `open` and *attr* is\n an `EntryAttributes` instance with the attributes of the newly created\n directory entry.\n\n (Successful) execution of this handler increases the lookup count for\n the returned inode by one.\n '''\n\n raise FUSEError(errno.ENOSYS)\n" }, { "path": "src/pyfuse3/asyncio.py", "content": "'''\nasyncio.py\n\nasyncio compatibility layer for pyfuse3\n\nCopyright © 2018 Nikolaus Rath \nCopyright © 2018 JustAnotherArchivist\n\nThis file is part of pyfuse3. This work may be distributed under\nthe terms of the GNU LGPL.\n'''\n\nimport asyncio\nimport collections\nimport sys\nfrom typing import Any, Callable, Iterable, Optional, Set, Type\n\nimport pyfuse3\n\nfrom ._pyfuse3 import FileHandleT\n\nLock = asyncio.Lock\n\n\ndef enable() -> None:\n '''Switch pyfuse3 to asyncio mode.'''\n\n fake_trio = sys.modules['pyfuse3.asyncio']\n fake_trio.lowlevel = fake_trio # type: ignore\n fake_trio.from_thread = fake_trio # type: ignore\n pyfuse3.trio = fake_trio # type: ignore\n\n\ndef disable() -> None:\n '''Switch pyfuse3 to default (trio) mode.'''\n\n pyfuse3.trio = sys.modules['trio'] # type: ignore\n\n\ndef current_trio_token() -> str:\n return 'asyncio'\n\n\n_read_futures = collections.defaultdict(set)\n\n\nasync def wait_readable(fd: FileHandleT) -> None:\n loop = asyncio.get_running_loop()\n future: 'asyncio.Future[Any]' = loop.create_future()\n _read_futures[fd].add(future)\n try:\n loop.add_reader(fd, future.set_result, None)\n future.add_done_callback(lambda f: loop.remove_reader(fd))\n await future\n finally:\n _read_futures[fd].remove(future)\n if not _read_futures[fd]:\n del _read_futures[fd]\n\n\ndef notify_closing(fd: FileHandleT) -> None:\n for f in _read_futures[fd]:\n f.set_exception(ClosedResourceError())\n\n\nclass ClosedResourceError(Exception):\n pass\n\n\ndef current_task() -> 'Optional[asyncio.Task[Any]]':\n if sys.version_info < (3, 7):\n return asyncio.Task.current_task()\n else:\n return asyncio.current_task()\n\n\nclass _Nursery:\n async def __aenter__(self) -> \"_Nursery\":\n self.tasks: 'Set[asyncio.Task[Any]]' = set()\n return self\n\n def start_soon(\n self, func: Callable[..., Any], *args: Iterable[Any], name: Optional[str] = None\n ) -> None:\n if sys.version_info < (3, 7):\n task = asyncio.ensure_future(func(*args))\n else:\n task = asyncio.create_task(func(*args))\n task.name = name # type: ignore\n self.tasks.add(task)\n\n async def __aexit__(\n self,\n exc_type: Optional[Type[BaseException]],\n exc_value: Optional[BaseException],\n traceback: Optional[Any],\n ) -> None:\n # Wait for tasks to finish\n while len(self.tasks):\n # Create a copy of the task list to ensure that it's not a problem\n # when self.tasks is modified\n done, pending = await asyncio.wait(tuple(self.tasks))\n for task in done:\n self.tasks.discard(task)\n\n # We waited for ALL_COMPLETED (default value of 'when' arg to\n # asyncio.wait), so all tasks should be completed. If that's not the\n # case, something's seriously wrong.\n assert len(pending) == 0\n\n\ndef open_nursery() -> _Nursery:\n return _Nursery()\n" }, { "path": "src/pyfuse3/darwin_compat.c", "content": "/*\n * Copyright (c) 2006-2008 Amit Singh/Google Inc.\n * Copyright (c) 2012 Anatol Pomozov\n * Copyright (c) 2011-2013 Benjamin Fleischer\n */\n\n#include \"darwin_compat.h\"\n\n#include \n#include \n#include \n\n/*\n * Semaphore implementation based on:\n *\n * Copyright (C) 2000,02 Free Software Foundation, Inc.\n * This file is part of the GNU C Library.\n * Written by Gal Le Mignot \n *\n * The GNU C Library is free software; you can redistribute it and/or\n * modify it under the terms of the GNU Library General Public License as\n * published by the Free Software Foundation; either version 2 of the\n * License, or (at your option) any later version.\n *\n * The GNU C Library is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * Library General Public License for more details.\n *\n * You should have received a copy of the GNU Library General Public\n * License along with the GNU C Library; see the file COPYING.LIB. If not,\n * write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,\n * Boston, MA 02111-1307, USA.\n */\n\n/* Semaphores */\n\n#define __SEM_ID_NONE ((int)0x0)\n#define __SEM_ID_LOCAL ((int)0xcafef00d)\n\n/* http://www.opengroup.org/onlinepubs/007908799/xsh/sem_init.html */\nint\ndarwin_sem_init(darwin_sem_t *sem, int pshared, unsigned int value)\n{\n if (pshared) {\n errno = ENOSYS;\n return -1;\n }\n\n sem->id = __SEM_ID_NONE;\n\n if (pthread_cond_init(&sem->__data.local.count_cond, NULL)) {\n goto cond_init_fail;\n }\n\n if (pthread_mutex_init(&sem->__data.local.count_lock, NULL)) {\n goto mutex_init_fail;\n }\n\n sem->__data.local.count = value;\n sem->id = __SEM_ID_LOCAL;\n\n return 0;\n\nmutex_init_fail:\n\n pthread_cond_destroy(&sem->__data.local.count_cond);\n\ncond_init_fail:\n\n return -1;\n}\n\n/* http://www.opengroup.org/onlinepubs/007908799/xsh/sem_destroy.html */\nint\ndarwin_sem_destroy(darwin_sem_t *sem)\n{\n int res = 0;\n\n pthread_mutex_lock(&sem->__data.local.count_lock);\n\n sem->id = __SEM_ID_NONE;\n pthread_cond_broadcast(&sem->__data.local.count_cond);\n\n if (pthread_cond_destroy(&sem->__data.local.count_cond)) {\n res = -1;\n }\n\n pthread_mutex_unlock(&sem->__data.local.count_lock);\n\n if (pthread_mutex_destroy(&sem->__data.local.count_lock)) {\n res = -1;\n }\n\n return res;\n}\n\nint\ndarwin_sem_getvalue(darwin_sem_t *sem, unsigned int *sval)\n{\n int res = 0;\n\n pthread_mutex_lock(&sem->__data.local.count_lock);\n\n if (sem->id != __SEM_ID_LOCAL) {\n res = -1;\n errno = EINVAL;\n } else {\n *sval = sem->__data.local.count;\n }\n\n pthread_mutex_unlock(&sem->__data.local.count_lock);\n\n return res;\n}\n\n/* http://www.opengroup.org/onlinepubs/007908799/xsh/sem_post.html */\nint\ndarwin_sem_post(darwin_sem_t *sem)\n{\n int res = 0;\n\n pthread_mutex_lock(&sem->__data.local.count_lock);\n\n if (sem->id != __SEM_ID_LOCAL) {\n res = -1;\n errno = EINVAL;\n } else if (sem->__data.local.count < DARWIN_SEM_VALUE_MAX) {\n sem->__data.local.count++;\n if (sem->__data.local.count == 1) {\n pthread_cond_signal(&sem->__data.local.count_cond);\n }\n } else {\n errno = ERANGE;\n res = -1;\n }\n\n pthread_mutex_unlock(&sem->__data.local.count_lock);\n\n return res;\n}\n\n/* http://www.opengroup.org/onlinepubs/009695399/functions/sem_timedwait.html */\nint\ndarwin_sem_timedwait(darwin_sem_t *sem, const struct timespec *abs_timeout)\n{\n int res = 0;\n\n if (abs_timeout &&\n (abs_timeout->tv_nsec < 0 || abs_timeout->tv_nsec >= 1000000000)) {\n errno = EINVAL;\n return -1;\n }\n\n pthread_cleanup_push((void(*)(void*))&pthread_mutex_unlock,\n &sem->__data.local.count_lock);\n\n pthread_mutex_lock(&sem->__data.local.count_lock);\n\n if (sem->id != __SEM_ID_LOCAL) {\n errno = EINVAL;\n res = -1;\n } else {\n if (!sem->__data.local.count) {\n res = pthread_cond_timedwait(&sem->__data.local.count_cond,\n &sem->__data.local.count_lock,\n abs_timeout);\n }\n if (res) {\n assert(res == ETIMEDOUT);\n res = -1;\n errno = ETIMEDOUT;\n } else if (sem->id != __SEM_ID_LOCAL) {\n res = -1;\n errno = EINVAL;\n } else {\n sem->__data.local.count--;\n }\n }\n\n pthread_cleanup_pop(1);\n\n return res;\n}\n\n/* http://www.opengroup.org/onlinepubs/007908799/xsh/sem_trywait.html */\nint\ndarwin_sem_trywait(darwin_sem_t *sem)\n{\n int res = 0;\n\n pthread_mutex_lock(&sem->__data.local.count_lock);\n\n if (sem->id != __SEM_ID_LOCAL) {\n res = -1;\n errno = EINVAL;\n } else if (sem->__data.local.count) {\n sem->__data.local.count--;\n } else {\n res = -1;\n errno = EAGAIN;\n }\n\n pthread_mutex_unlock (&sem->__data.local.count_lock);\n\n return res;\n}\n\n/* http://www.opengroup.org/onlinepubs/007908799/xsh/sem_wait.html */\nint\ndarwin_sem_wait(darwin_sem_t *sem)\n{\n /* Must be volatile or will be clobbered by longjmp */\n volatile int res = 0;\n\n pthread_cleanup_push((void(*)(void*))&pthread_mutex_unlock,\n &sem->__data.local.count_lock);\n\n pthread_mutex_lock(&sem->__data.local.count_lock);\n\n if (sem->id != __SEM_ID_LOCAL) {\n errno = EINVAL;\n res = -1;\n } else {\n if (!sem->__data.local.count) {\n pthread_cond_wait(&sem->__data.local.count_cond,\n &sem->__data.local.count_lock);\n if (!sem->__data.local.count) {\n /* spurious wakeup, assume it is an interruption */\n res = -1;\n errno = EINTR;\n goto out;\n }\n }\n if (sem->id != __SEM_ID_LOCAL) {\n res = -1;\n errno = EINVAL;\n } else {\n sem->__data.local.count--;\n }\n }\n\nout:\n pthread_cleanup_pop(1);\n\n return res;\n}\n" }, { "path": "src/pyfuse3/darwin_compat.h", "content": "/*\n * Copyright (c) 2006-2008 Amit Singh/Google Inc.\n * Copyright (c) 2011-2013 Benjamin Fleischer\n */\n\n#ifndef _DARWIN_COMPAT_\n#define _DARWIN_COMPAT_\n\n#include \n\n/* Semaphores */\n\ntypedef struct darwin_sem {\n int id;\n union {\n struct\n {\n unsigned int count;\n pthread_mutex_t count_lock;\n pthread_cond_t count_cond;\n } local;\n } __data;\n} darwin_sem_t;\n\n#define DARWIN_SEM_VALUE_MAX ((int32_t)32767)\n\nint darwin_sem_init(darwin_sem_t *sem, int pshared, unsigned int value);\nint darwin_sem_destroy(darwin_sem_t *sem);\nint darwin_sem_getvalue(darwin_sem_t *sem, unsigned int *value);\nint darwin_sem_post(darwin_sem_t *sem);\nint darwin_sem_timedwait(darwin_sem_t *sem, const struct timespec *abs_timeout);\nint darwin_sem_trywait(darwin_sem_t *sem);\nint darwin_sem_wait(darwin_sem_t *sem);\n\n/* Caller must not include */\n\ntypedef darwin_sem_t sem_t;\n\n#define sem_init(s, p, v) darwin_sem_init(s, p, v)\n#define sem_destroy(s) darwin_sem_destroy(s)\n#define sem_getvalue(s, v) darwin_sem_getvalue(s, v)\n#define sem_post(s) darwin_sem_post(s)\n#define sem_timedwait(s, t) darwin_sem_timedwait(s, t)\n#define sem_trywait(s) darwin_sem_trywait(s)\n#define sem_wait(s) darwin_sem_wait(s)\n\n#define SEM_VALUE_MAX DARWIN_SEM_VALUE_MAX\n\n#endif /* _DARWIN_COMPAT_ */\n" }, { "path": "src/pyfuse3/gettime.h", "content": "/*\n * gettime.h\n *\n * Platform-independent interface to system clock\n *\n * Copyright © 2015 Nikolaus Rath \n *\n * This file is part of pyfuse3. This work may be distributed under the\n * terms of the GNU LGPL.\n*/\n\n/*\n * Linux\n */\n#if PLATFORM == PLATFORM_LINUX\n#include \n\nstatic int gettime_realtime(struct timespec *tp) {\n return clock_gettime(CLOCK_REALTIME, tp);\n}\n\n\n/*\n * FreeBSD & NetBSD\n */\n#elif PLATFORM == PLATFORM_BSD\n#include \n\nstatic int gettime_realtime(struct timespec *tp) {\n return clock_gettime(CLOCK_REALTIME, tp);\n}\n\n/*\n * Darwin\n */\n#elif PLATFORM == PLATFORM_DARWIN\n#include \n\nstatic int gettime_realtime(struct timespec *tp) {\n struct timeval tv;\n int res;\n\n res = gettimeofday(&tv, NULL);\n if(res != 0)\n return -1;\n\n tp->tv_sec = tv.tv_sec;\n tp->tv_nsec = tv.tv_usec * 1000;\n\n return 0;\n}\n\n\n/*\n * Unknown system\n */\n#else\n#error This should not happen\n#endif\n" }, { "path": "src/pyfuse3/handlers.pxi", "content": "'''\nhandlers.pxi\n\nThis file defines the FUSE request handlers. It is included\nby __init__.pyx.\n\nCopyright © 2013 Nikolaus Rath \n\nThis file is part of pyfuse3. This work may be distributed under\nthe terms of the GNU LGPL.\n'''\n\n@cython.freelist(60)\ncdef class _Container:\n \"\"\"For internal use by pyfuse3 only.\"\"\"\n\n # This serves as a generic container to pass C variables\n # through Python. Which fields have valid data depends on\n # context.\n\n cdef dev_t rdev\n cdef fuse_file_info fi\n cdef fuse_ino_t ino\n cdef fuse_ino_t parent\n cdef fuse_req_t req\n cdef int flags\n cdef mode_t mode\n cdef off_t off\n cdef size_t size\n cdef struct_stat stat\n cdef uint64_t fh\n\ncdef void fuse_init (void *userdata, fuse_conn_info *conn):\n if not conn.capable & FUSE_CAP_READDIRPLUS:\n raise RuntimeError('Kernel too old, pyfuse3 requires kernel 3.9 or newer!')\n conn.want &= ~( FUSE_CAP_READDIRPLUS_AUTO)\n\n if (operations.supports_dot_lookup and\n conn.capable & FUSE_CAP_EXPORT_SUPPORT):\n conn.want |= FUSE_CAP_EXPORT_SUPPORT\n if (operations.enable_writeback_cache and\n conn.capable & FUSE_CAP_WRITEBACK_CACHE):\n conn.want |= FUSE_CAP_WRITEBACK_CACHE\n if (operations.enable_acl and\n conn.capable & FUSE_CAP_POSIX_ACL):\n conn.want |= FUSE_CAP_POSIX_ACL\n\n # Blocking rather than async, in case we decide to let the\n # init handler modify `conn` in the future.\n operations.init()\n\ncdef void fuse_lookup (fuse_req_t req, fuse_ino_t parent,\n const_char *name):\n cdef _Container c = _Container()\n c.req = req\n c.parent = parent\n save_retval(fuse_lookup_async(c, PyBytes_FromString(name)))\n\nasync def fuse_lookup_async (_Container c, name):\n cdef EntryAttributes entry\n cdef int ret\n\n ctx = get_request_context(c.req)\n try:\n entry = await operations.lookup(\n c.parent, name, ctx)\n except FUSEError as e:\n ret = fuse_reply_err(c.req, e.errno)\n else:\n ret = fuse_reply_entry(c.req, &entry.fuse_param)\n\n if ret != 0:\n log.error('fuse_lookup(): fuse_reply_* failed with %s', strerror(-ret))\n\n\ncdef void fuse_forget (fuse_req_t req, fuse_ino_t ino,\n uint64_t nlookup):\n save_retval(operations.forget([(ino, nlookup)]))\n fuse_reply_none(req)\n\n\ncdef void fuse_forget_multi(fuse_req_t req, size_t count,\n fuse_forget_data *forgets):\n forget_list = list()\n for el in forgets[:count]:\n forget_list.append((el.ino, el.nlookup))\n save_retval(operations.forget(forget_list))\n fuse_reply_none(req)\n\n\ncdef void fuse_getattr (fuse_req_t req, fuse_ino_t ino,\n fuse_file_info *fi):\n cdef _Container c = _Container()\n c.req = req\n c.ino = ino\n save_retval(fuse_getattr_async(c))\n\nasync def fuse_getattr_async (_Container c):\n cdef int ret\n cdef EntryAttributes entry\n\n ctx = get_request_context(c.req)\n try:\n entry = await operations.getattr(c.ino, ctx)\n except FUSEError as e:\n ret = fuse_reply_err(c.req, e.errno)\n else:\n ret = fuse_reply_attr(c.req, entry.attr, entry.fuse_param.attr_timeout)\n\n if ret != 0:\n log.error('fuse_getattr(): fuse_reply_* failed with %s', strerror(-ret))\n\n\ncdef void fuse_setattr (fuse_req_t req, fuse_ino_t ino, struct_stat *stat,\n int to_set, fuse_file_info *fi):\n cdef _Container c = _Container()\n c.req = req\n c.ino = ino\n c.stat = stat[0]\n c.flags = to_set\n if fi is NULL:\n fh = None\n else:\n fh = fi.fh\n save_retval(fuse_setattr_async(c, fh))\n\nasync def fuse_setattr_async (_Container c, fh):\n cdef int ret\n cdef timespec now\n cdef EntryAttributes entry\n cdef SetattrFields fields\n cdef struct_stat *attr\n cdef int to_set = c.flags\n\n ctx = get_request_context(c.req)\n entry = EntryAttributes()\n fields = SetattrFields.__new__(SetattrFields)\n string.memcpy(entry.attr, &c.stat, sizeof(struct_stat))\n\n attr = entry.attr\n if to_set & (FUSE_SET_ATTR_ATIME_NOW | FUSE_SET_ATTR_MTIME_NOW):\n ret = libc_extra.gettime_realtime(&now)\n if ret != 0:\n log.error('fuse_setattr(): clock_gettime(CLOCK_REALTIME) failed with %s',\n strerror(errno.errno))\n\n if to_set & FUSE_SET_ATTR_ATIME:\n fields.update_atime = True\n elif to_set & FUSE_SET_ATTR_ATIME_NOW:\n fields.update_atime = True\n attr.st_atime = now.tv_sec\n SET_ATIME_NS(attr, now.tv_nsec)\n\n if to_set & FUSE_SET_ATTR_MTIME:\n fields.update_mtime = True\n elif to_set & FUSE_SET_ATTR_MTIME_NOW:\n fields.update_mtime = True\n attr.st_mtime = now.tv_sec\n SET_MTIME_NS(attr, now.tv_nsec)\n\n fields.update_ctime = bool(to_set & FUSE_SET_ATTR_CTIME)\n fields.update_mode = bool(to_set & FUSE_SET_ATTR_MODE)\n fields.update_uid = bool(to_set & FUSE_SET_ATTR_UID)\n fields.update_gid = bool(to_set & FUSE_SET_ATTR_GID)\n fields.update_size = bool(to_set & FUSE_SET_ATTR_SIZE)\n\n try:\n entry = await operations.setattr(c.ino, entry, fields, fh, ctx)\n except FUSEError as e:\n ret = fuse_reply_err(c.req, e.errno)\n else:\n ret = fuse_reply_attr(c.req, entry.attr, entry.fuse_param.attr_timeout)\n\n if ret != 0:\n log.error('fuse_setattr(): fuse_reply_* failed with %s', strerror(-ret))\n\n\ncdef void fuse_readlink (fuse_req_t req, fuse_ino_t ino):\n cdef _Container c = _Container()\n c.req = req\n c.ino = ino\n save_retval(fuse_readlink_async(c))\n\nasync def fuse_readlink_async (_Container c):\n cdef int ret\n cdef char* name\n ctx = get_request_context(c.req)\n try:\n target = await operations.readlink(c.ino, ctx)\n except FUSEError as e:\n ret = fuse_reply_err(c.req, e.errno)\n else:\n name = PyBytes_AsString(target)\n ret = fuse_reply_readlink(c.req, name)\n\n if ret != 0:\n log.error('fuse_readlink(): fuse_reply_* failed with %s', strerror(-ret))\n\n\ncdef void fuse_mknod (fuse_req_t req, fuse_ino_t parent, const_char *name,\n mode_t mode, dev_t rdev):\n cdef _Container c = _Container()\n c.req = req\n c.parent = parent\n c.mode = mode\n c.rdev = rdev\n save_retval(fuse_mknod_async(c, PyBytes_FromString(name)))\n\nasync def fuse_mknod_async (_Container c, name):\n cdef int ret\n cdef EntryAttributes entry\n\n ctx = get_request_context(c.req)\n try:\n entry = await operations.mknod(\n c.parent, name, c.mode, c.rdev, ctx)\n except FUSEError as e:\n ret = fuse_reply_err(c.req, e.errno)\n else:\n ret = fuse_reply_entry(c.req, &entry.fuse_param)\n\n if ret != 0:\n log.error('fuse_mknod(): fuse_reply_* failed with %s', strerror(-ret))\n\n\ncdef void fuse_mkdir (fuse_req_t req, fuse_ino_t parent, const_char *name,\n mode_t mode):\n cdef _Container c = _Container()\n c.req = req\n c.parent = parent\n c.mode = mode\n save_retval(fuse_mkdir_async(c, PyBytes_FromString(name)))\n\nasync def fuse_mkdir_async (_Container c, name):\n cdef int ret\n cdef EntryAttributes entry\n\n # Force the entry type to directory. We need to explicitly cast,\n # because on BSD the S_* are not of type mode_t.\n c.mode = (c.mode & ~ S_IFMT) | S_IFDIR\n ctx = get_request_context(c.req)\n try:\n entry = await operations.mkdir(\n c.parent, name, c.mode, ctx)\n except FUSEError as e:\n ret = fuse_reply_err(c.req, e.errno)\n else:\n ret = fuse_reply_entry(c.req, &entry.fuse_param)\n\n if ret != 0:\n log.error('fuse_mkdir(): fuse_reply_* failed with %s', strerror(-ret))\n\n\ncdef void fuse_unlink (fuse_req_t req, fuse_ino_t parent, const_char *name):\n cdef _Container c = _Container()\n c.req = req\n c.parent = parent\n save_retval(fuse_unlink_async(c, PyBytes_FromString(name)))\n\nasync def fuse_unlink_async (_Container c, name):\n cdef int ret\n\n ctx = get_request_context(c.req)\n try:\n await operations.unlink(c.parent, name, ctx)\n except FUSEError as e:\n ret = fuse_reply_err(c.req, e.errno)\n else:\n ret = fuse_reply_err(c.req, 0)\n\n if ret != 0:\n log.error('fuse_unlink(): fuse_reply_* failed with %s', strerror(-ret))\n\n\ncdef void fuse_rmdir (fuse_req_t req, fuse_ino_t parent, const_char *name):\n cdef _Container c = _Container()\n c.req = req\n c.parent = parent\n save_retval(fuse_rmdir_async(c, PyBytes_FromString(name)))\n\nasync def fuse_rmdir_async (_Container c, name):\n cdef int ret\n\n ctx = get_request_context(c.req)\n try:\n await operations.rmdir(c.parent, name, ctx)\n except FUSEError as e:\n ret = fuse_reply_err(c.req, e.errno)\n else:\n ret = fuse_reply_err(c.req, 0)\n\n if ret != 0:\n log.error('fuse_rmdir(): fuse_reply_* failed with %s', strerror(-ret))\n\n\ncdef void fuse_symlink (fuse_req_t req, const_char *link, fuse_ino_t parent,\n const_char *name):\n cdef _Container c = _Container()\n c.req = req\n c.parent = parent\n save_retval(fuse_symlink_async(\n c, PyBytes_FromString(name), PyBytes_FromString(link)))\n\nasync def fuse_symlink_async (_Container c, name, link):\n cdef int ret\n cdef EntryAttributes entry\n\n ctx = get_request_context(c.req)\n try:\n entry = await operations.symlink(\n c.parent, name, link, ctx)\n except FUSEError as e:\n ret = fuse_reply_err(c.req, e.errno)\n else:\n ret = fuse_reply_entry(c.req, &entry.fuse_param)\n\n if ret != 0:\n log.error('fuse_symlink(): fuse_reply_* failed with %s', strerror(-ret))\n\n\ncdef void fuse_rename (fuse_req_t req, fuse_ino_t parent, const_char *name,\n fuse_ino_t newparent, const_char *newname, unsigned flags):\n cdef _Container c = _Container()\n c.req = req\n c.parent = parent\n c.ino = newparent\n c.flags = flags\n save_retval(fuse_rename_async(\n c, PyBytes_FromString(name), PyBytes_FromString(newname)))\n\n\nasync def fuse_rename_async (_Container c, name, newname):\n cdef int ret\n cdef unsigned flags = c.flags\n cdef fuse_ino_t newparent = c.ino\n\n ctx = get_request_context(c.req)\n try:\n await operations.rename(c.parent, name, newparent, newname, flags, ctx)\n except FUSEError as e:\n ret = fuse_reply_err(c.req, e.errno)\n else:\n ret = fuse_reply_err(c.req, 0)\n\n if ret != 0:\n log.error('fuse_rename(): fuse_reply_* failed with %s', strerror(-ret))\n\n\ncdef void fuse_link (fuse_req_t req, fuse_ino_t ino, fuse_ino_t newparent,\n const_char *newname):\n cdef _Container c = _Container()\n c.req = req\n c.ino = ino\n c.parent = newparent\n save_retval(fuse_link_async(c, PyBytes_FromString(newname)))\n\nasync def fuse_link_async (_Container c, newname):\n cdef int ret\n cdef EntryAttributes entry\n\n ctx = get_request_context(c.req)\n try:\n entry = await operations.link(\n c.ino, c.parent, newname, ctx)\n except FUSEError as e:\n ret = fuse_reply_err(c.req, e.errno)\n else:\n ret = fuse_reply_entry(c.req, &entry.fuse_param)\n\n if ret != 0:\n log.error('fuse_link(): fuse_reply_* failed with %s', strerror(-ret))\n\n\ncdef void fuse_open (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi):\n cdef _Container c = _Container()\n c.req = req\n c.ino = ino\n c.fi = fi[0]\n save_retval(fuse_open_async(c))\n\nasync def fuse_open_async (_Container c):\n cdef int ret\n cdef FileInfo fi\n\n ctx = get_request_context(c.req)\n\n try:\n fi = await operations.open(c.ino, c.fi.flags, ctx)\n except FUSEError as e:\n ret = fuse_reply_err(c.req, e.errno)\n else:\n fi._copy_to_fuse(&c.fi)\n ret = fuse_reply_open(c.req, &c.fi)\n\n if ret != 0:\n log.error('fuse_link(): fuse_reply_* failed with %s', strerror(-ret))\n\n\ncdef void fuse_read (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off,\n fuse_file_info *fi):\n cdef _Container c = _Container()\n c.req = req\n c.size = size\n c.off = off\n c.fh = fi.fh\n save_retval(fuse_read_async(c))\n\nasync def fuse_read_async (_Container c):\n cdef int ret\n cdef Py_buffer pybuf\n\n try:\n buf = await operations.read(c.fh, c.off, c.size)\n except FUSEError as e:\n ret = fuse_reply_err(c.req, e.errno)\n else:\n PyObject_GetBuffer(buf, &pybuf, PyBUF_CONTIG_RO)\n ret = fuse_reply_buf(c.req, pybuf.buf, pybuf.len)\n PyBuffer_Release(&pybuf)\n\n if ret != 0:\n log.error('fuse_read(): fuse_reply_* failed with %s', strerror(-ret))\n\n\ncdef void fuse_write (fuse_req_t req, fuse_ino_t ino, const_char *buf,\n size_t size, off_t off, fuse_file_info *fi):\n cdef _Container c = _Container()\n c.req = req\n c.size = size\n c.off = off\n c.fh = fi.fh\n\n if size > PY_SSIZE_T_MAX:\n raise OverflowError('Value too long to convert to Python')\n pbuf = PyBytes_FromStringAndSize(buf, size)\n save_retval(fuse_write_async(c, pbuf))\n\nasync def fuse_write_async (_Container c, pbuf):\n cdef int ret\n cdef size_t len_\n\n try:\n len_ = await operations.write(c.fh, c.off, pbuf)\n except FUSEError as e:\n ret = fuse_reply_err(c.req, e.errno)\n else:\n ret = fuse_reply_write(c.req, len_)\n\n if ret != 0:\n log.error('fuse_write(): fuse_reply_* failed with %s', strerror(-ret))\n\n\ncdef void fuse_write_buf(fuse_req_t req, fuse_ino_t ino, fuse_bufvec *bufv,\n off_t off, fuse_file_info *fi):\n cdef _Container c = _Container()\n c.req = req\n c.off = off\n c.fh = fi.fh\n buf = PyBytes_from_bufvec(bufv)\n save_retval(fuse_write_buf_async(c, buf))\n\nasync def fuse_write_buf_async (_Container c, buf):\n cdef int ret\n cdef size_t len_\n\n try:\n len_ = await operations.write(c.fh, c.off, buf)\n except FUSEError as e:\n ret = fuse_reply_err(c.req, e.errno)\n else:\n ret = fuse_reply_write(c.req, len_)\n\n if ret != 0:\n log.error('fuse_write_buf(): fuse_reply_* failed with %s', strerror(-ret))\n\n\ncdef void fuse_flush (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi):\n cdef _Container c = _Container()\n c.req = req\n c.fh = fi.fh\n save_retval(fuse_flush_async(c))\n\nasync def fuse_flush_async (_Container c):\n cdef int ret\n\n try:\n await operations.flush(c.fh)\n except FUSEError as e:\n ret = fuse_reply_err(c.req, e.errno)\n else:\n ret = fuse_reply_err(c.req, 0)\n\n if ret != 0:\n log.error('fuse_flush(): fuse_reply_* failed with %s', strerror(-ret))\n\n\ncdef void fuse_release (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi):\n cdef _Container c = _Container()\n c.req = req\n c.fh = fi.fh\n save_retval(fuse_release_async(c))\n\nasync def fuse_release_async (_Container c):\n cdef int ret\n\n try:\n await operations.release(c.fh)\n except FUSEError as e:\n ret = fuse_reply_err(c.req, e.errno)\n else:\n ret = fuse_reply_err(c.req, 0)\n\n if ret != 0:\n log.error('fuse_release(): fuse_reply_* failed with %s', strerror(-ret))\n\n\ncdef void fuse_fsync (fuse_req_t req, fuse_ino_t ino, int datasync,\n fuse_file_info *fi):\n cdef _Container c = _Container()\n c.req = req\n c.flags = datasync\n c.fh = fi.fh\n save_retval(fuse_fsync_async(c))\n\nasync def fuse_fsync_async (_Container c):\n cdef int ret\n\n try:\n await operations.fsync(c.fh, c.flags != 0)\n except FUSEError as e:\n ret = fuse_reply_err(c.req, e.errno)\n else:\n ret = fuse_reply_err(c.req, 0)\n\n if ret != 0:\n log.error('fuse_fsync(): fuse_reply_* failed with %s', strerror(-ret))\n\n\ncdef void fuse_opendir (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi):\n cdef _Container c = _Container()\n c.req = req\n c.ino = ino\n c.fi = fi[0]\n save_retval(fuse_opendir_async(c))\n\nasync def fuse_opendir_async (_Container c):\n cdef int ret\n\n ctx = get_request_context(c.req)\n try:\n c.fi.fh = await operations.opendir(c.ino, ctx)\n except FUSEError as e:\n ret = fuse_reply_err(c.req, e.errno)\n else:\n ret = fuse_reply_open(c.req, &c.fi)\n\n if ret != 0:\n log.error('fuse_opendir(): fuse_reply_* failed with %s', strerror(-ret))\n\n\n@cython.freelist(10)\ncdef class ReaddirToken:\n cdef fuse_req_t req\n cdef char *buf_start\n cdef char *buf\n cdef size_t size\n\ncdef void fuse_readdirplus (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off,\n fuse_file_info *fi):\n global py_retval\n cdef _Container c = _Container()\n c.req = req\n c.size = size\n c.off = off\n c.fh = fi.fh\n save_retval(fuse_readdirplus_async(c))\n\nasync def fuse_readdirplus_async (_Container c):\n cdef int ret\n cdef ReaddirToken token = ReaddirToken()\n token.buf_start = NULL\n token.size = c.size\n token.req = c.req\n\n try:\n await operations.readdir(c.fh, c.off, token)\n except FUSEError as e:\n ret = fuse_reply_err(c.req, e.errno)\n else:\n if token.buf_start == NULL:\n ret = fuse_reply_buf(c.req, NULL, 0)\n else:\n ret = fuse_reply_buf(c.req, token.buf_start, c.size - token.size)\n finally:\n stdlib.free(token.buf_start)\n\n if ret != 0:\n log.error('fuse_readdirplus(): fuse_reply_* failed with %s', strerror(-ret))\n\n\ncdef void fuse_releasedir (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi):\n cdef _Container c = _Container()\n c.req = req\n c.fh = fi.fh\n save_retval(fuse_releasedir_async(c))\n\nasync def fuse_releasedir_async (_Container c):\n cdef int ret\n\n try:\n await operations.releasedir(c.fh)\n except FUSEError as e:\n ret = fuse_reply_err(c.req, e.errno)\n else:\n ret = fuse_reply_err(c.req, 0)\n\n if ret != 0:\n log.error('fuse_releasedir(): fuse_reply_* failed with %s', strerror(-ret))\n\n\n\ncdef void fuse_fsyncdir (fuse_req_t req, fuse_ino_t ino, int datasync,\n fuse_file_info *fi):\n cdef _Container c = _Container()\n c.req = req\n c.flags = datasync\n c.fh = fi.fh\n save_retval(fuse_fsyncdir_async(c))\n\nasync def fuse_fsyncdir_async (_Container c):\n cdef int ret\n\n try:\n await operations.fsyncdir(c.fh, c.flags != 0)\n except FUSEError as e:\n ret = fuse_reply_err(c.req, e.errno)\n else:\n ret = fuse_reply_err(c.req, 0)\n\n if ret != 0:\n log.error('fuse_fsyncdir(): fuse_reply_* failed with %s', strerror(-ret))\n\n\n\ncdef void fuse_statfs (fuse_req_t req, fuse_ino_t ino):\n cdef _Container c = _Container()\n c.req = req\n save_retval(fuse_statfs_async(c))\n\nasync def fuse_statfs_async (_Container c):\n cdef int ret\n cdef StatvfsData stats\n\n ctx = get_request_context(c.req)\n try:\n stats = await operations.statfs(ctx)\n except FUSEError as e:\n ret = fuse_reply_err(c.req, e.errno)\n else:\n ret = fuse_reply_statfs(c.req, &stats.stat)\n\n if ret != 0:\n log.error('fuse_statfs(): fuse_reply_* failed with %s', strerror(-ret))\n\n\ncdef void fuse_setxattr (fuse_req_t req, fuse_ino_t ino, const_char *cname,\n const_char *cvalue, size_t size, int flags):\n cdef _Container c = _Container()\n c.req = req\n c.ino = ino\n c.size = size\n c.flags = flags\n\n name = PyBytes_FromString(cname)\n if c.size > PY_SSIZE_T_MAX:\n raise OverflowError('Value too long to convert to Python')\n value = PyBytes_FromStringAndSize(cvalue, c.size)\n\n save_retval(fuse_setxattr_async(c, name, value))\n\nasync def fuse_setxattr_async (_Container c, name, value):\n cdef int ret\n\n # Special case for deadlock debugging\n if c.ino == FUSE_ROOT_ID and name == 'fuse_stacktrace':\n operations.stacktrace()\n fuse_reply_err(c.req, 0)\n return\n\n # Make sure we know all the flags\n if c.flags & ~(libc_extra.XATTR_CREATE | libc_extra.XATTR_REPLACE):\n raise ValueError('unknown flag(s): %o' % c.flags)\n\n ctx = get_request_context(c.req)\n try:\n if c.flags & libc_extra.XATTR_CREATE: # Attribute must not exist\n try:\n await operations.getxattr(c.ino, name, ctx)\n except FUSEError as e:\n if e.errno != ENOATTR:\n raise\n else:\n raise FUSEError(errno.EEXIST)\n\n elif c.flags & libc_extra.XATTR_REPLACE: # Attribute must exist\n await operations.getxattr(c.ino, name, ctx)\n\n await operations.setxattr(c.ino, name, value, ctx)\n except FUSEError as e:\n ret = fuse_reply_err(c.req, e.errno)\n else:\n ret = fuse_reply_err(c.req, 0)\n\n if ret != 0:\n log.error('fuse_setxattr(): fuse_reply_* failed with %s', strerror(-ret))\n\n\ncdef void fuse_getxattr (fuse_req_t req, fuse_ino_t ino, const_char *name,\n size_t size):\n cdef _Container c = _Container()\n c.req = req\n c.ino = ino\n c.size = size\n save_retval(fuse_getxattr_async(c, PyBytes_FromString(name)))\n\nasync def fuse_getxattr_async (_Container c, name):\n cdef int ret\n cdef ssize_t len_s\n cdef size_t len_\n cdef char *cbuf\n\n ctx = get_request_context(c.req)\n try:\n buf = await operations.getxattr(c.ino, name, ctx)\n except FUSEError as e:\n ret = fuse_reply_err(c.req, e.errno)\n else:\n PyBytes_AsStringAndSize(buf, &cbuf, &len_s)\n len_ = len_s # guaranteed positive\n\n if c.size == 0:\n ret = fuse_reply_xattr(c.req, len_)\n elif len_ <= c.size:\n ret = fuse_reply_buf(c.req, cbuf, len_)\n else:\n ret = fuse_reply_err(c.req, errno.ERANGE)\n\n if ret != 0:\n log.error('fuse_getxattr(): fuse_reply_* failed with %s', strerror(-ret))\n\n\ncdef void fuse_listxattr (fuse_req_t req, fuse_ino_t ino, size_t size):\n cdef _Container c = _Container()\n c.req = req\n c.ino = ino\n c.size = size\n save_retval(fuse_listxattr_async(c))\n\nasync def fuse_listxattr_async (_Container c):\n cdef int ret\n cdef ssize_t len_s\n cdef size_t len_\n cdef char *cbuf\n\n\n ctx = get_request_context(c.req)\n try:\n res = await operations.listxattr(c.ino, ctx)\n except FUSEError as e:\n ret = fuse_reply_err(c.req, e.errno)\n else:\n buf = b'\\0'.join(res) + b'\\0'\n\n PyBytes_AsStringAndSize(buf, &cbuf, &len_s)\n len_ = len_s # guaranteed positive\n\n if len_ == 1: # No attributes\n len_ = 0\n\n if c.size == 0:\n ret = fuse_reply_xattr(c.req, len_)\n elif len_ <= c.size:\n ret = fuse_reply_buf(c.req, cbuf, len_)\n else:\n ret = fuse_reply_err(c.req, errno.ERANGE)\n\n if ret != 0:\n log.error('fuse_listxattr(): fuse_reply_* failed with %s', strerror(-ret))\n\n\ncdef void fuse_removexattr (fuse_req_t req, fuse_ino_t ino, const_char *name):\n cdef _Container c = _Container()\n c.req = req\n c.ino = ino\n save_retval(fuse_removexattr_async(c, PyBytes_FromString(name)))\n\nasync def fuse_removexattr_async (_Container c, name):\n cdef int ret\n\n ctx = get_request_context(c.req)\n try:\n await operations.removexattr(c.ino, name, ctx)\n except FUSEError as e:\n ret = fuse_reply_err(c.req, e.errno)\n else:\n ret = fuse_reply_err(c.req, 0)\n\n if ret != 0:\n log.error('fuse_removexattr(): fuse_reply_* failed with %s', strerror(-ret))\n\n\ncdef void fuse_access (fuse_req_t req, fuse_ino_t ino, int mask):\n cdef _Container c = _Container()\n c.req = req\n c.ino = ino\n c.flags = mask\n save_retval(fuse_access_async(c))\n\nasync def fuse_access_async (_Container c):\n cdef int ret\n cdef int mask = c.flags\n\n ctx = get_request_context(c.req)\n try:\n allowed = await operations.access(c.ino, mask, ctx)\n except FUSEError as e:\n ret = fuse_reply_err(c.req, e.errno)\n else:\n if allowed:\n ret = fuse_reply_err(c.req, 0)\n else:\n ret = fuse_reply_err(c.req, EACCES)\n\n if ret != 0:\n log.error('fuse_access(): fuse_reply_* failed with %s', strerror(-ret))\n\n\n\ncdef void fuse_poll (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi,\n fuse_pollhandle *ph):\n cdef _Container c = _Container()\n cdef object py_ph\n c.req = req\n c.ino = ino\n if fi is NULL:\n c.fh = 0\n else:\n c.fh = fi.fh\n if ph == NULL:\n py_ph = None\n else:\n py_ph = PollHandle.from_ptr(ph)\n save_retval(fuse_poll_async(c, py_ph))\n\nasync def fuse_poll_async (_Container c, object py_ph):\n cdef int ret\n cdef unsigned revents\n\n ctx = get_request_context(c.req)\n try:\n result = await operations.poll(c.ino, c.fh, py_ph, ctx)\n except FUSEError as e:\n ret = fuse_reply_err(c.req, e.errno)\n else:\n revents = (result if result is not None else 0)\n ret = fuse_reply_poll(c.req, revents)\n\n if ret != 0:\n log.error('fuse_poll(): fuse_reply_* failed with %s', strerror(-ret))\n\n\ncdef void fuse_create (fuse_req_t req, fuse_ino_t parent, const_char *name,\n mode_t mode, fuse_file_info *fi):\n cdef _Container c = _Container()\n c.req = req\n c.parent = parent\n c.mode = mode\n c.fi = fi[0]\n save_retval(fuse_create_async(c, PyBytes_FromString(name)))\n\nasync def fuse_create_async (_Container c, name):\n cdef int ret\n cdef EntryAttributes entry\n cdef FileInfo fi\n\n ctx = get_request_context(c.req)\n try:\n tmp = await operations.create(c.parent, name, c.mode, c.fi.flags, ctx)\n except FUSEError as e:\n ret = fuse_reply_err(c.req, e.errno)\n else:\n fi = tmp[0]\n entry = tmp[1]\n fi._copy_to_fuse(&c.fi)\n ret = fuse_reply_create(c.req, &entry.fuse_param, &c.fi)\n\n if ret != 0:\n log.error('fuse_create(): fuse_reply_* failed with %s', strerror(-ret))\n" }, { "path": "src/pyfuse3/internal.pxi", "content": "'''\ninternal.pxi\n\nThis file defines functions and data structures that are used internally by\npyfuse3. It is included by __init__.pyx.\n\nCopyright © 2013 Nikolaus Rath \n\nThis file is part of pyfuse3. This work may be distributed under\nthe terms of the GNU LGPL.\n'''\n\ncdef void save_retval(object val):\n global py_retval\n if py_retval is not None and val is not None:\n log.error('py_retval was not awaited - please report a bug at '\n 'https://github.com/libfuse/pyfuse3/issues!')\n py_retval = val\n\ncdef object get_request_context(fuse_req_t req):\n '''Get RequestContext() object'''\n\n cdef const_fuse_ctx* context\n cdef RequestContext ctx\n\n context = fuse_req_ctx(req)\n ctx = RequestContext.__new__(RequestContext)\n ctx.pid = context.pid\n ctx.uid = context.uid\n ctx.gid = context.gid\n ctx.umask = context.umask\n\n return ctx\n\ncdef void init_fuse_ops():\n '''Initialize fuse_lowlevel_ops structure'''\n\n string.memset(&fuse_ops, 0, sizeof(fuse_lowlevel_ops))\n\n fuse_ops.init = fuse_init\n fuse_ops.lookup = fuse_lookup\n fuse_ops.forget = fuse_forget\n fuse_ops.getattr = fuse_getattr\n fuse_ops.setattr = fuse_setattr\n fuse_ops.readlink = fuse_readlink\n fuse_ops.mknod = fuse_mknod\n fuse_ops.mkdir = fuse_mkdir\n fuse_ops.unlink = fuse_unlink\n fuse_ops.rmdir = fuse_rmdir\n fuse_ops.symlink = fuse_symlink\n fuse_ops.rename = fuse_rename\n fuse_ops.link = fuse_link\n fuse_ops.open = fuse_open\n fuse_ops.read = fuse_read\n fuse_ops.write = fuse_write\n fuse_ops.flush = fuse_flush\n fuse_ops.release = fuse_release\n fuse_ops.fsync = fuse_fsync\n fuse_ops.opendir = fuse_opendir\n fuse_ops.readdirplus = fuse_readdirplus\n fuse_ops.releasedir = fuse_releasedir\n fuse_ops.fsyncdir = fuse_fsyncdir\n fuse_ops.statfs = fuse_statfs\n ASSIGN_NOT_DARWIN(fuse_ops.setxattr, &fuse_setxattr)\n ASSIGN_NOT_DARWIN(fuse_ops.getxattr, &fuse_getxattr)\n fuse_ops.listxattr = fuse_listxattr\n fuse_ops.removexattr = fuse_removexattr\n fuse_ops.access = fuse_access\n fuse_ops.create = fuse_create\n fuse_ops.forget_multi = fuse_forget_multi\n fuse_ops.write_buf = fuse_write_buf\n fuse_ops.poll = fuse_poll\n\ncdef make_fuse_args(args, fuse_args* f_args):\n cdef char* arg\n cdef int i\n cdef ssize_t size_s\n cdef size_t size\n\n args_new = [ b'pyfuse3' ]\n for el in args:\n args_new.append(b'-o')\n args_new.append(el.encode('us-ascii'))\n args = args_new\n\n f_args.argc = len(args)\n if f_args.argc == 0:\n f_args.argv = NULL\n return\n\n f_args.allocated = 1\n f_args.argv = stdlib.calloc( f_args.argc, sizeof(char*))\n\n if f_args.argv is NULL:\n cpython.exc.PyErr_NoMemory()\n\n try:\n for (i, el) in enumerate(args):\n PyBytes_AsStringAndSize(el, &arg, &size_s)\n size = size_s # guaranteed positive\n f_args.argv[i] = stdlib.malloc((size+1)*sizeof(char))\n\n if f_args.argv[i] is NULL:\n cpython.exc.PyErr_NoMemory()\n\n string.strncpy(f_args.argv[i], arg, size+1)\n except:\n for i in range(f_args.argc):\n # Freeing a NULL pointer (if this element has not been allocated\n # yet) is fine.\n stdlib.free(f_args.argv[i])\n stdlib.free(f_args.argv)\n raise\n\ndef _notify_loop():\n '''Process async invalidate_entry calls.'''\n\n while True:\n req = _notify_queue.get()\n if req is None:\n log.debug('terminating notify thread')\n break\n\n (inode_p, name, deleted, ignore_enoent) = req\n try:\n invalidate_entry(inode_p, name, deleted)\n except Exception as exc:\n if ignore_enoent and isinstance(exc, FileNotFoundError):\n pass\n else:\n log.exception('Failed to submit invalidate_entry request for '\n 'parent inode %d, name %s', req[0], req[1])\n\ncdef str2bytes(s):\n '''Convert *s* to bytes'''\n\n return s.encode(fse, 'surrogateescape')\n\ncdef bytes2str(s):\n '''Convert *s* to str'''\n\n return s.decode(fse, 'surrogateescape')\n\ncdef strerror(int errno):\n try:\n return os.strerror(errno)\n except ValueError:\n return 'errno: %d' % errno\n\ncdef PyBytes_from_bufvec(fuse_bufvec *src):\n cdef fuse_bufvec dst\n cdef size_t len_\n cdef ssize_t res\n\n len_ = fuse_buf_size(src) - src.off\n if len_ > PY_SSIZE_T_MAX:\n raise OverflowError('Value too long to convert to Python')\n buf = PyBytes_FromStringAndSize(NULL, len_)\n dst.count = 1\n dst.idx = 0\n dst.off = 0\n dst.buf[0].mem = PyBytes_AS_STRING(buf)\n dst.buf[0].size = len_\n dst.buf[0].flags = 0\n res = fuse_buf_copy(&dst, src, 0)\n if res < 0:\n raise OSError(errno.errno, 'fuse_buf_copy failed with '\n + strerror(errno.errno))\n elif res < len_:\n # This is expected to be rare\n return buf[:res]\n else:\n return buf\n\ncdef void* calloc_or_raise(size_t nmemb, size_t size) except NULL:\n cdef void* mem\n mem = stdlib.calloc(nmemb, size)\n if mem is NULL:\n raise MemoryError()\n return mem\n\ncdef class _WorkerData:\n \"\"\"For internal use by pyfuse3 only.\"\"\"\n\n cdef int task_count\n cdef int task_serial\n cdef object read_lock\n cdef int active_readers\n\n def __init__(self):\n self.read_lock = None\n self.active_readers = 0\n\n cdef get_name(self):\n self.task_serial += 1\n return 'pyfuse-%02d' % self.task_serial\n\n# Delay initialization so that pyfuse3.asyncio can replace\n# the trio module.\ncdef _WorkerData worker_data\n\nasync def _wait_fuse_readable():\n '''Wait for FUSE fd to become readable\n\n Return True if the fd is readable, or False if the main loop\n should terminate.\n '''\n\n if worker_data.read_lock is None:\n worker_data.read_lock = trio.Lock()\n\n #name = trio.lowlevel.current_task().name\n worker_data.active_readers += 1\n try:\n #log.debug('%s: Waiting for read lock...', name)\n async with worker_data.read_lock:\n #log.debug('%s: Waiting for fuse fd to become readable...', name)\n if fuse_session_exited(session):\n log.debug('FUSE session exit flag set while waiting for FUSE fd '\n 'to become readable.')\n return False\n await trio.lowlevel.wait_readable(session_fd)\n #log.debug('%s: fuse fd readable, unparking next task.', name)\n except trio.ClosedResourceError:\n log.debug('FUSE fd about to be closed.')\n return False\n\n finally:\n worker_data.active_readers -= 1\n\n return True\n\n@async_wrapper\nasync def _session_loop(nursery, int min_tasks, int max_tasks):\n cdef int res\n cdef fuse_buf buf\n\n name = trio.lowlevel.current_task().name\n\n buf.mem = NULL\n buf.size = 0\n buf.pos = 0\n buf.flags = 0\n while not fuse_session_exited(session):\n if worker_data.active_readers > min_tasks:\n log.debug('%s: too many idle tasks (%d total, %d waiting), terminating.',\n name, worker_data.task_count, worker_data.active_readers)\n break\n\n if not await _wait_fuse_readable():\n break\n\n res = fuse_session_receive_buf(session, &buf)\n if not worker_data.active_readers and worker_data.task_count < max_tasks:\n worker_data.task_count += 1\n log.debug('%s: No tasks waiting, starting another worker (now %d total).',\n name, worker_data.task_count)\n nursery.start_soon(_session_loop, nursery, min_tasks, max_tasks,\n name=worker_data.get_name())\n\n if res == -errno.EINTR:\n continue\n elif res < 0:\n raise OSError(-res, 'fuse_session_receive_buf failed with '\n + strerror(-res))\n elif res == 0:\n break\n\n # When fuse_session_process_buf() calls back into one of our handler\n # methods, the handler will start a co-routine and store it in\n # py_retval.\n #log.debug('%s: processing request...', name)\n save_retval(None)\n fuse_session_process_buf(session, &buf)\n if py_retval is not None:\n await py_retval\n #log.debug('%s: processing complete.', name)\n\n log.debug('%s: terminated', name)\n stdlib.free(buf.mem)\n worker_data.task_count -= 1\n" }, { "path": "src/pyfuse3/macros.c", "content": "/*\nmacros.c - Pre-processor macros\n\nCopyright © 2013 Nikolaus Rath \n\nThis file is part of pyfuse3. This work may be distributed under\nthe terms of the GNU LGPL.\n*/\n\n\n/*\n * Macros to access the nanosecond attributes in struct stat in a\n * platform independent way. Stolen from fuse_misc.h.\n */\n\n#if PLATFORM == PLATFORM_LINUX\n#define GET_ATIME_NS(stbuf) ((stbuf)->st_atim.tv_nsec)\n#define GET_CTIME_NS(stbuf) ((stbuf)->st_ctim.tv_nsec)\n#define GET_MTIME_NS(stbuf) ((stbuf)->st_mtim.tv_nsec)\n#define SET_ATIME_NS(stbuf, val) (stbuf)->st_atim.tv_nsec = (val)\n#define SET_CTIME_NS(stbuf, val) (stbuf)->st_ctim.tv_nsec = (val)\n#define SET_MTIME_NS(stbuf, val) (stbuf)->st_mtim.tv_nsec = (val)\n\n#define GET_BIRTHTIME_NS(stbuf) (0)\n#define GET_BIRTHTIME(stbuf) (0)\n#define SET_BIRTHTIME_NS(stbuf, val) do {} while (0)\n#define SET_BIRTHTIME(stbuf, val) do {} while (0)\n\n/* BSD and OS-X */\n#else\n#define GET_BIRTHTIME(stbuf) ((stbuf)->st_birthtime)\n#define SET_BIRTHTIME(stbuf, val) ((stbuf)->st_birthtime = (val))\n\n#define GET_ATIME_NS(stbuf) ((stbuf)->st_atimespec.tv_nsec)\n#define GET_CTIME_NS(stbuf) ((stbuf)->st_ctimespec.tv_nsec)\n#define GET_MTIME_NS(stbuf) ((stbuf)->st_mtimespec.tv_nsec)\n#define GET_BIRTHTIME_NS(stbuf) ((stbuf)->st_birthtimespec.tv_nsec)\n#define SET_ATIME_NS(stbuf, val) ((stbuf)->st_atimespec.tv_nsec = (val))\n#define SET_CTIME_NS(stbuf, val) ((stbuf)->st_ctimespec.tv_nsec = (val))\n#define SET_MTIME_NS(stbuf, val) ((stbuf)->st_mtimespec.tv_nsec = (val))\n#define SET_BIRTHTIME_NS(stbuf, val) ((stbuf)->st_birthtimespec.tv_nsec = (val))\n#endif\n\n\n#if PLATFORM == PLATFORM_LINUX || PLATFORM == PLATFORM_BSD\n#define ASSIGN_DARWIN(x,y)\n#define ASSIGN_NOT_DARWIN(x,y) ((x) = (y))\n#elif PLATFORM == PLATFORM_DARWIN\n#define ASSIGN_DARWIN(x,y) ((x) = (y))\n#define ASSIGN_NOT_DARWIN(x,y)\n#else\n#error This should not happen\n#endif\n" }, { "path": "src/pyfuse3/macros.pxd", "content": "'''\nmacros.pxd\n\nCython definitions for macros.c\n\nCopyright © 2018 Nikolaus Rath \n\nThis file is part of pyfuse3. This work may be distributed under\nthe terms of the GNU LGPL.\n'''\n\nfrom posix.stat cimport struct_stat\n\ncdef extern from \"macros.c\" nogil:\n long GET_BIRTHTIME(struct_stat* buf)\n long GET_ATIME_NS(struct_stat* buf)\n long GET_CTIME_NS(struct_stat* buf)\n long GET_MTIME_NS(struct_stat* buf)\n long GET_BIRTHTIME_NS(struct_stat* buf)\n\n void SET_BIRTHTIME(struct_stat* buf, long val)\n void SET_ATIME_NS(struct_stat* buf, long val)\n void SET_CTIME_NS(struct_stat* buf, long val)\n void SET_MTIME_NS(struct_stat* buf, long val)\n void SET_BIRTHTIME_NS(struct_stat* buf, long val)\n\n void ASSIGN_DARWIN(void*, void*)\n void ASSIGN_NOT_DARWIN(void*, void*)\n" }, { "path": "src/pyfuse3/py.typed", "content": "" }, { "path": "src/pyfuse3/pyfuse3.h", "content": "/*\npyfuse3.h\n\nCopyright © 2013 Nikolaus Rath \n\nThis file is part of pyfuse3. This work may be distributed under\nthe terms of the GNU LGPL.\n*/\n\n#define PLATFORM_LINUX 1\n#define PLATFORM_BSD 2\n#define PLATFORM_DARWIN 3\n\n#ifdef __linux__\n#define PLATFORM PLATFORM_LINUX\n#elif __FreeBSD_kernel__ && __GLIBC__\n#define PLATFORM PLATFORM_LINUX\n#elif __FreeBSD__\n#define PLATFORM PLATFORM_BSD\n#elif __NetBSD__\n#define PLATFORM PLATFORM_BSD\n#elif __APPLE__ && __MACH__\n#define PLATFORM PLATFORM_DARWIN\n#else\n#error \"Unable to determine system (Linux/FreeBSD/NetBSD/Darwin)\"\n#endif\n\n#if PLATFORM == PLATFORM_DARWIN\n#include \"darwin_compat.h\"\n#else\n/* See also: Include/pthreads.pxd */\n#include \n#endif\n\n#include \n\n#if FUSE_VERSION < 32\n#error FUSE version too old, 3.2.0 or newer required\n#endif\n" }, { "path": "src/pyfuse3/xattr.h", "content": "/*\n * xattr.h\n *\n * Platform-independent interface to extended attributes\n *\n * Copyright © 2015 Nikolaus Rath \n *\n * This file is part of pyfuse3. This work may be distributed under the\n * terms of the GNU LGPL.\n*/\n\n#ifndef UNUSED\n# if defined(__GNUC__)\n# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))\n# define UNUSED __attribute__ ((__unused__))\n# else\n# define UNUSED\n# endif\n# else\n# define UNUSED\n# endif\n#endif\n\n/*\n * Linux\n */\n#if PLATFORM == PLATFORM_LINUX\n#include \n/*\n * Newer versions of attr deprecate attr/xattr.h which defines ENOATTR as a\n * synonym for ENODATA. To keep compatibility with the old style and the new,\n * define this ourselves.\n */\n#ifndef ENOATTR\n#define ENOATTR ENODATA\n#endif\n\n#define EXTATTR_NAMESPACE_USER 0\n#define EXTATTR_NAMESPACE_SYSTEM 0\n#define XATTR_NOFOLLOW 0\n#define XATTR_NODEFAULT 0\n#define XATTR_NOSECURITY 0\n\nstatic ssize_t getxattr_p (char *path, char *name, void *value, size_t size,\n UNUSED int namespace) {\n return getxattr(path, name, value, size);\n}\nstatic int setxattr_p (char *path, char *name, void *value, size_t size,\n UNUSED int namespace) {\n return setxattr(path, name, value, size, 0);\n}\n\n\n/*\n * FreeBSD & NetBSD\n */\n#elif PLATFORM == PLATFORM_BSD\n#include \n#include \n#include \n#include \n\n#define XATTR_NOFOLLOW 0\n#define XATTR_NODEFAULT 0\n#define XATTR_NOSECURITY 0\n\n/* FreeBSD doesn't have on operation to only set the attribute\n if it already exists (XATTR_REPLACE), or only if it does not\n yet exist (XATTR_CREATE). Setting these values to zero ensures\n that we can never test positively for them */\n#define XATTR_CREATE 0\n#define XATTR_REPLACE 0\n\nstatic ssize_t getxattr_p (char *path, char *name, void *value, size_t size,\n int namespace) {\n /* If size > SSIZE_MAX, we cannot determine if we got all the data\n (because the return value doesn't fit into ssize_t) */\n if (size >= SSIZE_MAX) {\n errno = EINVAL;\n return -1;\n }\n\n ssize_t ret;\n ret = extattr_get_file(path, namespace, name, value, size);\n if (ret > 0 && (size_t) ret == size) {\n errno = ERANGE;\n return -1;\n }\n return ret;\n}\n\nstatic int setxattr_p (char *path, char *name, void *value, size_t size,\n int namespace) {\n if (size >= SSIZE_MAX) {\n errno = EINVAL;\n return -1;\n }\n\n ssize_t ret;\n ret = extattr_set_file(path, namespace, name, value, size);\n if (ret < 0) {\n /* Errno values really ought to fit into int, but better safe\n than sorry */\n if (ret < INT_MIN)\n return -EOVERFLOW;\n else\n return (int) ret;\n }\n if ((size_t)ret != size) {\n errno = ENOSPC;\n return -1;\n }\n return 0;\n}\n\n\n/*\n * Darwin\n */\n#elif PLATFORM == PLATFORM_DARWIN\n#include \n\n#define EXTATTR_NAMESPACE_USER 0\n#define EXTATTR_NAMESPACE_SYSTEM 0\n\nstatic ssize_t getxattr_p (char *path, char *name, void *value, size_t size,\n UNUSED int namespace) {\n return getxattr(path, name, value, size, 0, 0);\n}\nstatic int setxattr_p (char *path, char *name, void *value, size_t size,\n UNUSED int namespace) {\n return setxattr(path, name, value, size, 0, 0);\n}\n\n\n/*\n * Unknown system\n */\n#else\n#error This should not happen\n#endif\n" }, { "path": "test/conftest.py", "content": "import gc\nimport logging\nimport os.path\nimport sys\nimport time\n\nimport pytest\n\n# Enable output checks\npytest_plugins = 'pytest_checklogs'\n\n\n# Register false positives\n@pytest.fixture(autouse=True)\ndef register_false_checklog_pos(reg_output):\n # DeprecationWarnings are unfortunately quite often a result of indirect\n # imports via third party modules, so we can't actually fix them.\n reg_output(r'(Pending)?DeprecationWarning', count=0)\n\n # Valgrind output\n reg_output(r'^==\\d+== Memcheck, a memory error detector$')\n reg_output(r'^==\\d+== For counts of detected and suppressed errors, rerun with: -v')\n reg_output(r'^==\\d+== ERROR SUMMARY: 0 errors from 0 contexts')\n\n\ndef pytest_addoption(parser):\n group = parser.getgroup(\"general\")\n group._addoption(\n \"--installed\", action=\"store_true\", default=False, help=\"Test the installed package.\"\n )\n\n group = parser.getgroup(\"terminal reporting\")\n group._addoption(\n \"--logdebug\",\n action=\"append\",\n metavar='',\n help=\"Activate debugging output from for tests. Use `all` \"\n \"to get debug messages from all modules. This option can be \"\n \"specified multiple times.\",\n )\n\n\n# If a test fails, wait a moment before retrieving the captured\n# stdout/stderr. When using a server process, this makes sure that we capture\n# any potential output of the server that comes *after* a test has failed. For\n# example, if a request handler raises an exception, the server first signals an\n# error to FUSE (causing the test to fail), and then logs the exception. Without\n# the extra delay, the exception will go into nowhere.\n@pytest.hookimpl(hookwrapper=True)\ndef pytest_pyfunc_call(pyfuncitem):\n outcome = yield\n failed = outcome.excinfo is not None\n if failed:\n time.sleep(1)\n\n\ndef pytest_configure(config):\n # If we are running from the source directory, make sure that we load\n # modules from here\n basedir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))\n if not config.getoption('installed'):\n pyfuse3_path = os.path.join(basedir, 'src')\n if os.path.exists(os.path.join(basedir, 'setup.py')) and os.path.exists(\n os.path.join(basedir, 'src', 'pyfuse3', '__init__.pyx')\n ):\n sys.path.insert(0, pyfuse3_path)\n\n # Make sure that called processes use the same path\n pp = os.environ.get('PYTHONPATH', None)\n if pp:\n pp = '%s:%s' % (pyfuse3_path, pp)\n else:\n pp = pyfuse3_path\n os.environ['PYTHONPATH'] = pp\n\n try:\n import faulthandler\n except ImportError:\n pass\n else:\n faulthandler.enable()\n\n # When running from VCS repo, enable all warnings\n if os.path.exists(os.path.join(basedir, 'MANIFEST.in')):\n import warnings\n\n warnings.resetwarnings()\n warnings.simplefilter('default')\n\n # Configure logging. We don't set a default handler but rely on\n # the catchlog pytest plugin.\n logdebug = config.getoption('logdebug')\n root_logger = logging.getLogger()\n if logdebug is not None:\n logging.disable(logging.NOTSET)\n if 'all' in logdebug:\n root_logger.setLevel(logging.DEBUG)\n else:\n for module in logdebug:\n logging.getLogger(module).setLevel(logging.DEBUG)\n else:\n root_logger.setLevel(logging.INFO)\n logging.disable(logging.DEBUG)\n logging.captureWarnings(capture=True)\n\n\n# Run gc.collect() at the end of every test, so that we get ResourceWarnings\n# as early as possible.\ndef pytest_runtest_teardown(item, nextitem):\n gc.collect()\n" }, { "path": "test/pytest.ini", "content": "[pytest]\naddopts = --verbose --assert=rewrite --tb=native -x\nmarkers = uses_fuse\n" }, { "path": "test/pytest_checklogs.py", "content": "#!/usr/bin/env python3\n'''\npytest_checklogs.py - this file is part of S3QL.\n\nCopyright (C) 2008 Nikolaus Rath \n\nThis work can be distributed under the terms of the GNU GPLv3.\n\npy.test plugin to look for suspicious phrases in messages emitted on\nstdout/stderr or via the logging module.\n\nFalse positives can be registered via a new `reg_output` fixture (for messages\nto stdout/stderr), and a `assert_logs` function (for logging messages).\n'''\n\nimport functools\nimport logging\nimport re\nfrom collections.abc import Generator\nfrom contextlib import contextmanager\n\nimport pytest\n\n\nclass CountMessagesHandler(logging.Handler):\n def __init__(self, level: int = logging.NOTSET) -> None:\n super().__init__(level)\n self.count: int = 0\n\n def emit(self, record: logging.LogRecord) -> None:\n self.count += 1\n\n\n@contextmanager\ndef assert_logs(\n pattern: str, level: int = logging.WARNING, count: int | None = None\n) -> Generator[None, None, None]:\n '''Assert that suite emits specified log message\n\n *pattern* is matched against the *unformatted* log message, i.e. before any\n arguments are merged.\n\n If *count* is not None, raise an exception unless exactly *count* matching\n messages are caught.\n\n Matched log records will also be flagged so that the caplog fixture\n does not generate exceptions for them (no matter their severity).\n '''\n\n def filter(record: logging.LogRecord) -> bool:\n if record.levelno == level and re.search(pattern, record.msg):\n record.checklogs_ignore = True\n return True\n return False\n\n handler = CountMessagesHandler()\n handler.setLevel(level)\n handler.addFilter(filter)\n logger = logging.getLogger()\n logger.addHandler(handler)\n try:\n yield\n\n finally:\n logger.removeHandler(handler)\n\n if count is not None and handler.count != count:\n pytest.fail(\n 'Expected to catch %d %r messages, but got only %d'\n % (count, pattern, handler.count)\n )\n\n\ndef check_test_output(capfd, item):\n (stdout, stderr) = capfd.readouterr()\n\n # Strip out false positives\n try:\n false_pos = item.checklogs_fp\n except AttributeError:\n false_pos = ()\n for pattern, flags, count in false_pos:\n cp = re.compile(pattern, flags)\n (stdout, cnt) = cp.subn('', stdout, count=count)\n if count == 0 or count - cnt > 0:\n stderr = cp.sub('', stderr, count=count - cnt)\n\n for pattern in (\n 'exception',\n 'error',\n 'warning',\n 'fatal',\n 'traceback',\n 'fault',\n 'crash(?:ed)?',\n 'abort(?:ed)',\n 'fishy',\n ):\n cp = re.compile(r'\\b{}\\b'.format(pattern), re.IGNORECASE | re.MULTILINE)\n hit = cp.search(stderr)\n if hit:\n pytest.fail('Suspicious output to stderr (matched \"%s\")' % hit.group(0))\n hit = cp.search(stdout)\n if hit:\n pytest.fail('Suspicious output to stdout (matched \"%s\")' % hit.group(0))\n\n\ndef register_output(item, pattern: str, count: int = 1, flags: int = re.MULTILINE) -> None:\n '''Register *pattern* as false positive for output checking\n\n This prevents the test from failing because the output otherwise\n appears suspicious.\n '''\n\n item.checklogs_fp.append((pattern, flags, count))\n\n\n@pytest.fixture()\ndef reg_output(request):\n assert not hasattr(request.node, 'checklogs_fp')\n request.node.checklogs_fp = []\n return functools.partial(register_output, request.node)\n\n\n# Autouse fixtures are instantiated before explicitly used fixtures, this should also\n# catch log messages emitted when e.g. initializing resources in other fixtures.\n@pytest.fixture(autouse=True)\ndef check_output(caplog, capfd, request):\n yield\n for when in (\"setup\", \"call\", \"teardown\"):\n for record in caplog.get_records(when):\n if record.levelno >= logging.WARNING and not getattr(record, 'checklogs_ignore', False):\n pytest.fail('Logger received warning messages.')\n check_test_output(capfd, request.node)\n" }, { "path": "test/test_api.py", "content": "#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n'''\ntest_api.py - Unit tests for pyfuse3.\n\nCopyright © 2015 Nikolaus Rath \n\nThis file is part of pyfuse3. This work may be distributed under\nthe terms of the GNU LGPL.\n'''\n\nif __name__ == '__main__':\n import sys\n\n import pytest\n\n sys.exit(pytest.main([__file__] + sys.argv[1:]))\n\nimport errno\nimport os\nimport tempfile\nfrom copy import copy\nfrom pickle import PicklingError\n\nimport pytest\n\nimport pyfuse3\nfrom pyfuse3 import EntryAttributes, RequestContext, SetattrFields, StatvfsData\n\n\ndef test_listdir():\n # There is a race-condition here if /usr/bin is modified while the test\n # runs - but hopefully this is sufficiently rare.\n list1 = set(os.listdir('/usr/bin'))\n list2 = set(pyfuse3.listdir('/usr/bin'))\n assert list1 == list2\n\n\ndef test_sup_groups():\n gids = pyfuse3.get_sup_groups(os.getpid())\n gids2 = set(os.getgroups())\n assert gids == gids2\n\n\ndef test_syncfs():\n pyfuse3.syncfs('.')\n\n\ndef _getxattr_helper(path, name):\n errno = None\n try:\n value = pyfuse3.getxattr(path, name)\n except OSError as exc:\n errno = exc.errno\n value = None\n\n if not hasattr(os, 'getxattr'):\n return value\n\n try:\n value2 = os.getxattr(path, name)\n except OSError as exc:\n assert exc.errno == errno\n else:\n assert value2 is not None\n assert value2 == value\n\n return value\n\n\ndef test_entry_res():\n a = EntryAttributes()\n val = 1000.2735\n a.st_atime_ns = int(val * 1e9)\n assert a.st_atime_ns / 1e9 == val\n\n\ndef test_xattr():\n with tempfile.NamedTemporaryFile() as fh:\n key = 'user.new_attribute'\n assert _getxattr_helper(fh.name, key) is None\n value = b'a nice little bytestring'\n\n try:\n pyfuse3.setxattr(fh.name, key, value)\n except OSError as exc:\n if exc.errno == errno.ENOTSUP:\n pytest.skip('xattrs not supported for %s' % fh.name)\n raise\n assert _getxattr_helper(fh.name, key) == value\n\n if not hasattr(os, 'setxattr'):\n return\n\n key = 'user.another_new_attribute'\n assert _getxattr_helper(fh.name, key) is None\n value = b'a nice little bytestring, but slightly modified'\n os.setxattr(fh.name, key, value)\n assert _getxattr_helper(fh.name, key) == value\n\n\ndef test_copy():\n for obj in (SetattrFields(), RequestContext()):\n pytest.raises(PicklingError, copy, obj)\n\n for inst, attr in ((EntryAttributes(), 'st_mode'), (StatvfsData(), 'f_files')):\n setattr(inst, attr, 42)\n inst_copy = copy(inst)\n assert getattr(inst, attr) == getattr(inst_copy, attr)\n\n exc = pyfuse3.FUSEError(10)\n assert exc.errno == copy(exc).errno\n" }, { "path": "test/test_examples.py", "content": "#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n'''\ntest_examples.py - Unit tests for pyfuse3.\n\nCopyright © 2015 Nikolaus Rath \n\nThis file is part of pyfuse3. This work may be distributed under\nthe terms of the GNU LGPL.\n'''\n\nif __name__ == '__main__':\n import sys\n\n import pytest\n\n sys.exit(pytest.main([__file__] + sys.argv[1:]))\n\nimport errno\nimport filecmp\nimport os\nimport shutil\nimport stat\nimport subprocess\nimport sys\nfrom tempfile import NamedTemporaryFile\n\nimport pytest\n\nfrom pyfuse3 import _NANOS_PER_SEC\nfrom util import cleanup, fuse_test_marker, umount, wait_for_mount\n\nbasename = os.path.join(os.path.dirname(__file__), '..')\nTEST_FILE = __file__\n\npytestmark = fuse_test_marker()\n\nwith open(TEST_FILE, 'rb') as fh:\n TEST_DATA = fh.read()\n\n\ndef name_generator(__ctr=[0]):\n __ctr[0] += 1\n return 'testfile_%d' % __ctr[0]\n\n\n@pytest.mark.parametrize('filename', ('hello.py', 'hello_asyncio.py'))\ndef test_hello(tmpdir, filename):\n mnt_dir = str(tmpdir)\n cmdline = [sys.executable, os.path.join(basename, 'examples', filename), mnt_dir]\n mount_process = subprocess.Popen(cmdline, stdin=subprocess.DEVNULL, universal_newlines=True)\n try:\n wait_for_mount(mount_process, mnt_dir)\n assert os.listdir(mnt_dir) == ['message']\n filename = os.path.join(mnt_dir, 'message')\n with open(filename, 'r') as fh:\n assert fh.read() == 'hello world\\n'\n with pytest.raises(IOError) as exc_info:\n open(filename, 'r+')\n assert exc_info.value.errno == errno.EACCES\n with pytest.raises(IOError) as exc_info:\n open(filename + 'does-not-exist', 'r+')\n assert exc_info.value.errno == errno.ENOENT\n except:\n cleanup(mount_process, mnt_dir)\n raise\n else:\n umount(mount_process, mnt_dir)\n\n\ndef test_tmpfs(tmpdir):\n mnt_dir = str(tmpdir)\n cmdline = [sys.executable, os.path.join(basename, 'examples', 'tmpfs.py'), mnt_dir]\n mount_process = subprocess.Popen(cmdline, stdin=subprocess.DEVNULL, universal_newlines=True)\n try:\n wait_for_mount(mount_process, mnt_dir)\n tst_write(mnt_dir)\n tst_mkdir(mnt_dir)\n tst_symlink(mnt_dir)\n tst_mknod(mnt_dir)\n tst_chown(mnt_dir)\n tst_chmod(mnt_dir)\n tst_utimens(mnt_dir)\n tst_rounding(mnt_dir)\n tst_link(mnt_dir)\n tst_rename(mnt_dir)\n tst_readdir(mnt_dir)\n tst_statvfs(mnt_dir)\n tst_truncate_path(mnt_dir)\n tst_truncate_fd(mnt_dir)\n tst_unlink(mnt_dir)\n except:\n cleanup(mount_process, mnt_dir)\n raise\n else:\n umount(mount_process, mnt_dir)\n\n\n@pytest.mark.parametrize('enable_writeback_cache', (True, False))\ndef test_passthroughfs(tmpdir, enable_writeback_cache):\n mnt_dir = str(tmpdir.mkdir('mnt'))\n src_dir = str(tmpdir.mkdir('src'))\n cmdline = [\n sys.executable,\n os.path.join(basename, 'examples', 'passthroughfs.py'),\n src_dir,\n mnt_dir,\n ]\n if enable_writeback_cache:\n cmdline.append('--enable-writeback-cache')\n mount_process = subprocess.Popen(cmdline, stdin=subprocess.DEVNULL, universal_newlines=True)\n try:\n wait_for_mount(mount_process, mnt_dir)\n tst_write(mnt_dir)\n tst_mkdir(mnt_dir)\n tst_symlink(mnt_dir)\n tst_mknod(mnt_dir)\n if os.getuid() == 0:\n tst_chown(mnt_dir)\n tst_chmod(mnt_dir)\n # Underlying fs may not have full nanosecond resolution\n tst_utimens(mnt_dir, ns_tol=1000)\n tst_rounding(mnt_dir)\n tst_link(mnt_dir)\n tst_rename(mnt_dir)\n tst_readdir(mnt_dir)\n tst_statvfs(mnt_dir)\n tst_truncate_path(mnt_dir)\n tst_truncate_fd(mnt_dir)\n tst_unlink(mnt_dir)\n tst_passthrough(src_dir, mnt_dir, enable_writeback_cache=enable_writeback_cache)\n except:\n cleanup(mount_process, mnt_dir)\n raise\n else:\n umount(mount_process, mnt_dir)\n\n\ndef checked_unlink(filename, path, isdir=False):\n fullname = os.path.join(path, filename)\n if isdir:\n os.rmdir(fullname)\n else:\n os.unlink(fullname)\n with pytest.raises(OSError) as exc_info:\n os.stat(fullname)\n assert exc_info.value.errno == errno.ENOENT\n assert filename not in os.listdir(path)\n\n\ndef tst_mkdir(mnt_dir):\n dirname = name_generator()\n fullname = mnt_dir + \"/\" + dirname\n os.mkdir(fullname)\n fstat = os.stat(fullname)\n assert stat.S_ISDIR(fstat.st_mode)\n assert os.listdir(fullname) == []\n assert fstat.st_nlink in (1, 2)\n assert dirname in os.listdir(mnt_dir)\n checked_unlink(dirname, mnt_dir, isdir=True)\n\n\ndef tst_symlink(mnt_dir):\n linkname = name_generator()\n fullname = mnt_dir + \"/\" + linkname\n os.symlink(\"/imaginary/dest\", fullname)\n fstat = os.lstat(fullname)\n assert stat.S_ISLNK(fstat.st_mode)\n assert os.readlink(fullname) == \"/imaginary/dest\"\n assert fstat.st_nlink == 1\n assert linkname in os.listdir(mnt_dir)\n checked_unlink(linkname, mnt_dir)\n\n\ndef tst_mknod(mnt_dir):\n filename = os.path.join(mnt_dir, name_generator())\n shutil.copyfile(TEST_FILE, filename)\n fstat = os.lstat(filename)\n assert stat.S_ISREG(fstat.st_mode)\n assert fstat.st_nlink == 1\n assert os.path.basename(filename) in os.listdir(mnt_dir)\n assert filecmp.cmp(TEST_FILE, filename, False)\n checked_unlink(filename, mnt_dir)\n\n\ndef tst_chown(mnt_dir):\n filename = os.path.join(mnt_dir, name_generator())\n os.mkdir(filename)\n fstat = os.lstat(filename)\n uid = fstat.st_uid\n gid = fstat.st_gid\n\n uid_new = uid + 1\n os.chown(filename, uid_new, -1)\n fstat = os.lstat(filename)\n assert fstat.st_uid == uid_new\n assert fstat.st_gid == gid\n\n gid_new = gid + 1\n os.chown(filename, -1, gid_new)\n fstat = os.lstat(filename)\n assert fstat.st_uid == uid_new\n assert fstat.st_gid == gid_new\n\n checked_unlink(filename, mnt_dir, isdir=True)\n\n\ndef tst_chmod(mnt_dir):\n filename = os.path.join(mnt_dir, name_generator())\n os.mkdir(filename)\n fstat = os.lstat(filename)\n mode = stat.S_IMODE(fstat.st_mode)\n\n mode_new = 0o640\n assert mode != mode_new\n os.chmod(filename, mode_new)\n fstat = os.lstat(filename)\n assert stat.S_IMODE(fstat.st_mode) == mode_new\n\n checked_unlink(filename, mnt_dir, isdir=True)\n\n\ndef tst_write(mnt_dir):\n name = os.path.join(mnt_dir, name_generator())\n shutil.copyfile(TEST_FILE, name)\n assert filecmp.cmp(name, TEST_FILE, False)\n checked_unlink(name, mnt_dir)\n\n\ndef tst_unlink(mnt_dir):\n name = os.path.join(mnt_dir, name_generator())\n data1 = b'foo'\n data2 = b'bar'\n\n with open(os.path.join(mnt_dir, name), 'wb+', buffering=0) as fh:\n fh.write(data1)\n checked_unlink(name, mnt_dir)\n fh.write(data2)\n fh.seek(0)\n assert fh.read() == data1 + data2\n\n\ndef tst_statvfs(mnt_dir):\n os.statvfs(mnt_dir)\n\n\ndef tst_link(mnt_dir):\n name1 = os.path.join(mnt_dir, name_generator())\n name2 = os.path.join(mnt_dir, name_generator())\n shutil.copyfile(TEST_FILE, name1)\n assert filecmp.cmp(name1, TEST_FILE, False)\n os.link(name1, name2)\n\n fstat1 = os.lstat(name1)\n fstat2 = os.lstat(name2)\n\n assert fstat1 == fstat2\n assert fstat1.st_nlink == 2\n\n assert os.path.basename(name2) in os.listdir(mnt_dir)\n assert filecmp.cmp(name1, name2, False)\n os.unlink(name2)\n fstat1 = os.lstat(name1)\n assert fstat1.st_nlink == 1\n os.unlink(name1)\n\n\ndef tst_rename(mnt_dir):\n name1 = os.path.join(mnt_dir, name_generator())\n name2 = os.path.join(mnt_dir, name_generator())\n shutil.copyfile(TEST_FILE, name1)\n\n assert os.path.basename(name1) in os.listdir(mnt_dir)\n assert os.path.basename(name2) not in os.listdir(mnt_dir)\n assert filecmp.cmp(name1, TEST_FILE, False)\n\n fstat1 = os.lstat(name1)\n os.rename(name1, name2)\n fstat2 = os.lstat(name2)\n\n assert fstat1 == fstat2\n assert filecmp.cmp(name2, TEST_FILE, False)\n assert os.path.basename(name1) not in os.listdir(mnt_dir)\n assert os.path.basename(name2) in os.listdir(mnt_dir)\n os.unlink(name2)\n\n\ndef tst_readdir(mnt_dir):\n dir_ = os.path.join(mnt_dir, name_generator())\n file_ = dir_ + \"/\" + name_generator()\n subdir = dir_ + \"/\" + name_generator()\n subfile = subdir + \"/\" + name_generator()\n\n os.mkdir(dir_)\n shutil.copyfile(TEST_FILE, file_)\n os.mkdir(subdir)\n shutil.copyfile(TEST_FILE, subfile)\n\n listdir_is = os.listdir(dir_)\n listdir_is.sort()\n listdir_should = [os.path.basename(file_), os.path.basename(subdir)]\n listdir_should.sort()\n assert listdir_is == listdir_should\n\n os.unlink(file_)\n os.unlink(subfile)\n os.rmdir(subdir)\n os.rmdir(dir_)\n\n\ndef tst_truncate_path(mnt_dir):\n assert len(TEST_DATA) > 1024\n\n filename = os.path.join(mnt_dir, name_generator())\n with open(filename, 'wb') as fh:\n fh.write(TEST_DATA)\n\n fstat = os.stat(filename)\n size = fstat.st_size\n assert size == len(TEST_DATA)\n\n # Add zeros at the end\n os.truncate(filename, size + 1024)\n assert os.stat(filename).st_size == size + 1024\n with open(filename, 'rb') as fh:\n assert fh.read(size) == TEST_DATA\n assert fh.read(1025) == b'\\0' * 1024\n\n # Truncate data\n os.truncate(filename, size - 1024)\n assert os.stat(filename).st_size == size - 1024\n with open(filename, 'rb') as fh:\n assert fh.read(size) == TEST_DATA[: size - 1024]\n\n os.unlink(filename)\n\n\ndef tst_truncate_fd(mnt_dir):\n assert len(TEST_DATA) > 1024\n with NamedTemporaryFile('w+b', 0, dir=mnt_dir) as fh:\n fd = fh.fileno()\n fh.write(TEST_DATA)\n fstat = os.fstat(fd)\n size = fstat.st_size\n assert size == len(TEST_DATA)\n\n # Add zeros at the end\n os.ftruncate(fd, size + 1024)\n assert os.fstat(fd).st_size == size + 1024\n fh.seek(0)\n assert fh.read(size) == TEST_DATA\n assert fh.read(1025) == b'\\0' * 1024\n\n # Truncate data\n os.ftruncate(fd, size - 1024)\n assert os.fstat(fd).st_size == size - 1024\n fh.seek(0)\n assert fh.read(size) == TEST_DATA[: size - 1024]\n\n\ndef tst_utimens(mnt_dir, ns_tol=0):\n filename = os.path.join(mnt_dir, name_generator())\n os.mkdir(filename)\n fstat = os.lstat(filename)\n\n atime = fstat.st_atime + 42.28\n mtime = fstat.st_mtime - 42.23\n atime_ns = fstat.st_atime_ns + int(42.28 * 1e9)\n mtime_ns = fstat.st_mtime_ns - int(42.23 * 1e9)\n os.utime(filename, None, ns=(atime_ns, mtime_ns))\n\n fstat = os.lstat(filename)\n\n assert abs(fstat.st_atime - atime) < 1e-3\n assert abs(fstat.st_mtime - mtime) < 1e-3\n assert abs(fstat.st_atime_ns - atime_ns) <= ns_tol\n assert abs(fstat.st_mtime_ns - mtime_ns) <= ns_tol\n\n checked_unlink(filename, mnt_dir, isdir=True)\n\n\ndef tst_rounding(mnt_dir, ns_tol=0):\n filename = os.path.join(mnt_dir, name_generator())\n os.mkdir(filename)\n fstat = os.lstat(filename)\n\n # Approximately 67 years, ending in 999.\n # Note: 67 years were chosen to avoid y2038 issues (1970 + 67 = 2037).\n # Testing these is **not** in scope of this test.\n secs = 67 * 365 * 24 * 3600 + 999\n # Max nanos\n nanos = _NANOS_PER_SEC - 1\n\n # seconds+ns and ns_tol as a float in seconds\n secs_f = secs + nanos / _NANOS_PER_SEC\n secs_tol = ns_tol / _NANOS_PER_SEC\n\n atime_ns = secs * _NANOS_PER_SEC + nanos\n mtime_ns = atime_ns\n\n os.utime(filename, None, ns=(atime_ns, mtime_ns))\n\n fstat = os.lstat(filename)\n\n assert abs(fstat.st_atime - secs_f) <= secs_tol\n assert abs(fstat.st_mtime - secs_f) <= secs_tol\n\n assert abs(fstat.st_atime_ns - atime_ns) <= ns_tol\n assert abs(fstat.st_mtime_ns - mtime_ns) <= ns_tol\n\n checked_unlink(filename, mnt_dir, isdir=True)\n\n\ndef tst_passthrough(src_dir, mnt_dir, enable_writeback_cache: bool = False):\n # Test propagation from source to mirror\n name = name_generator()\n src_name = os.path.join(src_dir, name)\n mnt_name = os.path.join(mnt_dir, name)\n assert name not in os.listdir(src_dir)\n assert name not in os.listdir(mnt_dir)\n with open(src_name, 'w') as fh:\n fh.write('Hello, world')\n assert name in os.listdir(src_dir)\n assert name in os.listdir(mnt_dir)\n assert_same_stats(src_name, mnt_name, check_times=not enable_writeback_cache)\n\n # Test propagation from mirror to source\n name = name_generator()\n src_name = os.path.join(src_dir, name)\n mnt_name = os.path.join(mnt_dir, name)\n assert name not in os.listdir(src_dir)\n assert name not in os.listdir(mnt_dir)\n with open(mnt_name, 'w') as fh:\n fh.write('Hello, world')\n assert name in os.listdir(src_dir)\n assert name in os.listdir(mnt_dir)\n assert_same_stats(src_name, mnt_name, check_times=not enable_writeback_cache)\n\n # Test propagation inside subdirectory\n name = name_generator()\n src_dir = os.path.join(src_dir, 'subdir')\n mnt_dir = os.path.join(mnt_dir, 'subdir')\n os.mkdir(src_dir)\n src_name = os.path.join(src_dir, name)\n mnt_name = os.path.join(mnt_dir, name)\n assert name not in os.listdir(src_dir)\n assert name not in os.listdir(mnt_dir)\n with open(mnt_name, 'w') as fh:\n fh.write('Hello, world')\n assert name in os.listdir(src_dir)\n assert name in os.listdir(mnt_dir)\n assert_same_stats(src_name, mnt_name, check_times=not enable_writeback_cache)\n\n\ndef assert_same_stats(name1, name2, check_times: bool = True):\n stat1 = os.stat(name1)\n stat2 = os.stat(name2)\n\n for name in (\n 'st_atime_ns',\n 'st_mtime_ns',\n 'st_ctime_ns',\n 'st_mode',\n 'st_ino',\n 'st_nlink',\n 'st_uid',\n 'st_gid',\n 'st_size',\n ):\n v1 = getattr(stat1, name)\n v2 = getattr(stat2, name)\n\n # Known bug, cf. https://github.com/libfuse/pyfuse3/issues/57\n if name.endswith('_ns') and os.getenv('CI') == 'true':\n continue\n\n # When FUSE writeback cache is enabled, the kernel maintains mtime/ctime\n # internally and only flushes them to the underlying filesystem on close.\n # Until then, the timestamps reported for the passthrough mount and the\n # backing directory may legitimately differ, so skip strict time checks.\n if name.endswith('_ns') and not check_times:\n continue\n\n assert v1 == v2, 'Attribute {} differs by {} ({} vs {})'.format(name, v1 - v2, v1, v2)\n" }, { "path": "test/test_fs.py", "content": "#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n'''\ntest_fs.py - Unit tests for pyfuse3.\n\nCopyright © 2015 Nikolaus Rath \n\nThis file is part of pyfuse3. This work may be distributed under\nthe terms of the GNU LGPL.\n'''\n\nimport sys\nfrom typing import cast\n\nimport pytest\n\nif __name__ == '__main__':\n sys.exit(pytest.main([__file__] + sys.argv[1:]))\n\nimport errno\nimport logging\nimport multiprocessing\nimport os\nimport select\nimport stat\nimport threading\nimport time\n\nimport trio\n\nimport pyfuse3\nfrom pyfuse3 import (\n EntryAttributes,\n FileHandleT,\n FileInfo,\n FUSEError,\n InodeT,\n PollHandle,\n ReaddirToken,\n RequestContext,\n)\nfrom util import cleanup, fuse_test_marker, umount, wait_for_mount\n\npytestmark = fuse_test_marker()\n\n\ndef get_mp():\n # We can't use forkserver because we have to make sure\n # that the server inherits the per-test stdout/stderr file\n # descriptors.\n if hasattr(multiprocessing, 'get_context'):\n mp = multiprocessing.get_context('fork')\n else:\n # Older versions only support *fork* anyway\n mp = multiprocessing # type: ignore[assignment]\n if threading.active_count() != 1:\n raise RuntimeError(\"Multi-threaded test running is not supported\")\n\n return mp\n\n\n@pytest.fixture()\ndef testfs(tmpdir):\n yield from _mount_fs(tmpdir, Fs)\n\n\n@pytest.fixture()\ndef pollfs(tmpdir):\n yield from _mount_fs(tmpdir, PollTestFs)\n\n\ndef _mount_fs(tmpdir, fs_class):\n mnt_dir = str(tmpdir)\n mp = get_mp()\n with mp.Manager() as mgr:\n cross_process = mgr.Namespace()\n mount_process = mp.Process(target=run_fs, args=(mnt_dir, cross_process, fs_class))\n\n mount_process.start()\n try:\n wait_for_mount(mount_process, mnt_dir)\n yield (mnt_dir, cross_process)\n except:\n cleanup(mount_process, mnt_dir)\n raise\n else:\n umount(mount_process, mnt_dir)\n\n\ndef test_invalidate_entry(testfs):\n (mnt_dir, fs_state) = testfs\n path = os.path.join(mnt_dir, 'message')\n os.stat(path)\n assert fs_state.lookup_called\n fs_state.lookup_called = False\n os.stat(path)\n assert not fs_state.lookup_called\n\n # Hardcoded sleeptimes - sorry! Needed because of the special semantics of\n # invalidate_entry()\n pyfuse3.setxattr(mnt_dir, 'command', b'forget_entry')\n time.sleep(1.1)\n os.stat(path)\n assert fs_state.lookup_called\n\n\ndef test_invalidate_inode(testfs):\n (mnt_dir, fs_state) = testfs\n with open(os.path.join(mnt_dir, 'message'), 'r') as fh:\n assert fh.read() == 'hello world\\n'\n assert fs_state.read_called\n fs_state.read_called = False\n fh.seek(0)\n assert fh.read() == 'hello world\\n'\n assert not fs_state.read_called\n\n pyfuse3.setxattr(mnt_dir, 'command', b'forget_inode')\n fh.seek(0)\n assert fh.read() == 'hello world\\n'\n assert fs_state.read_called\n\n\ndef test_notify_store(testfs):\n (mnt_dir, fs_state) = testfs\n with open(os.path.join(mnt_dir, 'message'), 'r') as fh:\n pyfuse3.setxattr(mnt_dir, 'command', b'store')\n fs_state.read_called = False\n assert fh.read() == 'hello world\\n'\n assert not fs_state.read_called\n\n\ndef test_notify_poll(pollfs):\n (mnt_dir, fs_state) = pollfs\n path = os.path.join(mnt_dir, 'message')\n\n with open(path, 'rb', buffering=0) as fh:\n poller = select.poll()\n poller.register(fh.fileno(), select.POLLPRI)\n\n events = []\n\n def poll_wait():\n events.extend(poller.poll(5000))\n\n thread = threading.Thread(target=poll_wait)\n thread.start()\n\n deadline = time.monotonic() + 5\n while time.monotonic() < deadline and not fs_state.poll_handle_received:\n time.sleep(0.01)\n\n assert fs_state.poll_called\n assert fs_state.poll_handle_received\n assert not events\n\n pyfuse3.setxattr(path, 'command', b'poll_ready')\n thread.join(5)\n assert not thread.is_alive()\n assert events\n assert events[0][0] == fh.fileno()\n assert events[0][1] & select.POLLPRI\n\n\ndef test_entry_timeout(testfs):\n (mnt_dir, fs_state) = testfs\n fs_state.entry_timeout = 1\n path = os.path.join(mnt_dir, 'message')\n\n os.stat(path)\n assert fs_state.lookup_called\n fs_state.lookup_called = False\n os.stat(path)\n assert not fs_state.lookup_called\n\n time.sleep(fs_state.entry_timeout * 1.1)\n fs_state.lookup_called = False\n os.stat(path)\n assert fs_state.lookup_called\n\n\ndef test_attr_timeout(testfs):\n (mnt_dir, fs_state) = testfs\n fs_state.attr_timeout = 1\n with open(os.path.join(mnt_dir, 'message'), 'r') as fh:\n os.fstat(fh.fileno())\n assert fs_state.getattr_called\n fs_state.getattr_called = False\n os.fstat(fh.fileno())\n assert not fs_state.getattr_called\n\n time.sleep(fs_state.attr_timeout * 1.1)\n fs_state.getattr_called = False\n os.fstat(fh.fileno())\n assert fs_state.getattr_called\n\n\ndef test_terminate(tmpdir):\n mnt_dir = str(tmpdir)\n mp = get_mp()\n with mp.Manager() as mgr:\n fs_state = mgr.Namespace()\n mount_process = mp.Process(target=run_fs, args=(mnt_dir, fs_state))\n\n mount_process.start()\n try:\n wait_for_mount(mount_process, mnt_dir)\n pyfuse3.setxattr(mnt_dir, 'command', b'terminate')\n mount_process.join(5)\n assert mount_process.exitcode is not None\n except:\n cleanup(mount_process, mnt_dir)\n raise\n\n\nclass Fs(pyfuse3.Operations):\n def __init__(self, cross_process):\n super(Fs, self).__init__()\n self.hello_name = b\"message\"\n self.hello_inode = cast(InodeT, pyfuse3.ROOT_INODE + 1)\n self.hello_data = b\"hello world\\n\"\n self.status = cross_process\n self.lookup_cnt = 0\n self.status.getattr_called = False\n self.status.lookup_called = False\n self.status.read_called = False\n self.status.entry_timeout = 99999\n self.status.attr_timeout = 99999\n\n async def getattr(self, inode: InodeT, ctx: RequestContext | None = None) -> EntryAttributes:\n entry = EntryAttributes()\n if inode == pyfuse3.ROOT_INODE:\n entry.st_mode = stat.S_IFDIR | 0o755\n entry.st_size = 0\n elif inode == self.hello_inode:\n entry.st_mode = stat.S_IFREG | 0o644\n entry.st_size = len(self.hello_data)\n else:\n raise pyfuse3.FUSEError(errno.ENOENT)\n\n stamp = int(1438467123.985654 * 1e9)\n entry.st_atime_ns = stamp\n entry.st_ctime_ns = stamp\n entry.st_mtime_ns = stamp\n entry.st_gid = os.getgid()\n entry.st_uid = os.getuid()\n entry.st_ino = inode\n entry.entry_timeout = self.status.entry_timeout\n entry.attr_timeout = self.status.attr_timeout\n\n self.status.getattr_called = True\n return entry\n\n async def forget(self, inode_list):\n for inode, cnt in inode_list:\n if inode == self.hello_inode:\n self.lookup_cnt -= 1\n assert self.lookup_cnt >= 0\n else:\n assert inode == pyfuse3.ROOT_INODE\n\n async def lookup(\n self, parent_inode: InodeT, name: bytes, ctx: RequestContext\n ) -> EntryAttributes:\n if parent_inode != pyfuse3.ROOT_INODE or name != self.hello_name:\n raise pyfuse3.FUSEError(errno.ENOENT)\n self.lookup_cnt += 1\n self.status.lookup_called = True\n return await self.getattr(self.hello_inode, ctx)\n\n async def opendir(self, inode, ctx):\n if inode != pyfuse3.ROOT_INODE:\n raise pyfuse3.FUSEError(errno.ENOENT)\n # For simplicity, we use the inode as file handle\n return FileHandleT(inode)\n\n async def readdir(self, fh: FileHandleT, start_id: int, token: ReaddirToken) -> None:\n assert fh == pyfuse3.ROOT_INODE\n if start_id == 0:\n pyfuse3.readdir_reply(token, self.hello_name, await self.getattr(self.hello_inode), 1)\n return\n\n async def open(self, inode, flags, ctx):\n if inode != self.hello_inode:\n raise pyfuse3.FUSEError(errno.ENOENT)\n if flags & os.O_RDWR or flags & os.O_WRONLY:\n raise pyfuse3.FUSEError(errno.EACCES)\n # For simplicity, we use the inode as file handle\n return FileInfo(fh=FileHandleT(inode))\n\n async def read(self, fh, off, size):\n assert fh == self.hello_inode\n self.status.read_called = True\n return self.hello_data[off : off + size]\n\n async def setxattr(self, inode, name, value, ctx):\n if inode != pyfuse3.ROOT_INODE or name != b'command':\n raise FUSEError(errno.ENOTSUP)\n\n if value == b'forget_entry':\n pyfuse3.invalidate_entry_async(pyfuse3.ROOT_INODE, self.hello_name)\n\n # Make sure that the request is pending before we return\n await trio.sleep(0.1)\n\n elif value == b'forget_inode':\n pyfuse3.invalidate_inode(self.hello_inode)\n\n elif value == b'store':\n pyfuse3.notify_store(self.hello_inode, offset=0, data=self.hello_data)\n\n elif value == b'terminate':\n pyfuse3.terminate()\n\n else:\n raise FUSEError(errno.EINVAL)\n\n\nclass PollTestFs(Fs):\n def __init__(self, cross_process):\n super().__init__(cross_process)\n self.poll_handle: PollHandle | None = None\n self.status.poll_called = False\n self.status.poll_handle_received = False\n self.status.poll_ready = False\n\n async def poll(\n self,\n inode: InodeT,\n fh: FileHandleT,\n poll_handle: PollHandle | None,\n ctx: RequestContext,\n ) -> int:\n assert inode == self.hello_inode\n assert fh == self.hello_inode\n\n self.status.poll_called = True\n\n if poll_handle is not None:\n self.poll_handle = poll_handle\n self.status.poll_handle_received = True\n\n if self.status.poll_ready:\n return select.POLLPRI\n\n return 0\n\n async def setxattr(self, inode, name, value, ctx):\n if value != b\"poll_ready\":\n return await super().setxattr(inode, name, value, ctx)\n\n if inode != self.hello_inode or name != b\"command\":\n raise FUSEError(errno.ENOTSUP)\n\n self.status.poll_ready = True\n\n if self.poll_handle is None:\n raise FUSEError(errno.EINVAL)\n\n self.poll_handle.notify()\n self.poll_handle = None\n\n\ndef run_fs(mountpoint, cross_process, fs_class=Fs):\n # Logging (note that we run in a new process, so we can't\n # rely on direct log capture and instead print to stdout)\n root_logger = logging.getLogger()\n formatter = logging.Formatter(\n '%(asctime)s.%(msecs)03d %(levelname)s %(funcName)s(%(threadName)s): %(message)s',\n datefmt=\"%M:%S\",\n )\n handler = logging.StreamHandler(sys.stdout)\n handler.setLevel(logging.DEBUG)\n handler.setFormatter(formatter)\n root_logger.addHandler(handler)\n root_logger.setLevel(logging.DEBUG)\n\n testfs = fs_class(cross_process)\n fuse_options = set(pyfuse3.default_options)\n fuse_options.add('fsname=pyfuse3_testfs')\n pyfuse3.init(testfs, mountpoint, fuse_options)\n try:\n trio.run(pyfuse3.main)\n finally:\n pyfuse3.close()\n" }, { "path": "test/test_rounding.py", "content": "#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n'''\ntest_rounding.py - Unit tests for pyfuse3.\n\nCopyright © 2020 Philip Warner \n\nThis file is part of pyfuse3. This work may be distributed under\nthe terms of the GNU LGPL.\n'''\n\nif __name__ == '__main__':\n import sys\n\n import pytest\n\n sys.exit(pytest.main([__file__] + sys.argv[1:]))\n\nfrom pyfuse3 import _NANOS_PER_SEC, EntryAttributes\n\n\ndef test_rounding():\n # Incorrect division previously resulted in rounding errors for\n # all dates.\n entry = EntryAttributes()\n\n # Approximately 67 years, ending in 999.\n # Note: 67 years were chosen to avoid y2038 issues (1970 + 67 = 2037).\n # Testing these is **not** in scope of this test.\n secs = 67 * 365 * 24 * 3600 + 999\n nanos = _NANOS_PER_SEC - 1\n\n total = secs * _NANOS_PER_SEC + nanos\n\n entry.st_atime_ns = total\n entry.st_ctime_ns = total\n entry.st_mtime_ns = total\n # Birthtime skipped -- only valid under BSD and OSX\n # entry.st_birthtime_ns = total\n\n assert entry.st_atime_ns == total\n assert entry.st_ctime_ns == total\n assert entry.st_mtime_ns == total\n # Birthtime skipped -- only valid under BSD and OSX\n # assert entry.st_birthtime_ns == total\n" }, { "path": "test/util.py", "content": "#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n'''\nutil.py - Utility functions for pyfuse3 unit tests.\n\nCopyright © 2015 Nikolaus Rath \n\nThis file is part of pyfuse3. This work may be distributed under\nthe terms of the GNU LGPL.\n'''\n\nimport multiprocessing\nimport os\nimport platform\nimport shutil\nimport stat\nimport subprocess\nimport time\nfrom collections.abc import Callable\nfrom multiprocessing.context import ForkProcess\nfrom typing import TypeVar\n\nimport pytest\n\nProcess = subprocess.Popen | multiprocessing.Process | ForkProcess\n\n\ndef fuse_test_marker():\n '''Return a pytest.marker that indicates FUSE availability\n\n If system/user/environment does not support FUSE, return\n a `pytest.mark.skip` object with more details. If FUSE is\n supported, return `pytest.mark.uses_fuse()`.\n '''\n\n if platform.system() == 'Darwin':\n # No working autodetection, just assume it will work.\n return\n skip = lambda x: pytest.mark.skip(reason=x)\n\n fusermount_path = shutil.which('fusermount')\n if fusermount_path is None:\n return skip(\"Can't find fusermount executable\")\n\n if not os.path.exists('/dev/fuse'):\n return skip(\"FUSE kernel module does not seem to be loaded\")\n\n if os.getuid() == 0:\n return pytest.mark.uses_fuse()\n\n mode = os.stat(fusermount_path).st_mode\n if mode & stat.S_ISUID == 0:\n return skip('fusermount executable not setuid, and we are not root.')\n\n try:\n fd = os.open('/dev/fuse', os.O_RDWR)\n except OSError as exc:\n return skip('Unable to open /dev/fuse: %s' % exc.strerror)\n else:\n os.close(fd)\n\n return pytest.mark.uses_fuse()\n\n\ndef exitcode(process: Process) -> int | None:\n if isinstance(process, subprocess.Popen):\n return process.poll()\n else:\n if process.is_alive():\n return None\n else:\n return process.exitcode\n\n\nT = TypeVar('T')\n\n\ndef wait_for(callable: Callable[[], T], timeout: float = 10, interval: float = 0.1) -> T | None:\n '''Wait until *callable* returns something True and return it\n\n If *timeout* expires, return None\n '''\n\n waited = 0.0\n while True:\n ret = callable()\n if ret:\n return ret\n if waited > timeout:\n return None\n waited += interval\n time.sleep(interval)\n\n\ndef wait_for_mount(mount_process: Process, mnt_dir: str) -> bool:\n elapsed = 0.0\n while elapsed < 30:\n if os.path.ismount(mnt_dir):\n return True\n if exitcode(mount_process) is not None:\n pytest.fail('file system process terminated prematurely')\n time.sleep(0.1)\n elapsed += 0.1\n pytest.fail(\"mountpoint failed to come up\")\n\n\ndef cleanup(mount_process: Process, mnt_dir: str) -> None:\n if platform.system() == 'Darwin':\n subprocess.call(\n ['umount', '-l', mnt_dir], stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT\n )\n else:\n subprocess.call(\n ['fusermount', '-z', '-u', mnt_dir], stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT\n )\n\n mount_process.terminate()\n if isinstance(mount_process, subprocess.Popen):\n try:\n mount_process.wait(1)\n except subprocess.TimeoutExpired:\n mount_process.kill()\n else:\n mount_process.join(5)\n if mount_process.exitcode is None:\n mount_process.kill()\n\n\ndef umount(mount_process: Process, mnt_dir: str) -> None:\n if platform.system() == 'Darwin':\n subprocess.check_call(['umount', '-l', mnt_dir])\n else:\n subprocess.check_call(['fusermount', '-z', '-u', mnt_dir])\n assert not os.path.ismount(mnt_dir)\n\n if isinstance(mount_process, subprocess.Popen):\n try:\n code = mount_process.wait(5)\n if code == 0:\n return\n pytest.fail('file system process terminated with code %s' % (code,))\n except subprocess.TimeoutExpired:\n mount_process.terminate()\n try:\n mount_process.wait(1)\n except subprocess.TimeoutExpired:\n mount_process.kill()\n else:\n mount_process.join(5)\n if mount_process.exitcode == 0:\n return\n elif mount_process.exitcode is None:\n mount_process.terminate()\n mount_process.join(1)\n else:\n pytest.fail('file system process terminated with code %s' % (mount_process.exitcode,))\n\n pytest.fail('mount process did not terminate')\n" }, { "path": "util/build_backend.py", "content": "\"\"\"\nCustom build backend for pyfuse3.\n\nThis wraps setuptools.build_meta and dynamically configures the Cython\nextension based on pkg-config output and platform detection.\n\"\"\"\n\nimport os\nimport subprocess\n\nfrom setuptools import Extension\nfrom setuptools.build_meta import * # noqa: F403\n\n\ndef pkg_config(pkg, cflags=True, ldflags=False, min_ver=None):\n \"\"\"Frontend to pkg-config\"\"\"\n\n if min_ver:\n cmd = ['pkg-config', pkg, '--atleast-version', min_ver]\n\n if subprocess.call(cmd) != 0:\n cmd = ['pkg-config', '--modversion', pkg]\n proc = subprocess.Popen(cmd, stdout=subprocess.PIPE)\n version = proc.communicate()[0].strip()\n if not version:\n raise SystemExit(2) # pkg-config generates error message already\n else:\n raise SystemExit(\n '%s version too old (found: %s, required: %s)' % (pkg, version, min_ver)\n )\n\n cmd = ['pkg-config', pkg]\n if cflags:\n cmd.append('--cflags')\n if ldflags:\n cmd.append('--libs')\n\n proc = subprocess.Popen(cmd, stdout=subprocess.PIPE)\n cflags = proc.stdout.readline().rstrip()\n proc.stdout.close()\n if proc.wait() != 0:\n raise SystemExit(2) # pkg-config generates error message already\n\n return cflags.decode('us-ascii').split()\n\n\ndef get_extension_modules():\n \"\"\"Build the Cython extension with platform-specific configuration.\"\"\"\n\n # Get fuse3 flags from pkg-config\n compile_args = pkg_config('fuse3', cflags=True, ldflags=False, min_ver='3.2.0')\n compile_args += [\n '-DFUSE_USE_VERSION=32',\n '-Wall',\n '-Wextra',\n '-Wconversion',\n '-Wsign-compare',\n '-Wno-unused-function',\n '-Wno-implicit-fallthrough',\n '-Wno-unused-parameter',\n ]\n\n link_args = pkg_config('fuse3', cflags=False, ldflags=True, min_ver='3.2.0')\n link_args.append('-lpthread')\n\n # Determine source files based on platform\n c_sources = ['src/pyfuse3/__init__.pyx']\n\n if os.uname()[0] in ('Linux', 'GNU/kFreeBSD'):\n link_args.append('-lrt')\n elif os.uname()[0] == 'Darwin':\n c_sources.append('src/pyfuse3/darwin_compat.c')\n\n return [\n Extension(\n 'pyfuse3.__init__',\n c_sources,\n extra_compile_args=compile_args,\n extra_link_args=link_args,\n include_dirs=['Include'],\n )\n ]\n\n\n# Override get_requires_for_build_wheel to ensure we have pkg-config available\ndef get_requires_for_build_wheel(config_settings=None):\n \"\"\"Return build requirements.\"\"\"\n from setuptools.build_meta import get_requires_for_build_wheel as orig\n\n return orig(config_settings)\n\n\n# Hook into the build process\n_orig_build_wheel = build_wheel # noqa: F405\n_orig_build_editable = build_editable if 'build_editable' in dir() else None # noqa: F405\n_orig_build_sdist = build_sdist # noqa: F405\n\n\ndef build_wheel(wheel_directory, config_settings=None, metadata_directory=None):\n \"\"\"Build wheel with dynamic extension configuration.\"\"\"\n # Inject our extension modules into the distribution\n from setuptools import Distribution\n\n # Monkey-patch Distribution to include our extensions\n orig_init = Distribution.__init__\n\n def patched_init(self, attrs=None):\n if attrs is None:\n attrs = {}\n # Add our dynamically configured extension modules\n if 'ext_modules' not in attrs:\n attrs['ext_modules'] = get_extension_modules()\n orig_init(self, attrs)\n\n Distribution.__init__ = patched_init\n\n try:\n return _orig_build_wheel(wheel_directory, config_settings, metadata_directory)\n finally:\n Distribution.__init__ = orig_init\n\n\ndef build_editable(wheel_directory, config_settings=None, metadata_directory=None):\n \"\"\"Build editable wheel with dynamic extension configuration.\"\"\"\n if _orig_build_editable is None:\n raise NotImplementedError(\"build_editable not available\")\n\n from setuptools import Distribution\n\n # Monkey-patch Distribution to include our extensions\n orig_init = Distribution.__init__\n\n def patched_init(self, attrs=None):\n if attrs is None:\n attrs = {}\n # Add our dynamically configured extension modules\n if 'ext_modules' not in attrs:\n attrs['ext_modules'] = get_extension_modules()\n orig_init(self, attrs)\n\n Distribution.__init__ = patched_init\n\n try:\n return _orig_build_editable(wheel_directory, config_settings, metadata_directory)\n finally:\n Distribution.__init__ = orig_init\n\n\ndef build_sdist(sdist_directory, config_settings=None):\n \"\"\"Build source distribution.\"\"\"\n # For sdist, we don't need to configure extensions\n return _orig_build_sdist(sdist_directory, config_settings)\n" }, { "path": "util/sdist-sign", "content": "#!/bin/bash\n\nR=$1\n\nif [ \"$R\" = \"\" ]; then\n echo \"Usage: sdist-sign 1.2.3\"\n exit\nfi\n\nif [ \"$QUBES_GPG_DOMAIN\" = \"\" ]; then\n GPG=gpg\nelse\n GPG=qubes-gpg-client-wrapper\nfi\n\npython setup.py sdist\n\nD=dist/pyfuse3-$R.tar.gz\n\n$GPG --detach-sign --local-user \"Thomas Waldmann\" --armor --output $D.asc $D\n" }, { "path": "util/upload-pypi", "content": "#!/bin/bash\n\nR=$1\n\nif [ \"$R\" = \"\" ]; then\n echo \"Usage: upload-pypi 1.2.3 [test]\"\n exit\nfi\n\nif [ \"$2\" = \"test\" ]; then\n export TWINE_REPOSITORY=testpyfuse3\nelse\n export TWINE_REPOSITORY=pyfuse3\nfi\n\nD=dist/pyfuse3-$R.tar.gz\n\ntwine upload $D\n" } ]