Install via conda

config/galaxy.ini.sample

@@ -196,6 +196,8 @@ paste.app_factory = galaxy.web.buildapp:app_factory
 # Set to True to instruct Galaxy to look for and install missing tool
 # dependencies before each job runs.
 #conda_auto_install = False
+# Set to True to perform additional checking of installed conda environment
+#conda_verbose_install_check=False
 # Set to True to instruct Galaxy to install conda from the web automatically
 # if it cannot find a local copy and conda_exec is not configured.
 #conda_auto_init = False

lib/galaxy/tools/__init__.py

@@ -29,6 +29,7 @@
 from galaxy.tools.actions.data_source import DataSourceToolAction
 from galaxy.tools.actions.data_manager import DataManagerToolAction
 from galaxy.tools.actions.model_operations import ModelOperationToolAction
+from galaxy.tools.deps import views
 from galaxy.tools.parameters import params_to_incoming, check_param, params_from_strings, params_to_strings, visit_input_values
 from galaxy.tools.parameters import output_collect
 from galaxy.tools.parameters.basic import (BaseURLToolParameter,
@@ -108,6 +109,11 @@ def __init__( self, config_filenames, tool_root_dir, app ):
             app=app,
         )
 
+    @property
+    def all_requirements(self):
+        reqs = [json.dumps(req, sort_keys=True) for _, tool in self.tools() for req in tool.tool_requirements]
+        return [json.loads(req) for req in set(reqs)]
+
     @property
     def tools_by_id( self ):
         # Deprecated method, TODO - eliminate calls to this in test/.
@@ -310,6 +316,7 @@ def __init__( self, config_file, tool_source, app, guid=None, repository_id=None
             global_tool_errors.add_error(config_file, "Tool Loading", e)
             raise e
         self.history_manager = histories.HistoryManager( app )
+        self._view = views.DependencyResolversView(app)
 
     @property
     def sa_session( self ):
@@ -1292,6 +1299,21 @@ def installed_tool_dependencies(self):
             installed_tool_dependencies = None
         return installed_tool_dependencies
 
+    @property
+    def tool_requirements(self):
+        """
+        Return all requiremens of type package
+        """
+        reqs = [req.to_dict() for req in self.requirements if req.type == 'package']
+        return reqs
+
+    @property
+    def tool_requirements_status(self):
+        """
+        Return a list of dictionaries for all tool dependencies with their associated status
+        """
+        return self._view.get_requirements_status(self.tool_requirements)
+
     def build_redirect_url_params( self, param_dict ):
         """
         Substitute parameter values into self.redirect_url_params

lib/galaxy/tools/deps/__init__.py

@@ -7,7 +7,7 @@
 import logging
 log = logging.getLogger( __name__ )
 
-from .resolvers import INDETERMINATE_DEPENDENCY
+from .resolvers import NullDependency
 from .resolvers.galaxy_packages import GalaxyPackageDependencyResolver
 from .resolvers.tool_shed_packages import ToolShedPackageDependencyResolver
 from .resolvers.conda import CondaDependencyResolver
@@ -58,7 +58,7 @@ def dependency_shell_commands( self, requirements, **kwds ):
         return []
 
     def find_dep( self, name, version=None, type='package', **kwds ):
-        return INDETERMINATE_DEPENDENCY
+        return NullDependency(version=version, name=name)
 
 
 class DependencyManager( object ):
@@ -90,7 +90,7 @@ def dependency_shell_commands( self, requirements, **kwds ):
         commands = []
         for requirement in requirements:
             log.debug( "Building dependency shell command for dependency '%s'", requirement.name )
-            dependency = INDETERMINATE_DEPENDENCY
+            dependency = NullDependency(version=requirement.version, name=requirement.name)
             if requirement.type in [ 'package', 'set_environment' ]:
                 dependency = self.find_dep( name=requirement.name,
                                             version=requirement.version,
@@ -115,10 +115,10 @@ def find_dep( self, name, version=None, type='package', **kwds ):
                 continue
             dependency = resolver.resolve( name, version, type, **kwds )
             if require_exact and not dependency.exact:
-                dependency = INDETERMINATE_DEPENDENCY
-            if dependency != INDETERMINATE_DEPENDENCY:
+                continue
+            if not isinstance(dependency, NullDependency):
                 return dependency
-        return INDETERMINATE_DEPENDENCY
+        return NullDependency(version=version, name=name)
 
     def __build_dependency_resolvers( self, conf_file ):
         if not conf_file:

lib/galaxy/tools/deps/conda_util.py

@@ -322,11 +322,13 @@ def is_target_available(conda_target, conda_context=None):
         return False
 
 
-def is_conda_target_installed(conda_target, conda_context=None):
+def is_conda_target_installed(conda_target, conda_context=None, verbose_install_check=False):
     conda_context = _ensure_conda_context(conda_context)
     # fail by default
     success = False
     if conda_context.has_env(conda_target.install_environment):
+        if not verbose_install_check:
+            return True
         # because export_list directs output to a file we
         # need to make a temporary file, not use StringIO
         f, package_list_file = tempfile.mkstemp(suffix='.env_packages')
@@ -342,10 +344,11 @@ def is_conda_target_installed(conda_target, conda_context=None):
     return success
 
 
-def filter_installed_targets(conda_targets, conda_context=None):
+def filter_installed_targets(conda_targets, conda_context=None, verbose_install_check=False):
     conda_context = _ensure_conda_context(conda_context)
     installed = functools.partial(is_conda_target_installed,
-                                  conda_context=conda_context)
+                                  conda_context=conda_context,
+                                  verbose_install_check=verbose_install_check)
     return filter(installed, conda_targets)
 
 

lib/galaxy/tools/deps/resolvers/__init__.py

@@ -13,6 +13,7 @@ class DependencyResolver(Dictifiable, object):
     # because the repository install context is used in dependency resolution
     # so the same requirement tags in different tools will have very different
     # resolution.
+    disabled = False
     resolves_simple_dependencies = True
     __metaclass__ = ABCMeta
 
@@ -71,7 +72,7 @@ def install_dependency(self, name, version, type, **kwds):
 
 
 class Dependency(Dictifiable, object):
-    dict_collection_visible_keys = ['dependency_type', 'exact']
+    dict_collection_visible_keys = ['dependency_type', 'exact', 'name', 'version']
     __metaclass__ = ABCMeta
 
     @abstractmethod
@@ -91,8 +92,9 @@ class NullDependency( Dependency ):
     dependency_type = None
     exact = True
 
+    def __init__(self, version=None, name=None):
+        self.version = version
+        self.name = name
+
     def shell_commands( self, requirement ):
         return None
-
-
-INDETERMINATE_DEPENDENCY = NullDependency()

lib/galaxy/tools/deps/resolvers/brewed_tool_shed_packages.py

@@ -12,7 +12,7 @@
     UsesToolDependencyDirMixin,
     UsesInstalledRepositoriesMixin,
 )
-from ..resolvers import DependencyResolver, INDETERMINATE_DEPENDENCY
+from ..resolvers import DependencyResolver, NullDependency
 
 log = logging.getLogger(__name__)
 
@@ -31,10 +31,9 @@ def __init__(self, dependency_manager, **kwds):
 
     def resolve(self, name, version, type, **kwds):
         if type != "package":
-            return INDETERMINATE_DEPENDENCY
-
+            return NullDependency(version=version, name=name)
         if version is None:
-            return INDETERMINATE_DEPENDENCY
+            return NullDependency(version=version, name=name)
 
         return self._find_tool_dependencies(name, version, type, **kwds)
 
@@ -49,7 +48,7 @@ def _find_tool_dependencies(self, name, version, type, **kwds):
             if os.path.exists(tool_depenedencies_path):
                 return self._resolve_from_tool_dependencies_path(name, version, tool_depenedencies_path)
 
-        return INDETERMINATE_DEPENDENCY
+        return NullDependency(version=version, name=name)
 
     def _resolve_from_installed_tool_dependency(self, name, version, installed_tool_dependency):
         tool_shed_repository = installed_tool_dependency.tool_shed_repository
@@ -66,11 +65,11 @@ def _resolve_from_tool_dependencies_path(self, name, version, tool_dependencies_
             raw_dependencies = RawDependencies(tool_dependencies_path)
         except Exception:
             log.debug("Failed to parse dependencies in file %s" % tool_dependencies_path)
-            return INDETERMINATE_DEPENDENCY
+            return NullDependency(version=version, name=name)
 
         raw_dependency = raw_dependencies.find(name, version)
         if not raw_dependency:
-            return INDETERMINATE_DEPENDENCY
+            return NullDependency(version=version, name=name)
 
         recipe_name = build_recipe_name(
             package_name=name,

lib/galaxy/tools/deps/resolvers/conda.py

@@ -6,11 +6,9 @@
 
 import os
 
-from galaxy.exceptions import NotImplemented
-
 from ..resolvers import (
     DependencyResolver,
-    INDETERMINATE_DEPENDENCY,
+    NullDependency,
     Dependency,
     ListableDependencyResolver,
     InstallableDependencyResolver,
@@ -65,6 +63,7 @@ def get_option(name):
 
         conda_exec = get_option("exec")
         debug = _string_as_bool(get_option("debug"))
+        verbose_install_check = _string_as_bool(get_option("verbose_install_check"))
         ensure_channels = get_option("ensure_channels")
         use_path_exec = get_option("use_path_exec")
         if use_path_exec is None:
@@ -89,53 +88,57 @@ def get_option(name):
         auto_install = _string_as_bool(get_option("auto_install"))
         copy_dependencies = _string_as_bool(get_option("copy_dependencies"))
 
-        if auto_init and not os.path.exists(conda_context.conda_prefix):
-            if install_conda(conda_context):
-                raise Exception("Conda installation requested and failed.")
+        if not os.path.exists(conda_context.conda_prefix):
+            if auto_init:
+                if install_conda(conda_context):
+                    self.disabled = True
+                    log.warning("Conda installation requested and failed.")
+            else:
+                self.disabled = True
+                log.warning("Conda not installed and auto-installation disabled.")
 
         self.conda_context = conda_context
         self.auto_install = auto_install
         self.copy_dependencies = copy_dependencies
+        self.verbose_install_check = verbose_install_check
 
     def resolve(self, name, version, type, **kwds):
         # Check for conda just not being there, this way we can enable
         # conda by default and just do nothing in not configured.
         if not os.path.isdir(self.conda_context.conda_prefix):
-            return INDETERMINATE_DEPENDENCY
+            return NullDependency(version=version, name=name)
 
         if type != "package":
-            return INDETERMINATE_DEPENDENCY
-
-        job_directory = kwds.get("job_directory", None)
-        if job_directory is None:
-            log.warning("Conda dependency resolver not sent job directory.")
-            return INDETERMINATE_DEPENDENCY
+            return NullDependency(version=version, name=name)
 
         exact = not self.versionless or version is None
         if self.versionless:
             version = None
 
         conda_target = CondaTarget(name, version=version)
         is_installed = is_conda_target_installed(
-            conda_target, conda_context=self.conda_context
+            conda_target, conda_context=self.conda_context, verbose_install_check=self.verbose_install_check
         )
-        if not is_installed and self.auto_install:
-            return_code = install_conda_target(conda_target, conda_context=self.conda_context)
-            if return_code != 0:
-                is_installed = False
-                log.debug('Cleaning up after failed install of {}, {}'.format(name, version))
-                cleanup_failed_install(conda_target, conda_context=self.conda_context)
-            else:
-                # Recheck if installed
-                is_installed = is_conda_target_installed(
-                    conda_target, conda_context=self.conda_context
+
+        job_directory = kwds.get("job_directory", None)
+        if job_directory is None:  # Job directory is None when resolve() called by find_dep()
+            if is_installed:
+                return CondaDependency(
+                    False,
+                    os.path.join(self.conda_context.envs_path, conda_target.install_environment),
+                    exact,
+                    name=name,
+                    version=version
                 )
-                if not is_installed:
-                    log.debug('Cleaning up after failing to verify installed environment for {}, {}'.format(name, version))
-                    cleanup_failed_install(conda_target, conda_context=self.conda_context)
+            else:
+                log.warning("Conda dependency resolver not sent job directory.")
+                return NullDependency(version=version, name=name)
+
+        if not is_installed and self.auto_install:
+            is_installed = self.install_dependency(name, version, type)
 
         if not is_installed:
-            return INDETERMINATE_DEPENDENCY
+            return NullDependency(version=version, name=name)
 
         # Have installed conda_target and job_directory to send it too.
         # If dependency is for metadata generation, store environment in conda-metadata-env
@@ -150,8 +153,9 @@ def resolve(self, name, version, type, **kwds):
             copy=self.copy_dependencies,
             conda_context=self.conda_context,
         )
+
         if not exit_code:
-            return CondaDepenency(
+            return CondaDependency(
                 self.conda_context.activate,
                 conda_environment,
                 exact,
@@ -166,34 +170,67 @@ def list_dependencies(self):
             yield self._to_requirement(name, version)
 
     def install_dependency(self, name, version, type, **kwds):
+        "Returns True on (seemingly) successfull installation"
         if type != "package":
-            raise NotImplemented("Can only install dependencies of type '%s'" % type)
+            log.warning("Cannot install dependencies of type '%s'" % type)
+            return False
 
         if self.versionless:
             version = None
+
         conda_target = CondaTarget(name, version=version)
 
-        if install_conda_target(conda_target, conda_context=self.conda_context):
-            raise Exception("Failed to install conda recipe.")
+        is_installed = is_conda_target_installed(
+            conda_target, conda_context=self.conda_context, verbose_install_check=self.verbose_install_check
+        )
+
+        if is_installed:
+            return is_installed
+
+        return_code = install_conda_target(conda_target, conda_context=self.conda_context)
+        if return_code != 0:
+            is_installed = False
+            log.debug("Remove failed conda install of {}, version '{}'".format(name, version))
+            cleanup_failed_install(conda_target, conda_context=self.conda_context)
+        else:
+            # Recheck if installed
+            is_installed = is_conda_target_installed(
+                conda_target, conda_context=self.conda_context, verbose_install_check=self.verbose_install_check
+            )
+            if not is_installed:
+                log.debug("Remove failed conda install of {}, version '{}'".format(name, version))
+                cleanup_failed_install(conda_target, conda_context=self.conda_context)
+
+        return is_installed
 
     @property
     def prefix(self):
         return self.conda_context.conda_prefix
 
 
-class CondaDepenency(Dependency):
-    dict_collection_visible_keys = Dependency.dict_collection_visible_keys + ['environment_path']
+class CondaDependency(Dependency):
+    dict_collection_visible_keys = Dependency.dict_collection_visible_keys + ['environment_path', 'name', 'version']
     dependency_type = 'conda'
 
-    def __init__(self, activate, environment_path, exact):
+    def __init__(self, activate, environment_path, exact, name=None, version=None):
         self.activate = activate
         self.environment_path = environment_path
         self._exact = exact
+        self._name = name
+        self._version = version
 
     @property
     def exact(self):
         return self._exact
 
+    @property
+    def name(self):
+        return self._name
+
+    @property
+    def version(self):
+        return self._version
+
     def shell_commands(self, requirement):
         return """[ "$CONDA_DEFAULT_ENV" = "%s" ] || . %s '%s' 2>&1 """ % (
             self.environment_path,