def requires_prior_installation_of(self):
"""
Return a list of repository dependency tuples like (tool_shed, name, owner, changeset_revision, prior_installation_required) for this
repository's repository dependencies where prior_installation_required is True. By definition, repository dependencies are required to
be installed in order for this repository to function correctly. However, those repository dependencies that are defined for this
repository with prior_installation_required set to True place them in a special category in that the required repositories must be
installed before this repository is installed. Among other things, this enables these "special" repository dependencies to include
information that enables the successful installation of this repository. This method is not used during the initial installation of
this repository, but only after it has been installed (metadata must be set for this repository in order for this method to be useful).
"""
required_rd_tups_that_must_be_installed = []
if self.has_repository_dependencies:
rd_tups = self.metadata['repository_dependencies'][
'repository_dependencies']
for rd_tup in rd_tups:
if len(rd_tup) == 5:
tool_shed, name, owner, changeset_revision, prior_installation_required, only_if_compiling_contained_td = \
common_util.parse_repository_dependency_tuple(rd_tup, contains_error=False)
if asbool(prior_installation_required):
required_rd_tups_that_must_be_installed.append(
(tool_shed, name, owner, changeset_revision,
'True', 'False'))
elif len(rd_tup) == 6:
tool_shed, name, owner, changeset_revision, prior_installation_required, only_if_compiling_contained_td = \
common_util.parse_repository_dependency_tuple(rd_tup, contains_error=False)
# The repository dependency will only be required to be previously installed if it does not fall into the category of
# a repository that must be installed only so that its contained tool dependency can be used for compiling the tool
# dependency of the dependent repository.
if not asbool(only_if_compiling_contained_td):
if asbool(prior_installation_required):
required_rd_tups_that_must_be_installed.append(
(tool_shed, name, owner, changeset_revision,
'True', 'False'))
return required_rd_tups_that_must_be_installed
def get_repository_dependency_types(repository_dependencies):
"""
Inspect the received list of repository_dependencies tuples and return boolean values
for has_repository_dependencies and has_repository_dependencies_only_if_compiling_contained_td.
"""
# Set has_repository_dependencies, which will be True only if at least one repository_dependency
# is defined with the value of
# only_if_compiling_contained_td as False.
has_repository_dependencies = False
for rd_tup in repository_dependencies:
tool_shed, name, owner, changeset_revision, prior_installation_required, only_if_compiling_contained_td = \
common_util.parse_repository_dependency_tuple(rd_tup)
if not util.asbool(only_if_compiling_contained_td):
has_repository_dependencies = True
break
# Set has_repository_dependencies_only_if_compiling_contained_td, which will be True only if at
# least one repository_dependency is defined with the value of only_if_compiling_contained_td as True.
has_repository_dependencies_only_if_compiling_contained_td = False
for rd_tup in repository_dependencies:
tool_shed, name, owner, changeset_revision, prior_installation_required, only_if_compiling_contained_td = \
common_util.parse_repository_dependency_tuple(rd_tup)
if util.asbool(only_if_compiling_contained_td):
has_repository_dependencies_only_if_compiling_contained_td = True
break
return has_repository_dependencies, has_repository_dependencies_only_if_compiling_contained_td
def get_prior_install_required_dict(self, tool_shed_repositories,
repository_dependencies_dict):
"""
Return a dictionary whose keys are the received tsr_ids and whose values are a list of tsr_ids, each of which is contained in the received
list of tsr_ids and whose associated repository must be installed prior to the repository associated with the tsr_id key.
"""
# Initialize the dictionary.
prior_install_required_dict = {}
tsr_ids = [
tool_shed_repository.id
for tool_shed_repository in tool_shed_repositories
]
for tsr_id in tsr_ids:
prior_install_required_dict[tsr_id] = []
# Inspect the repository dependencies about to be installed and populate the dictionary.
for rd_key, rd_tups in repository_dependencies_dict.items():
if rd_key in ['root_key', 'description']:
continue
for rd_tup in rd_tups:
prior_install_ids = []
tool_shed, name, owner, changeset_revision, prior_installation_required, only_if_compiling_contained_td = \
common_util.parse_repository_dependency_tuple(rd_tup)
if util.asbool(prior_installation_required):
for tsr in tool_shed_repositories:
if tsr.name == name and tsr.owner == owner and tsr.changeset_revision == changeset_revision:
prior_install_ids.append(tsr.id)
prior_install_required_dict[tsr.id] = prior_install_ids
return prior_install_required_dict
def create_or_update_tool_shed_repository_records(
self, name, changeset_revision, repository_dependencies_dict):
"""
Make sure the repository defined by name and changeset_revision and all of its repository dependencies have
associated tool_shed_repository table rows in the Galaxy database.
"""
created_tool_shed_repositories = []
description = repository_dependencies_dict.get('description', None)
tool_shed_repository = self.create_or_update_tool_shed_repository_record(
name,
self.repository_owner,
changeset_revision,
description=description)
if tool_shed_repository:
created_tool_shed_repositories.append(tool_shed_repository)
for rd_key, rd_tups in repository_dependencies_dict.items():
if rd_key in ['root_key', 'description']:
continue
for rd_tup in rd_tups:
parsed_rd_tup = common_util.parse_repository_dependency_tuple(
rd_tup)
rd_tool_shed, rd_name, rd_owner, rd_changeset_revision = parsed_rd_tup[
0:4]
# TODO: Make sure the repository description is applied to the new repository record during installation.
tool_shed_repository = self.create_or_update_tool_shed_repository_record(
rd_name, rd_owner, rd_changeset_revision, description=None)
if tool_shed_repository:
created_tool_shed_repositories.append(tool_shed_repository)
return created_tool_shed_repositories
def has_repository_dependencies_only_if_compiling_contained_td(self):
repository_dependencies_dict = self.metadata.get('repository_dependencies', {})
repository_dependencies = repository_dependencies_dict.get('repository_dependencies', [])
# [["http://localhost:9009", "package_libgtextutils_0_6", "test", "e2003cbf18cd", "True", "True"]]
for rd_tup in repository_dependencies:
tool_shed, name, owner, changeset_revision, prior_installation_required, only_if_compiling_contained_td = \
common_util.parse_repository_dependency_tuple(rd_tup)
if not asbool(only_if_compiling_contained_td):
return False
return True
def get_repository_ids_requiring_prior_import_or_install(
app, tsr_ids, repository_dependencies):
"""
This method is used in the Tool Shed when exporting a repository and its dependencies,
and in Galaxy when a repository and its dependencies are being installed. Inspect the
received repository_dependencies and determine if the encoded id of each required
repository is in the received tsr_ids. If so, then determine whether that required
repository should be imported / installed prior to its dependent repository. Return a
list of encoded repository ids, each of which is contained in the received list of tsr_ids,
and whose associated repositories must be imported / installed prior to the dependent
repository associated with the received repository_dependencies.
"""
prior_tsr_ids = []
if repository_dependencies:
for key, rd_tups in repository_dependencies.items():
if key in ['description', 'root_key']:
continue
for rd_tup in rd_tups:
tool_shed, \
name, \
owner, \
changeset_revision, \
prior_installation_required, \
only_if_compiling_contained_td = \
common_util.parse_repository_dependency_tuple(rd_tup)
# If only_if_compiling_contained_td is False, then the repository dependency
# is not required to be installed prior to the dependent repository even if
# prior_installation_required is True. This is because the only meaningful
# content of the repository dependency is its contained tool dependency, which
# is required in order to compile the dependent repository's tool dependency.
# In the scenario where the repository dependency is not installed prior to the
# dependent repository's tool dependency compilation process, the tool dependency
# compilation framework will install the repository dependency prior to compilation
# of the dependent repository's tool dependency.
if not util.asbool(only_if_compiling_contained_td):
if util.asbool(prior_installation_required):
if is_tool_shed_client(app):
# We store the port, if one exists, in the database.
tool_shed = common_util.remove_protocol_from_tool_shed_url(
tool_shed)
repository = get_repository_for_dependency_relationship(
app, tool_shed, name, owner,
changeset_revision)
else:
repository = get_repository_by_name_and_owner(
app, name, owner)
if repository:
encoded_repository_id = app.security.encode_id(
repository.id)
if encoded_repository_id in tsr_ids:
prior_tsr_ids.append(encoded_repository_id)
return prior_tsr_ids
def can_eliminate_repository_dependency(metadata_dict, tool_shed_url, name,
owner):
"""
Determine if the relationship between a repository_dependency record
associated with a tool_shed_repository record on the Galaxy side
can be eliminated.
"""
rd_dict = metadata_dict.get('repository_dependencies', {})
rd_tups = rd_dict.get('repository_dependencies', [])
for rd_tup in rd_tups:
tsu, n, o, none1, none2, none3 = common_util.parse_repository_dependency_tuple(
rd_tup)
if tsu == tool_shed_url and n == name and o == owner:
# The repository dependency is current, so keep it.
return False
return True
def get_repository_dependency_tups_from_repository_metadata(
app, repository_metadata, deprecated_only=False):
"""
Return a list of of tuples defining repository objects required by the received repository. The returned
list defines the entire repository dependency tree. This method is called only from the Tool Shed.
"""
dependency_tups = []
if repository_metadata is not None:
metadata = repository_metadata.metadata
if metadata:
repository_dependencies_dict = metadata.get(
'repository_dependencies', None)
if repository_dependencies_dict is not None:
repository_dependency_tups = repository_dependencies_dict.get(
'repository_dependencies', None)
if repository_dependency_tups is not None:
# The value of repository_dependency_tups is a list of repository dependency tuples like this:
# ['http://localhost:9009', 'package_samtools_0_1_18', 'devteam', 'ef37fc635cb9', 'False', 'False']
for repository_dependency_tup in repository_dependency_tups:
toolshed, name, owner, changeset_revision, pir, oicct = \
parse_repository_dependency_tuple(repository_dependency_tup)
repository = get_repository_by_name_and_owner(
app, name, owner)
if repository:
if deprecated_only:
if repository.deprecated:
dependency_tups.append(
repository_dependency_tup)
else:
dependency_tups.append(
repository_dependency_tup)
else:
log.debug(
"Cannot locate repository %s owned by %s for inclusion in repository dependency tups."
% (name, owner))
return dependency_tups
def build_repository_dependency_relationships(self, repo_info_dicts,
tool_shed_repositories):
"""
Build relationships between installed tool shed repositories and other installed
tool shed repositories upon which they depend. These relationships are defined in
the repository_dependencies entry for each dictionary in the received list of repo_info_dicts.
Each of these dictionaries is associated with a repository in the received tool_shed_repositories
list.
"""
install_model = self.app.install_model
log.debug("Building repository dependency relationships...")
for repo_info_dict in repo_info_dicts:
for name, repo_info_tuple in repo_info_dict.items():
description, \
repository_clone_url, \
changeset_revision, \
ctx_rev, \
repository_owner, \
repository_dependencies, \
tool_dependencies = \
repository_util.get_repo_info_tuple_contents(repo_info_tuple)
if repository_dependencies:
for key, val in repository_dependencies.items():
if key in ['root_key', 'description']:
continue
d_repository = None
repository_components_tuple = get_components_from_key(
key)
components_list = repository_util.extract_components_from_tuple(
repository_components_tuple)
d_toolshed, d_name, d_owner, d_changeset_revision = components_list[
0:4]
for tsr in tool_shed_repositories:
# Get the the tool_shed_repository defined by name, owner and changeset_revision. This is
# the repository that will be dependent upon each of the tool shed repositories contained in
# val. We'll need to check tool_shed_repository.tool_shed as well if/when repository dependencies
# across tool sheds is supported.
if tsr.name == d_name and tsr.owner == d_owner and tsr.changeset_revision == d_changeset_revision:
d_repository = tsr
break
if d_repository is None:
# The dependent repository is not in the received list so look in the database.
d_repository = self.get_or_create_tool_shed_repository(
d_toolshed, d_name, d_owner,
d_changeset_revision)
# Process each repository_dependency defined for the current dependent repository.
for repository_dependency_components_list in val:
required_repository = None
rd_toolshed, \
rd_name, \
rd_owner, \
rd_changeset_revision, \
rd_prior_installation_required, \
rd_only_if_compiling_contained_td = \
common_util.parse_repository_dependency_tuple(repository_dependency_components_list)
# Get the the tool_shed_repository defined by rd_name, rd_owner and rd_changeset_revision. This
# is the repository that will be required by the current d_repository.
# TODO: Check tool_shed_repository.tool_shed as well when repository dependencies across tool sheds is supported.
for tsr in tool_shed_repositories:
if tsr.name == rd_name and tsr.owner == rd_owner and tsr.changeset_revision == rd_changeset_revision:
required_repository = tsr
break
if required_repository is None:
# The required repository is not in the received list so look in the database.
required_repository = self.get_or_create_tool_shed_repository(
rd_toolshed, rd_name, rd_owner,
rd_changeset_revision)
# Ensure there is a repository_dependency relationship between d_repository and required_repository.
rrda = None
for rd in d_repository.repository_dependencies:
if rd.id == required_repository.id:
rrda = rd
break
if not rrda:
# Make sure required_repository is in the repository_dependency table.
repository_dependency = self.get_repository_dependency_by_repository_id(
install_model, required_repository.id)
if not repository_dependency:
log.debug(
'Creating new repository_dependency record for installed revision %s of repository: %s owned by %s.',
required_repository.
installed_changeset_revision,
required_repository.name,
required_repository.owner)
repository_dependency = install_model.RepositoryDependency(
tool_shed_repository_id=
required_repository.id)
install_model.context.add(
repository_dependency)
install_model.context.flush()
# Build the relationship between the d_repository and the required_repository.
rrda = install_model.RepositoryRepositoryDependencyAssociation(
tool_shed_repository_id=d_repository.id,
repository_dependency_id=
repository_dependency.id)
install_model.context.add(rrda)
install_model.context.flush()
