def _create_profile_local(ctx, profile_directory, profile_name, kwds): database_type = kwds.get("database_type", "auto") if database_type == "auto": if which("psql"): database_type = "postgres" elif which("docker"): database_type = "postgres_docker" else: database_type = "sqlite" if database_type != "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) else: database_location = os.path.join(profile_directory, "galaxy.sqlite") database_connection = DATABASE_LOCATION_TEMPLATE % database_location return { "database_type": database_type, "database_connection": database_connection, "engine": "galaxy", }
def find_engine(config): nodejs_path = getattr(config, "nodejs_path", None) if nodejs_path is None: nodejs_path = which("nodejs") or which("node") or None if nodejs_path is None: raise Exception("nodejs or node not found on PATH") return nodejs_path
def create_command(virtualenv_path, galaxy_python_version=None): """ If virtualenv is on Planemo's path use it, otherwise use the planemo subcommand virtualenv to create the virtualenv. """ planemo_path = os.path.abspath(sys.argv[0]) virtualenv_on_path = which("virtualenv") if virtualenv_on_path: base_command = [ os.path.abspath(virtualenv_on_path), ] else: base_command = [ planemo_path, "virtualenv", ] command = base_command # Create a virtualenv with the selected python version. # default to 2.7 if galaxy_python_version is None: galaxy_python_version = DEFAULT_PYTHON_VERSION python = which("python%s" % galaxy_python_version) if python: python = os.path.abspath(python) command.extend(["-p", python]) command.append(virtualenv_path) return " ".join(command)
def test_build_mulled(self): if not which('docker'): raise unittest.SkipTest( "Docker not found on PATH, required for building images via involucro" ) resolver_type = self.build_mulled_resolver tool_ids = ['mulled_example_multi_1'] endpoint = "dependency_resolvers/toolbox/install" data = { 'tool_ids': json.dumps(tool_ids), 'resolver_type': resolver_type, 'container_type': self.container_type, 'include_containers': True } create_response = self._post(endpoint, data=data, admin=True) self._assert_status_code_is(create_response, 200) create_response = self._get("dependency_resolvers/toolbox", data={ 'tool_ids': tool_ids, 'container_type': self.container_type, 'include_containers': True, 'index_by': 'tools' }, admin=True) response = create_response.json() assert len(response) == 1 status = response[0]['status'] assert status[0]['model_class'] == 'ContainerDependency' assert status[0]['dependency_type'] == self.container_type assert status[0]['container_description']['identifier'].startswith( 'quay.io/local/mulled-v2-')
def create_database_source(**kwds): """Return a :class:`planemo.database.DatabaseSource` for configuration.""" database_type = kwds.get("database_type", "auto") if database_type == "auto": if which("psql"): database_type = "postgres" elif which("docker"): database_type = "postgres_docker" else: raise Exception( "Cannot find executables for psql or docker, cannot configure a database source." ) if database_type == "postgres": return LocalPostgresDatabaseSource(**kwds) elif database_type == "postgres_docker": return DockerPostgresDatabaseSource(**kwds) # TODO # from .sqlite import SqliteDatabaseSource # elif database_type == "sqlite": # return SqliteDatabaseSource(**kwds) else: raise Exception("Unknown database type [%s]." % database_type)
def test_build_mulled(self): if not which('docker'): raise unittest.SkipTest( "Docker not found on PATH, required for building images via involucro" ) resolver_type = self.build_mulled_resolver tool_id = 'mulled_example_multi_1' endpoint = "tools/%s/dependencies" % tool_id data = {'id': tool_id, 'resolver_type': resolver_type} create_response = self._post(endpoint, data=data, admin=True) self._assert_status_code_is(create_response, 200) response = create_response.json() assert any([ True for d in response if d['dependency_type'] == self.container_type ])
def ensure_gh(ctx, **kwds): """Ensure ``hub`` is on the system ``PATH``. This method will ensure ``hub`` is installed if it isn't available. For more information on ``hub`` checkout ... """ gh_path = which("gh") if not gh_path: planemo_gh_path = os.path.join(ctx.workspace, "gh") if not os.path.exists(planemo_gh_path): _try_download_gh(planemo_gh_path) if not os.path.exists(planemo_gh_path): raise Exception(FAILED_TO_DOWNLOAD_GH) gh_path = planemo_gh_path return gh_path
def skip_unless_executable(executable): if which(executable): return lambda func: func return skip("PATH doesn't contain executable %s" % executable)
def skip_if_container_type_unavailable(cls): if not which(cls.container_type): raise unittest.SkipTest("Executable '%s' not found on PATH" % cls.container_type)
def skip_unless_executable(executable): if which(executable): return _identity return pytest.mark.skip("PATH doesn't contain executable %s" % executable)
def enabled(self): return bool(which("xmllint"))
def setUpClass(cls): if not which(cls.container_type): raise unittest.SkipTest("Executable '%s' not found on PATH" % cls.container_type) super(DockerizedJobsIntegrationTestCase, cls).setUpClass()