add observing user directories

Author: thebino

core/addon.py

@@ -233,6 +233,22 @@ async def async_setup_addon(
 
         return True
 
+    async def read(self, key):
+        """read key/value pair from addon."""
+        try:
+            component = importlib.import_module(f"core.addons.{self.domain}")
+        except ImportError as err:
+            _LOGGER.error(f"Unable to import addon '{self.domain}': {err}")
+            return False
+        except Exception:  # pylint: disable=broad-except
+            _LOGGER.exception(f"Setup failed for {self.domain}: unknown error")
+            return False
+
+        if hasattr(component, "read"):
+            await component.read(self.core, key)
+        else:
+            _LOGGER.error(f"Unable to read key from addon '{self.domain}'")
+
     async def async_process_images_in_addons(self, images) -> bool:
         """Trigger image addons with images to process."""
         if self.type == AddonType.IMAGE:

core/addons/api/__init__.py

@@ -195,10 +195,12 @@ async def get(
         # -d  remove exif data
 
         result = Session.query(Photo).filter(Photo.uuid == entity_id).first()
-
-        file = os.path.join(result.directory, result.filename)
-        if os.path.exists(os.path.join(file)):
-            return web.FileResponse(path=file, status=200)
+        if result:
+            file = os.path.join(result.directory, result.filename)
+            if os.path.exists(os.path.join(file)):
+                return web.FileResponse(path=file, status=200)
+            else:
+                raise web.HTTPNotFound()
         else:
             raise web.HTTPNotFound()
 

core/authentication/auth_database.py

@@ -3,7 +3,10 @@
 import string
 import uuid
 from datetime import datetime, timedelta
-from typing import Optional, Tuple
+from typing import TYPE_CHECKING, Optional, Tuple
+
+if TYPE_CHECKING:
+    from core.core import ApplicationCore
 
 import jwt
 from passlib.hash import sha256_crypt
@@ -21,7 +24,7 @@
 
 
 class AuthDatabase:
-    def __init__(self, data_dir: str):
+    def __init__(self, core: "ApplicationCore", data_dir: str):
         Base.metadata.create_all(engine)
 
         users = Session.query(User).all()
@@ -47,6 +50,8 @@ def __init__(self, data_dir: str):
             Session.add(user)
             Session.commit()
 
+            core.storage.create_user_home(user.id)
+
     async def check_credentials(self, email: str, password: str) -> bool:
         """Check if the given email is found, not disabled and matches with the hashed password."""
         user = (

core/authorization/__init__.py

@@ -172,10 +172,16 @@ async def delete_user_handler(self, request: web.Request) -> web.StreamResponse:
 
         loggedInUser = await self.core.authentication.check_authorized(request)
         if loggedInUser != userId:
-            _LOGGER.error(
-                f"attempt to change a different user! Authenticated user: {loggedInUser}, user to change: {userId}"
-            )
-            raise web.HTTPForbidden
+            # admin users can delete other users
+            try:
+                await self.core.authentication.check_permission(
+                    request, "admin.users:write"
+                )
+            except web.HTTPForbidden:
+                _LOGGER.error(
+                    f"attempt to change a different user! Authenticated user: {loggedInUser}, user to change: {userId}"
+                )
+                raise web.HTTPForbidden
 
         Session.query(User).filter(User.id == loggedInUser).update(
             {User.deleted_date: datetime.utcnow(), User.disabled: True},
@@ -235,13 +241,16 @@ async def create_user_handler(self, request: web.Request) -> web.StreamResponse:
                 "lastname": new_user.lastname,
             }
 
+            # create user home
+            self.core.storage.create_user_home(new_user.id)
+
             return web.json_response(status=201, data=data)
 
         _LOGGER.error(f"Could not find newly created user {email}")
         return web.json_response(status=500, data=data)
 
     async def check_scope(self, scope: str):
+        # TODO: check if requested scope has been granted by the user when creating the current token
         _LOGGER.warning(f"check_scope({scope})")
 
-        # TODO: raise if scope is missing
         # raise web.HTTPForbidden()

core/base.py

@@ -10,7 +10,6 @@
 Session = scoped_session(session_factory)
 
 Base = declarative_base()
-Base.metadata.create_all(engine)
 
 
 def generate_uuid():

core/core.py

@@ -8,15 +8,26 @@
 import sys
 from logging.handlers import TimedRotatingFileHandler
 from time import monotonic
-from typing import (Any, Awaitable, Callable, Dict, Iterable, List, Optional,
-                    Sequence, Set, TypeVar)
+from typing import (
+    Any,
+    Awaitable,
+    Callable,
+    Dict,
+    Iterable,
+    List,
+    Optional,
+    Sequence,
+    Set,
+    TypeVar,
+)
 
 from colorlog import ColoredFormatter
 
 from core import loader
 from core.addon import Addon
 from core.authentication import Authentication, AuthenticationClient
 from core.authorization import Authorization
+from core.base import Base, engine
 from core.configs import Config
 from core.persistency.persistency import PersistencyManager
 from core.utils.timeout import TimeoutManager
@@ -296,15 +307,17 @@ async def async_block_till_done(self) -> None:
 
         self.http = Webserver(self)
 
+        Base.metadata.create_all(engine)
+
         # setup addons from config entries
         await self.async_set_up_addons()
 
+        await self.storage.start_directory_observing()
+        _LOGGER.info("Observe user directories for file changes.")
+
         await self.http.start()
         _LOGGER.info("Webserver should be up and running...")
 
-        await self.storage.start_directory_observing()
-        _LOGGER.info("Observe user directories.")
-
         while self._pending_tasks:
             pending = [task for task in self._pending_tasks if not task.done()]
             self._pending_tasks.clear()

core/persistency/dto/directory.py

@@ -0,0 +1,30 @@
+"""Directory representation for persistency."""
+import uuid
+from datetime import datetime
+
+from sqlalchemy import Column, DateTime, ForeignKey, Integer, String
+
+from ...base import Base
+
+
+def generate_uuid():
+    return str(uuid.uuid4())
+
+
+class Directory(Base):
+    """Directory representation for user directories containing files."""
+
+    __tablename__ = "directories"
+
+    id = Column(String, name="uuid", primary_key=True, default=generate_uuid)
+    directory = Column(String)
+    owner = Column(Integer, ForeignKey("users.uuid"), nullable=False)
+    added = Column(DateTime, default=datetime.utcnow)
+    last_scanned = Column(DateTime)
+
+    def __init__(self, directory, owner):
+        self.directory = directory
+        self.owner = owner
+
+    def __repr__(self):
+        return f"Directory({self.directory}, owner={self.owner})"

core/persistency/persistency.py

@@ -102,27 +102,42 @@ def process_load_queue(self, queue: Queue) -> None:
                 time.sleep(1)
 
     async def start_directory_observing(self) -> None:
-        _LOGGER.debug("start_directory_observing")
+        """Start observing user directories for changes."""
         self.worker.start()
 
-        # TODO: add directories into database
-        # webDir = os.path.join(self.core.config.data_dir, "web")
-        # directory = Directory(webDir, 1)
-        # Session.add(directory)
-        # Session.commit()
-
         directories = Session.query(Directory).all()
         for dir in directories:
             path = os.path.join(dir.directory)
             self.observer.schedule(self.event_handler, path, recursive=True)
         self.observer.start()
 
     async def stop_directory_observing(self) -> None:
-        _LOGGER.debug("stop_directory_observing")
+        """Stop observing user directories."""
         self.worker.stop()
         self.observer.stop()
         self.observer.join()
 
+    async def restart_directory_observing(self) -> None:
+        """stop and re-start directory observing."""
+        await self.stop_directory_observing()
+        await self.start_directory_observing()
+
+    def create_user_home(self, user_id: str) -> None:
+        """Create a directory for the user in the configured data directory."""
+        # create user_home in filesystem
+        path = os.path.join(self.config.data_dir, user_id)
+        os.mkdir(path)
+
+        # add user_home to observing
+        self.observer.schedule(self.event_handler, path, recursive=True)
+
+        # add user_home to database
+        directory = Directory(path, user_id)
+        Session.add(directory)
+        Session.commit()
+
+        _LOGGER.info(f"user home for user {user_id} created.")
+
     async def read_photos(self, user_id: int, offset: int = 0, limit: int = 10) -> List:
         return (
             Session.query(Photo)

core/webserver/__init__.py

@@ -80,7 +80,7 @@ async def start(self):
         _LOGGER.info(f"Webserver is listening on {site._host}:{site._port}")
 
     async def init_auth(self):
-        auth_database = AuthDatabase(self.core.config.data_dir)
+        auth_database = AuthDatabase(self.core, self.core.config.data_dir)
 
         # setup auth
         self.core.authorization = Authorization(self.core, self.app)

requirements.txt

@@ -13,4 +13,5 @@ pyyaml>=5.3.1
 sqlalchemy>=1.3.20
 voluptuous>=0.12.0
 voluptuous-serialize>=2.4.0
+watchdog>=2.0.0
 wheel>=0.36.2