shareddata 6.83.8__tar.gz → 6.83.16__tar.gz

{shareddata-6.83.8/src/shareddata.egg-info → shareddata-6.83.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shareddata
-Version: 6.83.8
+Version: 6.83.16
 Summary: Memory Mapped / Shared Memory Database with S3 repository
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License

{shareddata-6.83.8 → shareddata-6.83.16}/setup.py

@@ -34,7 +34,7 @@ install_requires = [
 
 setup(
     name='shareddata',
-    version='6.83.8',
+    version='6.83.16',
     description='Memory Mapped / Shared Memory Database with S3 repository',
     long_description=open('README.md').read(),
     long_description_content_type='text/markdown',

shareddata-6.83.16/src/SharedData/API/listcache.py

@@ -0,0 +1,91 @@
+"""
+TTL + single-flight cache for the expensive listing endpoints.
+
+``/api/tables``, ``/api/timeseries`` and ``/api/collections`` enumerate every
+partition on S3 (``list_remote``) and on local disk (``list_local``). With an
+empty ``keyword`` this scans the entire data lake and can take well over a
+minute. When several callers (the Dashboard polling + workers) hit the route at
+once, each one launches an independent full scan, the responses materialize in
+memory simultaneously, and the box sawtooths into swap while every request
+exceeds the upstream gateway timeout and returns 502/504.
+
+This cache fixes the dominant failure mode: it memoizes each listing for a short
+TTL and, crucially, runs the producer under a per-key lock (single-flight) so at
+most one scan executes per key at a time. Concurrent callers block on the lock
+and then receive the freshly cached result instead of each starting their own
+scan. Steady-state polling becomes instant; the storm of overlapping full scans
+disappears.
+
+Note: the very first (cold) call for a key still pays the full scan cost. That
+is inherent to a no-keyword full enumeration; pair this with a higher gateway
+read-timeout on the listing routes if cold calls must also stay under the proxy
+limit.
+"""
+
+import threading
+import time
+
+
+class _Entry:
+    __slots__ = ("value", "ts", "lock")
+
+    def __init__(self):
+        self.value = None
+        self.ts = 0.0
+        self.lock = threading.Lock()
+
+
+class TTLSingleFlightCache:
+    """Thread-safe TTL cache that collapses concurrent misses into one producer call."""
+
+    def __init__(self, ttl=60.0):
+        self.ttl = float(ttl)
+        self._entries = {}
+        self._guard = threading.Lock()
+
+    def _entry(self, key):
+        # Fast path under a short global lock just to fetch/create the per-key entry.
+        with self._guard:
+            entry = self._entries.get(key)
+            if entry is None:
+                entry = _Entry()
+                self._entries[key] = entry
+            return entry
+
+    def get(self, key, producer, ttl=None):
+        """
+        Return the cached value for ``key`` if fresh, otherwise call ``producer()``.
+
+        Only one thread runs ``producer`` per key at a time; others wait on the
+        per-key lock and then receive the value the winner just stored.
+        """
+        ttl = self.ttl if ttl is None else float(ttl)
+        entry = self._entry(key)
+
+        # Fresh hit, no locking needed.
+        if entry.value is not None and (time.time() - entry.ts) < ttl:
+            return entry.value
+
+        # Stale or empty -> single-flight refresh.
+        with entry.lock:
+            # Another thread may have refreshed while we waited on the lock.
+            if entry.value is not None and (time.time() - entry.ts) < ttl:
+                return entry.value
+            value = producer()
+            entry.value = value
+            entry.ts = time.time()
+            return value
+
+    def invalidate(self, key=None):
+        """Drop one key (or the whole cache when ``key`` is None)."""
+        with self._guard:
+            if key is None:
+                self._entries.clear()
+            else:
+                self._entries.pop(key, None)
+
+
+# Module-level singleton shared by the listing routes.
+# 60s TTL: listing metadata changes slowly, and a minute of staleness is
+# acceptable for a directory view while it eliminates the scan pile-up.
+LIST_CACHE = TTLSingleFlightCache(ttl=60.0)

{shareddata-6.83.8 → shareddata-6.83.16}/src/SharedData/API/routes/collections.py

@@ -23,6 +23,7 @@ from SharedData.API.constants import (
     DEFAULT_PAGE_SIZE,
     ERROR_SLEEP_SECONDS,
 )
+from SharedData.API.listcache import LIST_CACHE
 from SharedData.API.utils import (
     apply_subfolder,
     make_empty_response,
@@ -99,13 +100,20 @@ def init_collections_routes(shdata, authenticate_fn):
                 return jsonify({'error': 'unauthorized'}), 401
             keyword = request.args.get('keyword', '')
             user = request.args.get('user', DEFAULT_USER)
-            collections = shdata.list_collections(keyword=keyword, user=user)
-            if collections.empty:
+
+            def _produce():
+                collections = shdata.list_collections(keyword=keyword, user=user)
+                if collections.empty:
+                    return b''  # sentinel -> 204
+                collections_recs = collections.reset_index().to_dict('records')
+                collections_recs = CollectionMongoDB.serialize(collections_recs, iso_dates=True)
+                return json.dumps(collections_recs).encode('utf-8')
+
+            # Single-flight + TTL cache: see listcache.py.
+            response_data = LIST_CACHE.get(('collections', user, keyword), _produce)
+            if not response_data:
                 return Response(status=204)
-            collections = collections.reset_index().to_dict('records')
-            collections = CollectionMongoDB.serialize(collections, iso_dates=True)
-            response_data = json.dumps(collections).encode('utf-8')
-            response = Response(response_data, mimetype='application/json')        
+            response = Response(response_data, mimetype='application/json')
             return response
         except Exception as e:        
             response = Response(status=500)

{shareddata-6.83.8 → shareddata-6.83.16}/src/SharedData/API/routes/tables.py

@@ -21,6 +21,7 @@ from SharedData.API.constants import (
     ERROR_SLEEP_SECONDS,
     MAX_RESPONSE_SIZE_BYTES,
 )
+from SharedData.API.listcache import LIST_CACHE
 from SharedData.API.utils import (
     apply_subfolder,
     make_empty_response,
@@ -56,12 +57,19 @@ def init_tables_routes(shdata, authenticate_fn):
             keyword = request.args.get('keyword', '')
             user = request.args.get('user', DEFAULT_USER)
 
-            tables = shdata.list_tables(keyword=keyword, user=user)
-            if tables.empty:
+            def _produce():
+                tables = shdata.list_tables(keyword=keyword, user=user)
+                if tables.empty:
+                    return b''  # sentinel -> 204
+                tables_recs = tables.reset_index().to_dict('records')
+                tables_recs = CollectionMongoDB.serialize(tables_recs, iso_dates=True)
+                return json.dumps(tables_recs).encode('utf-8')
+
+            # Single-flight + TTL cache: collapses concurrent/repeat full scans so
+            # they no longer pile up past the gateway timeout (see listcache.py).
+            response_data = LIST_CACHE.get(('tables', user, keyword), _produce)
+            if not response_data:
                 return Response(status=204)
-            tables = tables.reset_index().to_dict('records')        
-            tables = CollectionMongoDB.serialize(tables, iso_dates=True)
-            response_data = json.dumps(tables).encode('utf-8')
             response = Response(response_data, mimetype='application/json')
             response.headers['Content-Length'] = len(response_data)
             return response
@@ -190,14 +198,36 @@ def init_tables_routes(shdata, authenticate_fn):
             loc = np.array(loc)
         
         # cycle query keys
-        if query.keys() is not None:        
-            for key in query.keys():            
-                if pd.api.types.is_string_dtype(tbl[key]):
-                    idx = tbl[loc][key] == query[key].encode()
-                elif pd.api.types.is_datetime64_any_dtype(tbl[key]):
-                    idx = tbl[loc][key] == pd.Timestamp(query[key])
-                else:                    
-                    idx = tbl[loc][key] == query[key]
+        if query.keys() is not None:
+            for key in query.keys():
+                # Take the column view FIRST, then index it.
+                #
+                # `tbl[key]` is zero-copy (SharedNumpy.__getitem__ slices to
+                # count, and a field name on an ndarray is a view), whereas
+                # `tbl[loc]` is fancy indexing -- a copy of every selected row
+                # at the FULL record width, done once per query key and applied
+                # BEFORE the 20 MiB response cap, so it was unbounded.
+                #
+                # Measured on a 208-byte record: old peak was exactly
+                # 217.0 B/row at 100k/200k/400k/800k rows and FLAT across a
+                # 2000x selectivity sweep (it copies the whole table either
+                # way); new peak is ~1 B/row.
+                #
+                # `tbl[:]` (not `tbl[key]`) is deliberate: SharedNumpy.__getitem__
+                # re-reads tbl.count on every access, so slicing the whole table
+                # here observes the count at COMPARISON time, exactly as the old
+                # `tbl[loc]` did. Caching a column view from an earlier count
+                # would diverge if a concurrent writer shrank the table -- e.g.
+                # TableIndex.create_index() lowers hdr['count'] when it drops
+                # invalid/duplicate rows -- letting this succeed where the old
+                # code raised IndexError (and vice versa on growth).
+                col = tbl[:][key]
+                if pd.api.types.is_string_dtype(col):
+                    idx = col[loc] == query[key].encode()
+                elif pd.api.types.is_datetime64_any_dtype(col):
+                    idx = col[loc] == pd.Timestamp(query[key])
+                else:
+                    idx = col[loc] == query[key]
                 loc = loc[idx]
         
         if len(loc) == 0:
@@ -206,28 +236,31 @@ def init_tables_routes(shdata, authenticate_fn):
         # filter columns
         pkey = DATABASE_PKEYS[database]
         columns = request.args.get('columns')
-        if columns:
-            if not tbl.is_schemaless:
-                columns = columns.split(',')
-                columns = np.array([c for c in columns if c not in pkey])
-                columns = pkey + list(np.unique(columns))
-                names = columns
-                formats = [tbl.dtype.fields[name][0].str for name in names]
-                dtype = np.dtype(list(zip(names, formats)))
-                # Apply pagination    
-                maxrows = int(np.floor(MAX_RESPONSE_SIZE_BYTES / dtype.itemsize))
-                maxrows = min(maxrows, len(loc))
-                if (per_page > maxrows) | (per_page == 0):
-                    per_page = maxrows        
-                startpage = (page - 1) * per_page
-                endpage = startpage + per_page        
-                content_pages = int(np.ceil(len(loc) / per_page))
-                recs2send = tbl[loc[startpage:endpage]]
-                # Create new array
-                arrays = [recs2send[field] for field in columns]
-                recs2send = np.rec.fromarrays(arrays, dtype=dtype)
-            else:
-                pass
+        # NOTE: `columns` on a SCHEMALESS table falls through to the plain
+        # pagination branch below. It used to hit `else: pass`, which left
+        # startpage/endpage/content_pages/recs2send unbound -> UnboundLocalError
+        # -> 500 -> 1s in-handler sleep -> 3 immediate client retries. The
+        # projection for schemaless tables is applied to the decoded dict_list
+        # further down instead.
+        if columns and not tbl.is_schemaless:
+            columns = columns.split(',')
+            columns = np.array([c for c in columns if c not in pkey])
+            columns = pkey + list(np.unique(columns))
+            names = columns
+            formats = [tbl.dtype.fields[name][0].str for name in names]
+            dtype = np.dtype(list(zip(names, formats)))
+            # Apply pagination
+            maxrows = int(np.floor(MAX_RESPONSE_SIZE_BYTES / dtype.itemsize))
+            maxrows = min(maxrows, len(loc))
+            if (per_page > maxrows) | (per_page == 0):
+                per_page = maxrows
+            startpage = (page - 1) * per_page
+            endpage = startpage + per_page
+            content_pages = int(np.ceil(len(loc) / per_page))
+            recs2send = tbl[loc[startpage:endpage]]
+            # Create new array
+            arrays = [recs2send[field] for field in columns]
+            recs2send = np.rec.fromarrays(arrays, dtype=dtype)
         else:
             # Apply pagination    
             maxrows = int(np.floor(MAX_RESPONSE_SIZE_BYTES / tbl.itemsize))
@@ -293,11 +326,13 @@ def init_tables_routes(shdata, authenticate_fn):
             if tbl.is_schemaless:
                 dict_list = tbl.get_dict_list(loc[startpage:endpage])
                 if columns:
+                    # was built into `filtered_dict_list` and then dropped on
+                    # the floor -- the UNfiltered list was sent to the client
                     columns = columns.split(',')
-                    filtered_dict_list = []
-                    for record in dict_list:
-                        filtered_record = {col: record[col] for col in columns if col in record}
-                        filtered_dict_list.append(filtered_record)
+                    dict_list = [
+                        {col: record[col] for col in columns if col in record}
+                        for record in dict_list
+                    ]
 
             json_payload = {
                 'names': names,

{shareddata-6.83.8 → shareddata-6.83.16}/src/SharedData/API/routes/timeseries.py

@@ -16,6 +16,7 @@ from SharedData.API.constants import (
     DEFAULT_USER,
     ERROR_SLEEP_SECONDS,
 )
+from SharedData.API.listcache import LIST_CACHE
 from SharedData.API.utils import (
     apply_subfolder,
     make_empty_response,
@@ -45,22 +46,24 @@ def init_timeseries_routes(shdata, authenticate_fn):
                 return jsonify({'error': 'unauthorized'}), 401
             keyword = request.args.get('keyword', '')
             user = request.args.get('user', DEFAULT_USER)
-            
-            timeseries_df = shdata.list_timeseries(keyword=keyword, user=user)
-            
-            if len(timeseries_df) == 0:
+
+            def _produce():
+                timeseries_df = shdata.list_timeseries(keyword=keyword, user=user)
+                if len(timeseries_df) == 0:
+                    return b''  # sentinel -> 204
+                timeseries_list = timeseries_df.reset_index().to_dict('records')
+                for ts in timeseries_list:
+                    for key, value in ts.items():
+                        if pd.isna(value):
+                            ts[key] = None
+                        elif isinstance(value, pd.Timestamp):
+                            ts[key] = value.isoformat()
+                return json.dumps(timeseries_list).encode('utf-8')
+
+            # Single-flight + TTL cache: see listcache.py.
+            response_data = LIST_CACHE.get(('timeseries', user, keyword), _produce)
+            if not response_data:
                 return Response(status=204)
-            
-            timeseries_list = timeseries_df.reset_index().to_dict('records')
-            
-            for ts in timeseries_list:
-                for key, value in ts.items():
-                    if pd.isna(value):
-                        ts[key] = None
-                    elif isinstance(value, pd.Timestamp):
-                        ts[key] = value.isoformat()
-            
-            response_data = json.dumps(timeseries_list).encode('utf-8')
             response = Response(response_data, mimetype='application/json')
             response.headers['Content-Length'] = len(response_data)
             return response

{shareddata-6.83.8 → shareddata-6.83.16}/src/SharedData/CollectionMongoDB.py

@@ -112,7 +112,7 @@ class CollectionMongoDB:
             # Check for indexes other than the default _id index
             self.hasindex = any(index_name == pkey_name for index_name in index_info)
             # If index was requested but the collection was previously created without one, create it now
-            if hasindex and not self.hasindex:
+            if hasindex and not self.hasindex and self.period in ['D1', 'M15', 'M1']:
                 self.mongodb.client[self.user][self.relpath].create_index(pkey_fields, unique=True, name=pkey_name)
                 self.mongodb.client[self.user][self.relpath].create_index([("mtime", DESCENDING)])
                 self.hasindex = True

shareddata-6.83.16/src/SharedData/Defaults.py

@@ -0,0 +1,313 @@
+import os
+from dotenv import load_dotenv
+import socket
+from pathlib import Path
+
+# Load persisted SharedData environment variables from user home directory
+# These are set remotely via the 'setenv' WorkerPool API command
+shareddata_env_file = Path.home() / '.shareddata.env'
+if shareddata_env_file.is_file():
+    load_dotenv(shareddata_env_file, override=False)
+
+try:
+    load_dotenv()  # take environment variables from .env in CWD
+except Exception:
+    # Continue gracefully if .env file is not found or cannot be loaded
+    pass
+
+if not 'AWS_PROFILE' in os.environ:    
+    if (not 'AWS_ACCESS_KEY_ID' in os.environ)\
+        or (not 'AWS_SECRET_ACCESS_KEY' in os.environ):
+        
+        if not 'AWS_ACCESS_KEY_ID' in os.environ:
+            os.environ['AWS_ACCESS_KEY_ID'] = ''
+        if not 'AWS_SECRET_ACCESS_KEY' in os.environ:
+            os.environ['AWS_SECRET_ACCESS_KEY'] = ''
+else:
+    
+    if not 'S3_AWS_PROFILE' in os.environ:
+        os.environ['S3_AWS_PROFILE'] = os.environ['AWS_PROFILE']    
+
+if not 'DATABASE_FOLDER' in os.environ:
+    try:
+        os.environ['DATABASE_FOLDER'] = os.path.expanduser("~")+'/db'
+    except Exception:
+        # Fallback for Docker containers where home directory might not be accessible
+        os.environ['DATABASE_FOLDER'] = '/tmp/db'
+Path(os.environ['DATABASE_FOLDER']).mkdir(parents=True, exist_ok=True)
+
+if not 'SHAREDDATA_TOKEN' in os.environ:
+    os.environ['SHAREDDATA_TOKEN'] = 'shareddata-token'
+
+if not 'SHAREDDATA_SECRET_KEY' in os.environ:
+    os.environ['SHAREDDATA_SECRET_KEY'] = 'shareddata-secret-key'
+
+if not 'S3_BUCKET' in os.environ:
+    os.environ['S3_BUCKET'] = 's3://shareddata'
+
+if not 'LOG_API' in os.environ:
+    os.environ['LOG_API'] = 'True'
+
+if not 'LOG_FILE' in os.environ:
+    os.environ['LOG_FILE'] = 'False'
+
+if not 'USERNAME' in os.environ:
+    if 'USER' in os.environ:
+        os.environ['USERNAME'] = os.environ['USER']
+    else:
+        os.environ['USERNAME'] = 'shareddata-user'
+                    
+if not 'COMPUTERNAME' in os.environ:
+    os.environ['COMPUTERNAME'] = socket.gethostname().upper()
+
+if not 'USER_COMPUTER' in os.environ:    
+    os.environ['USER_COMPUTER'] = os.environ['USERNAME'] + \
+        '@'+os.environ['COMPUTERNAME']
+
+if not 'LOG_LEVEL' in os.environ:
+    os.environ['LOG_LEVEL'] = 'INFO'
+
+if not 'GIT_PROTOCOL' in os.environ:
+    os.environ['GIT_PROTOCOL'] = 'https'
+
+if not 'GIT_SERVER' in os.environ:
+    os.environ['GIT_SERVER'] = 'github.com'
+
+if not 'SOURCE_FOLDER' in os.environ:
+    if 'USERPROFILE' in os.environ:
+        os.environ['SOURCE_FOLDER'] = os.environ['USERPROFILE']+'/src/'
+    elif 'HOME' in os.environ:
+        os.environ['SOURCE_FOLDER'] = os.environ['HOME']+'/src/'
+    else:
+        # Fallback for Docker containers without HOME set
+        os.environ['SOURCE_FOLDER'] = '/tmp/src/'
+Path(os.environ['SOURCE_FOLDER']).mkdir(parents=True, exist_ok=True)
+
+
+if not 'SLEEP_TIME' in os.environ:
+    os.environ['SLEEP_TIME'] = '2'
+
+if not 'KAFKA_RETENTION' in os.environ:
+    os.environ['KAFKA_RETENTION'] = '84600000'  # 1 days
+
+if not 'KAFKA_PARTITIONS' in os.environ:
+    os.environ['KAFKA_PARTITIONS'] = '1'
+
+if not 'KAFKA_REPLICATION' in os.environ:
+    os.environ['KAFKA_REPLICATION'] = '1'
+
+if not 'PYTHONUNBUFFERED' in os.environ:
+    os.environ['PYTHONUNBUFFERED'] = '1'
+
+loaded = True
+
+
+def folder_accessible(folder: str) -> bool:
+    """
+    Check whether a folder is actually usable for I/O.
+
+    ``Path.is_dir()`` returns ``True`` for unmounted mountpoints (the
+    mountpoint directory still exists on the root fs) — which would
+    silently route writes to the wrong disk.  This function detects
+    unmounts by checking for a provisioning marker file
+    (``.shareddata_mounted``) that SharedData creates in each dbfolder
+    during ``__init__``.  When a disk is unmounted, the marker
+    (which lives on the disk) disappears while the empty mountpoint
+    directory remains on the root fs — so the absence of the marker
+    reliably signals an unmount.
+
+    Returns ``True`` only if the folder exists, is a directory, carries
+    the provisioning marker, and allows creating a temporary file
+    (which is immediately cleaned up).
+    """
+    try:
+        if not folder:
+            return False
+        import uuid
+        p = Path(folder)
+        if not p.is_dir():
+            return False
+        # Marker file — created at provisioning time (SharedData.__init__).
+        # Absence means the disk is unmounted (marker lives on the disk,
+        # not the root fs) or the folder was never provisioned.
+        if not (p / '.shareddata_mounted').exists():
+            return False
+        # Writability probe with unique sentinel to avoid races.
+        sentinel = p / f'.shareddata_access_check.{os.getpid()}.{uuid.uuid4().hex}'
+        with open(sentinel, 'wb') as f:
+            f.write(b'')
+        sentinel.unlink(missing_ok=True)
+        return True
+    except (OSError, TypeError):
+        return False
+
+
+def _current_mount_points():
+    """Set of currently-mounted mount points from ``/proc/self/mountinfo``.
+
+    Returns ``None`` when the file is unavailable (e.g. non-Linux) so callers
+    can fall back to the legacy ``os.path.ismount()`` heuristic.
+    """
+    try:
+        mounts = set()
+        with open('/proc/self/mountinfo', 'r') as f:
+            for line in f:
+                fields = line.split(' ')
+                # mountinfo field 5 (index 4) is the mount point.
+                if len(fields) >= 5:
+                    mounts.add(_unescape_mountinfo(fields[4]))
+        return mounts or None
+    except (OSError, ValueError):
+        return None
+
+
+def _unescape_mountinfo(s: str) -> str:
+    # mountinfo octal-escapes space/tab/newline/backslash in path fields.
+    return (s.replace('\\040', ' ').replace('\\011', '\t')
+             .replace('\\012', '\n').replace('\\134', '\\'))
+
+
+def _parse_fstab_targets(lines):
+    """Pure parser: set of absolute mount targets from fstab *lines*.
+
+    fstab octal-escapes whitespace in the target field exactly like
+    mountinfo, so decode it the same way — otherwise a declared target like
+    ``/mnt/db\\040disk`` would never match the unescaped path from
+    ``Path.resolve()`` / mountinfo and the unmounted-stub check would miss it.
+    """
+    targets = set()
+    for line in lines:
+        line = line.strip()
+        if not line or line.startswith('#'):
+            continue
+        cols = line.split()
+        if len(cols) >= 2 and cols[1].startswith('/'):
+            targets.add(_unescape_mountinfo(cols[1]))
+    return targets
+
+
+def _declared_mount_points():
+    """Set of declared mount targets from ``/etc/fstab`` (absolute paths only).
+
+    fstab lists mount points that *should* carry a device even when the device
+    is currently unmounted — exactly what distinguishes an unmounted stub from
+    a genuine root-fs folder.
+    """
+    try:
+        with open('/etc/fstab', 'r') as f:
+            return _parse_fstab_targets(f)
+    except OSError:
+        return set()
+
+
+def _classify_on_mounted_device(resolved_path, current_mounts, declared_mounts):
+    """Pure decision (no I/O): is *resolved_path* backed by a live device?
+
+    Walks the path's ancestors from itself up to ``/``:
+    - an ancestor that is a DECLARED mount target but is NOT currently mounted
+      is an unmounted stub — the path lives on the root fs only by accident —
+      so return ``False``;
+    - the first ancestor that IS a current mount point (``/`` always is) means
+      the path is backed by a live filesystem — return ``True``.
+    """
+    from pathlib import PurePosixPath
+    p = PurePosixPath(resolved_path)
+    ancestors = [str(p)] + [str(a) for a in p.parents]
+    for a in ancestors:
+        if a in declared_mounts and a not in current_mounts:
+            return False
+        if a in current_mounts:
+            return True
+    return True
+
+
+def _is_on_mounted_device_legacy(folder: str) -> bool:
+    """Original ``os.path.ismount()`` st_dev heuristic — fallback for platforms
+    without ``/proc/self/mountinfo``.  Cannot detect an unmounted mountpoint
+    stub (``ismount()`` returns False for it); the mountinfo path is preferred
+    on Linux."""
+    try:
+        p = Path(folder).resolve()
+        current = p
+        while True:
+            if os.path.ismount(current):
+                try:
+                    dev = current.stat().st_dev
+                    parent_dev = current.parent.stat().st_dev
+                    if dev != parent_dev:
+                        return True  # device is mounted
+                    else:
+                        # Mountpoint stub — device not mounted.
+                        # But if this is /, it's the root fs (always live).
+                        if current == Path('/'):
+                            return True
+                        return False
+                except OSError:
+                    return False
+            if current == current.parent:
+                # Reached / without finding a mountpoint — root fs.
+                return True
+            current = current.parent
+    except (OSError, TypeError):
+        return False
+
+
+def _is_on_mounted_device(folder: str) -> bool:
+    """
+    Return ``True`` if *folder* is on a currently-live device.
+
+    Combines ``/proc/self/mountinfo`` (currently-mounted points) with
+    ``/etc/fstab`` (declared mount targets) so an *unmounted* mountpoint stub
+    is correctly rejected.  ``os.path.ismount()`` returns False for such a
+    stub, so the previous st_dev walk fell through to ``/`` and wrongly
+    reported it live — letting ``ensure_folder_provisioned()`` drop the
+    ``.shareddata_mounted`` marker on the root fs and defeating unmount
+    detection (writes silently landing on ``/`` instead of the intended disk).
+
+    Falls back to the legacy ``os.path.ismount()`` heuristic when mountinfo is
+    unavailable (non-Linux).
+    """
+    try:
+        if not folder:
+            return False
+        resolved = str(Path(folder).resolve())
+        current = _current_mount_points()
+        if current is None:
+            return _is_on_mounted_device_legacy(folder)
+        declared = _declared_mount_points()
+        return _classify_on_mounted_device(resolved, current, declared)
+    except (OSError, TypeError):
+        return False
+
+def ensure_folder_provisioned(folder: str) -> bool:
+    """
+    Create the provisioning marker in *folder* so that future calls to
+    ``folder_accessible()`` can distinguish a mounted disk from an
+    unmounted mountpoint directory.
+
+    Refuses to create the marker if the folder is on an unmounted
+    mountpoint (``_is_on_mounted_device`` returns ``False``) — this
+    prevents provisioning over a bare mountpoint directory on the
+    root filesystem, which would defeat the unmount detection.
+
+    Called from ``SharedData.__init__`` after ``os.makedirs`` for each
+    dbfolder.  Returns ``True`` on success, ``False`` if the folder
+    cannot be written to or is on an unmounted device.
+    """
+    try:
+        if not folder:
+            return False
+        p = Path(folder)
+        if not p.is_dir():
+            return False
+        # Refuse to provision over an unmounted mountpoint — the marker
+        # would end up on root fs and defeat folder_accessible().
+        if not _is_on_mounted_device(folder):
+            return False
+        marker = p / '.shareddata_mounted'
+        if not marker.exists():
+            marker.touch()
+        return True
+    except (OSError, TypeError):
+        return False
+