Don't special case singularity postgres

Author: mvdbeek

planemo/database/interface.py

@@ -22,5 +22,13 @@ def list_databases(self):
     def sqlalchemy_url(self, identifier) -> Optional[str]:
         """Return a URL string for use by sqlalchemy."""
 
+    def start(self):
+        """Start the database source, if necessary."""
+        pass
+
+    def stop(self):
+        """Stop the database source, if necessary."""
+        pass
+
 
 __all__ = ("DatabaseSource",)

planemo/database/postgres_docker.py

@@ -63,11 +63,17 @@ def __init__(self, **kwds):
         self.database_port = DEFAULT_POSTGRES_PORT_EXPOSE
         self._kwds = kwds
         self._docker_host_kwds = dockerfiles.docker_host_args(**kwds)
+
+    def start(self):
         if not is_running_container(**self._docker_host_kwds):
             start_postgres_docker(**self._docker_host_kwds)
             # Hack to give docker a bit of time to boot up and allow psql to start.
             time.sleep(30)
 
+    def stop(self):
+        if is_running_container(**self._docker_host_kwds):
+            stop_postgres_docker(**self._docker_host_kwds)
+
     def sqlalchemy_url(self, identifier):
         """Return URL or form postgresql://username:password@localhost/mydatabase."""
         return "postgresql://%s:%s@%s:%d/%s" % (

planemo/database/postgres_singularity.py

@@ -102,23 +102,22 @@ def create_database(self, identifier):
     def delete_database(self, identifier):
         shutil.rmtree(self.database_location, ignore_errors=True)
 
-    def __enter__(self):
+    def start(self):
         self.running_process = start_postgres_singularity(
             singularity_path=self.singularity_path,
             database_location=self.database_location,
             user=self.database_user,
             password=self.database_password,
         )
-        return self
 
-    def __exit__(self, exc_type, exc_value, traceback):
+    def stop(self):
         if self.running_process:
             try:
                 self.running_process.terminate()
                 postmaster_pid_file = os.path.join(self.database_location, "pgdata", "postmaster.pid")
                 if os.path.exists(postmaster_pid_file):
                     os.remove(postmaster_pid_file)
-                postmaster_lock_file = os.path.join(self.database_location, "pgrun", "pgrun/.s.PGSQL.5432.lock")
+                postmaster_lock_file = os.path.join(self.database_location, "pgrun", ".s.PGSQL.5432.lock")
                 if os.path.exists(postmaster_lock_file):
                     os.remove(postmaster_lock_file)
             except Exception as e:

planemo/engine/factory.py

@@ -9,7 +9,6 @@
     DockerizedManagedGalaxyEngine,
     ExternalGalaxyEngine,
     LocalManagedGalaxyEngine,
-    LocalManagedGalaxyEngineWithSingularityDB,
 )
 from .toil import ToilEngine
 
@@ -26,10 +25,7 @@ def build_engine(ctx, **kwds):
     """Build an engine from the supplied planemo configuration."""
     engine_type_str = kwds.get("engine", "galaxy")
     if engine_type_str == "galaxy":
-        if "database_type" in kwds and kwds["database_type"] == "postgres_singularity":
-            engine_type = LocalManagedGalaxyEngineWithSingularityDB
-        else:
-            engine_type = LocalManagedGalaxyEngine
+        engine_type = LocalManagedGalaxyEngine
     elif engine_type_str == "docker_galaxy":
         engine_type = DockerizedManagedGalaxyEngine
     elif engine_type_str == "external_galaxy":

planemo/engine/galaxy.py

@@ -12,7 +12,6 @@
 from galaxy.tool_util.verify import interactor
 
 from planemo import io
-from planemo.database.postgres_singularity import SingularityPostgresDatabaseSource
 from planemo.galaxy.activity import (
     execute,
     execute_rerun,
@@ -172,20 +171,6 @@ def _serve_kwds(self):
         return self._kwds.copy()
 
 
-class LocalManagedGalaxyEngineWithSingularityDB(LocalManagedGalaxyEngine):
-    def run(self, runnables, job_paths, output_collectors: Optional[List[Callable]] = None):
-        with SingularityPostgresDatabaseSource(**self._kwds.copy()) as db_source:
-            # Get the actual database connection string from the running database
-            database_identifier = self._kwds.get("database_identifier", "galaxy")
-            database_connection = db_source.sqlalchemy_url(database_identifier)
-
-            # Update kwds with the actual database connection
-            self._kwds["database_connection"] = database_connection
-
-            run_responses = super().run(runnables, job_paths, output_collectors)
-        return run_responses
-
-
 class DockerizedManagedGalaxyEngine(LocalManagedGalaxyEngine):
     """An :class:`Engine` implementation backed by Galaxy running in Docker.
 
@@ -240,5 +225,4 @@ def expand_test_cases(config, test_cases):
     "DockerizedManagedGalaxyEngine",
     "ExternalGalaxyEngine",
     "LocalManagedGalaxyEngine",
-    "LocalManagedGalaxyEngineWithSingularityDB",
 )

planemo/galaxy/config.py

@@ -37,6 +37,7 @@
 
 from planemo import git
 from planemo.config import OptionSource
+from planemo.database import create_database_source
 from planemo.deps import ensure_dependency_resolvers_conf_configured
 from planemo.docker import docker_host_args
 from planemo.galaxy.workflows import (
@@ -421,7 +422,6 @@ def config_join(*args):
             )
         )
         _handle_container_resolution(ctx, kwds, properties)
-        properties["database_connection"] = _database_connection(database_location, **kwds)
         if kwds.get("mulled_containers", False):
             properties["mulled_channels"] = kwds.get("conda_ensure_channels", "")
 
@@ -444,15 +444,6 @@ def config_join(*args):
         # https://github.com/galaxyproject/planemo/issues/788
         env["GALAXY_LOG"] = log_file
         env["GALAXY_PID"] = pid_file
-        write_galaxy_config(
-            galaxy_root=galaxy_root,
-            properties=properties,
-            env=env,
-            kwds=kwds,
-            template_args=template_args,
-            config_join=config_join,
-        )
-
         _write_tool_conf(ctx, all_tool_paths, tool_conf)
         write_file(empty_tool_conf, EMPTY_TOOL_CONF_TEMPLATE)
 
@@ -461,19 +452,29 @@ def config_join(*args):
         write_file(shed_tool_conf, shed_tool_conf_contents, force=False)
 
         write_file(shed_data_manager_config_file, SHED_DATA_MANAGER_CONF_TEMPLATE)
+        with _database_connection(database_location, **kwds) as database_connection:
+            properties["database_connection"] = database_connection
+            write_galaxy_config(
+                galaxy_root=galaxy_root,
+                properties=properties,
+                env=env,
+                kwds=kwds,
+                template_args=template_args,
+                config_join=config_join,
+            )
 
-        yield LocalGalaxyConfig(
-            ctx,
-            config_directory,
-            env,
-            test_data_dir,
-            port,
-            server_name,
-            master_api_key,
-            runnables,
-            galaxy_root,
-            kwds,
-        )
+            yield LocalGalaxyConfig(
+                ctx,
+                config_directory,
+                env,
+                test_data_dir,
+                port,
+                server_name,
+                master_api_key,
+                runnables,
+                galaxy_root,
+                kwds,
+            )
 
 
 def write_galaxy_config(galaxy_root, properties, env, kwds, template_args, config_join):
@@ -1104,10 +1105,17 @@ def default_use_path_paste(self):
         return self.user_is_admin
 
 
+@contextlib.contextmanager
 def _database_connection(database_location, **kwds):
-    default_connection = DATABASE_LOCATION_TEMPLATE % database_location
-    database_connection = kwds.get("database_connection") or default_connection
-    return database_connection
+    if kwds.get("database_type") != "sqlite":
+        database_source = create_database_source(**kwds)
+        try:
+            database_source.start()
+            yield database_source.sqlalchemy_url(kwds.get("database_identifier", "galaxy"))
+        finally:
+            database_source.stop()
+    else:
+        yield DATABASE_LOCATION_TEMPLATE % database_location
 
 
 def _find_galaxy_root(ctx, **kwds):

planemo/galaxy/profiles.py

@@ -95,15 +95,13 @@ def _create_profile_local(ctx, profile_directory, profile_name, kwds):
         else:
             database_type = "sqlite"
 
-    if database_type not in ["sqlite", "postgres_singularity"]:
+    if database_type not in ["sqlite"]:
         database_source = create_database_source(**kwds)
         database_identifier = _profile_to_database_identifier(profile_name)
         database_source.create_database(
             database_identifier,
         )
         database_connection = database_source.sqlalchemy_url(database_identifier)
-    elif database_type == "postgres_singularity":
-        database_connection + database_source.sqlalchemy_url(database_identifier)
     else:
         database_location = os.path.join(profile_directory, "galaxy.sqlite")
         database_connection = DATABASE_LOCATION_TEMPLATE % database_location