Mo basics

app/core/woodpecker.py

@@ -8,21 +8,23 @@ from injectable import injectable, Autowired, autowired
 
 from app.config import get_settings
 from app.model.webhook import WoodpeckerEvent
-from app.services import Passwords, GitService, DockerService
+from app.services import GitService, DockerService
+from app.services.mo import Mo
 
 logger = logging.getLogger(__name__)
 
 
 class WoodpeckerRunner(Process):
-  def __init__(self, git: GitService, docker: DockerService, passwords: Passwords,
+  def __init__(self, git: GitService, docker: DockerService, mo: Mo,
                success_callback=None, error_callback=None):
     super().__init__(daemon=True)
     self._git = git
     self._docker = docker
-    self._passwords = passwords
+    self._mo = mo
     self._success_callback = success_callback
     self._error_callback = error_callback
     self._event: WoodpeckerEvent | None = None
+    self._root = get_settings().git.path
 
   def process_event(self, event: WoodpeckerEvent):
     self._event = event
@@ -34,12 +36,12 @@ class WoodpeckerRunner(Process):
       if service is None:
         logger.info("No service found.")
         return self._success_callback()
-      service_path = f"{get_settings().git.path}/compose/{service}/docker-compose.yml"
+      service_path = f"{self._root}/compose/{service}/docker-compose.yml"
       self._git.checkout(self._event.commit)
       for file in self._event.files:
         if file.__contains__('.mo.'):
-          pass
+          self._mo.process(Path(f"{self._root}{file}").absolute())
-      self._docker.reload(Path(service_path))
+      self._docker.reload(Path(service_path).absolute())
 
       return self._success_callback()
     except Exception as e:
@@ -63,8 +65,8 @@ class WoodpeckerRunner(Process):
 @injectable(singleton=True)
 class Woodpecker:
   @autowired
-  def __init__(self, passwords: Annotated[Passwords, Autowired]):
+  def __init__(self, mo: Annotated[Mo, Autowired]):
-    self._passwords = passwords
+    self._mo = mo
     self._git = GitService()
     self._docker = DockerService()
     self._runner: WoodpeckerRunner | None = None
@@ -82,7 +84,8 @@ class Woodpecker:
 
   def _start_runner(self, event: WoodpeckerEvent):
     with self._lock:
-      self._runner = WoodpeckerRunner(self._git, self._docker, self._on_runner_completed)
+      self._runner = WoodpeckerRunner(self._git, self._docker, self._mo,
+                                      self._on_runner_completed, self._on_runner_error)
       self._runner.process_event(event)
 
   def _on_runner_completed(self):

app/services/mo.py

@@ -0,0 +1,16 @@
+from pathlib import Path
+from typing import Annotated
+
+from injectable import injectable, autowired, Autowired
+
+from app.services import Passwords
+
+
+@injectable
+class Mo:
+  @autowired
+  def __init__(self, passwords: Annotated[Passwords, Autowired]):
+    self._passwords = passwords
+
+  def process(self, mo_file: Path):
+    pass

app/services/passwords.py

@@ -1,7 +1,8 @@
 import os.path
+import shutil
 
 from injectable import injectable
-from pykeepass import PyKeePass, create_database, Group
+from pykeepass import PyKeePass, create_database
 
 
 @injectable(singleton=True)
@@ -12,29 +13,27 @@ class Passwords:
 
     with open(settings.kp.secret, "r") as fh:
       secret = fh.read().splitlines()[0]
-
+    self._path = settings.kp.file
-    self._kp_org = self.__get_or_create_store(settings.kp.file, secret)
+    self._kp_org = self._open_or_create(self._path, secret)
-    self._kp = self.__get_lock(settings.kp.file, secret)
+    self._kp = self._open_lock(self._path, secret)
 
   @staticmethod
-  def __get_or_create_store(path, passwd) -> PyKeePass:
+  def _open_or_create(path, password) -> PyKeePass:
     if os.path.exists(path):
-      return PyKeePass(
+      return PyKeePass(path, password=password)
-        path,
+    return create_database(path, password)
-        password=passwd,
-      )
-    return create_database(path, passwd)
 
   @staticmethod
-  def __get_lock(path, passwd) -> PyKeePass:
+  def _open_lock(path, password) -> PyKeePass:
     lock_path = path + ".lock"
-    import shutil
     shutil.copyfile(path, lock_path)
-    return Passwords.__get_or_create_store(lock_path, passwd)
+    return Passwords._open_or_create(lock_path, password)
 
   @property
-  def store(self):
+  def kp(self) -> PyKeePass:
-    return self._kp.root_group
+    return self._kp
 
-  def save(self, group: Group):
+  def save(self):
-    pass
+    # nadpisz plik źródłowy zmianami z lock
+    self._kp.save()
+    shutil.copyfile(self._path + ".lock", self._path)