Exemple #1
0
def create_tool_dependency_objects(app,
                                   tool_shed_repository,
                                   relative_install_dir,
                                   set_status=True):
    """Create or update a ToolDependency for each entry in tool_dependencies_config.  This method is called when installing a new tool_shed_repository."""
    tool_dependency_objects = []
    shed_config_dict = tool_shed_repository.get_shed_config_dict(app)
    if shed_config_dict.get('tool_path'):
        relative_install_dir = os.path.join(shed_config_dict.get('tool_path'),
                                            relative_install_dir)
    # Get the tool_dependencies.xml file from the repository.
    tool_dependencies_config = suc.get_config_from_disk(
        'tool_dependencies.xml', relative_install_dir)
    tree, error_message = xml_util.parse_xml(tool_dependencies_config)
    if tree is None:
        return tool_dependency_objects
    root = tree.getroot()
    fabric_version_checked = False
    for elem in root:
        tool_dependency_type = elem.tag
        if tool_dependency_type == 'package':
            name = elem.get('name', None)
            version = elem.get('version', None)
            if name and version:
                tool_dependency = create_or_update_tool_dependency(
                    app,
                    tool_shed_repository,
                    name=name,
                    version=version,
                    type=tool_dependency_type,
                    status=app.model.ToolDependency.installation_status.
                    NEVER_INSTALLED,
                    set_status=set_status)
                tool_dependency_objects.append(tool_dependency)
        elif tool_dependency_type == 'set_environment':
            for env_elem in elem:
                # <environment_variable name="R_SCRIPT_PATH" action="set_to">$REPOSITORY_INSTALL_DIR</environment_variable>
                name = env_elem.get('name', None)
                action = env_elem.get('action', None)
                if name and action:
                    tool_dependency = create_or_update_tool_dependency(
                        app,
                        tool_shed_repository,
                        name=name,
                        version=None,
                        type=tool_dependency_type,
                        status=app.model.ToolDependency.installation_status.
                        NEVER_INSTALLED,
                        set_status=set_status)
                    tool_dependency_objects.append(tool_dependency)
    return tool_dependency_objects
def create_tool_dependency_objects( app, tool_shed_repository, relative_install_dir, set_status=True ):
    """
    Create or update a ToolDependency for each entry in tool_dependencies_config.  This method is called when
    installing a new tool_shed_repository.
    """
    tool_dependency_objects = []
    shed_config_dict = tool_shed_repository.get_shed_config_dict( app )
    if shed_config_dict.get( 'tool_path' ):
        relative_install_dir = os.path.join( shed_config_dict.get( 'tool_path' ), relative_install_dir )
    # Get the tool_dependencies.xml file from the repository.
    tool_dependencies_config = suc.get_config_from_disk( 'tool_dependencies.xml', relative_install_dir )
    tree, error_message = xml_util.parse_xml( tool_dependencies_config )
    if tree is None:
        return tool_dependency_objects
    root = tree.getroot()
    fabric_version_checked = False
    for elem in root:
        tool_dependency_type = elem.tag
        if tool_dependency_type == 'package':
            name = elem.get( 'name', None )
            version = elem.get( 'version', None )
            if name and version:
                status = app.install_model.ToolDependency.installation_status.NEVER_INSTALLED
                tool_dependency = create_or_update_tool_dependency( app,
                                                                    tool_shed_repository,
                                                                    name=name,
                                                                    version=version,
                                                                    type=tool_dependency_type,
                                                                    status=status,
                                                                    set_status=set_status )
                tool_dependency_objects.append( tool_dependency )
        elif tool_dependency_type == 'set_environment':
            for env_elem in elem:
                # <environment_variable name="R_SCRIPT_PATH" action="set_to">$REPOSITORY_INSTALL_DIR</environment_variable>
                name = env_elem.get( 'name', None )
                action = env_elem.get( 'action', None )
                if name and action:
                    status = app.install_model.ToolDependency.installation_status.NEVER_INSTALLED
                    tool_dependency = create_or_update_tool_dependency( app,
                                                                        tool_shed_repository,
                                                                        name=name,
                                                                        version=None,
                                                                        type=tool_dependency_type,
                                                                        status=status,
                                                                        set_status=set_status )
                    tool_dependency_objects.append( tool_dependency )
    return tool_dependency_objects
def load_installed_datatypes( app, repository, relative_install_dir, deactivate=False ):
    # Load proprietary datatypes and return information needed for loading proprietary datatypes converters and display applications later.
    metadata = repository.metadata
    repository_dict = None
    datatypes_config = suc.get_config_from_disk( suc.DATATYPES_CONFIG_FILENAME, relative_install_dir )
    if datatypes_config:
        converter_path, display_path = alter_config_and_load_prorietary_datatypes( app, datatypes_config, relative_install_dir, deactivate=deactivate )
        if converter_path or display_path:
            # Create a dictionary of tool shed repository related information.
            repository_dict = create_repository_dict_for_proprietary_datatypes( tool_shed=repository.tool_shed,
                                                                                name=repository.name,
                                                                                owner=repository.owner,
                                                                                installed_changeset_revision=repository.installed_changeset_revision,
                                                                                tool_dicts=metadata.get( 'tools', [] ),
                                                                                converter_path=converter_path,
                                                                                display_path=display_path )
    return repository_dict
Exemple #4
0
def load_installed_datatypes(app,
                             repository,
                             relative_install_dir,
                             deactivate=False):
    # Load proprietary datatypes and return information needed for loading proprietary datatypes converters and display applications later.
    metadata = repository.metadata
    repository_dict = None
    datatypes_config = suc.get_config_from_disk(suc.DATATYPES_CONFIG_FILENAME,
                                                relative_install_dir)
    if datatypes_config:
        converter_path, display_path = alter_config_and_load_prorietary_datatypes(
            app, datatypes_config, relative_install_dir, deactivate=deactivate)
        if converter_path or display_path:
            # Create a dictionary of tool shed repository related information.
            repository_dict = create_repository_dict_for_proprietary_datatypes(
                tool_shed=repository.tool_shed,
                name=repository.name,
                owner=repository.owner,
                installed_changeset_revision=repository.
                installed_changeset_revision,
                tool_dicts=metadata.get('tools', []),
                converter_path=converter_path,
                display_path=display_path)
    return repository_dict
             tool_util.add_to_tool_panel( self.app,
                                          tool_shed_repository.name,
                                          repository_clone_url,
                                          tool_shed_repository.installed_changeset_revision,
                                          repository_tools_tups,
                                          self.repository_owner,
                                          self.migrated_tools_config,
                                          tool_panel_dict=tool_panel_dict_for_display,
                                          new_install=True )
 if install_dependencies and tool_dependencies and has_tool_dependencies:
     # Install tool dependencies.
     suc.update_tool_shed_repository_status( self.app,
                                             tool_shed_repository,
                                             self.app.install_model.ToolShedRepository.installation_status.INSTALLING_TOOL_DEPENDENCIES )
     # Get the tool_dependencies.xml file from disk.
     tool_dependencies_config = suc.get_config_from_disk( 'tool_dependencies.xml', repo_install_dir )
     installed_tool_dependencies = common_install_util.handle_tool_dependencies( app=self.app,
                                                                                 tool_shed_repository=tool_shed_repository,
                                                                                 tool_dependencies_config=tool_dependencies_config,
                                                                                 tool_dependencies=tool_dependencies,
                                                                                 from_install_manager=True )
     for installed_tool_dependency in installed_tool_dependencies:
         if installed_tool_dependency.status == self.app.install_model.ToolDependency.installation_status.ERROR:
             print '\nThe following error occurred from the InstallManager while installing tool dependency ', installed_tool_dependency.name, ':'
             print installed_tool_dependency.error_message, '\n\n'
 if 'datatypes' in metadata_dict:
     tool_shed_repository.status = self.app.install_model.ToolShedRepository.installation_status.LOADING_PROPRIETARY_DATATYPES
     if not tool_shed_repository.includes_datatypes:
         tool_shed_repository.includes_datatypes = True
     self.app.install_model.context.add( tool_shed_repository )
     self.app.install_model.context.flush()
Exemple #6
0
 def handle_repository_contents( self, tool_shed_repository, repository_clone_url, relative_install_dir, repository_elem, install_dependencies ):
     """Generate the metadata for the installed tool shed repository, among other things."""
     tool_panel_dict_for_display = odict()
     if self.tool_path:
         repo_install_dir = os.path.join( self.tool_path, relative_install_dir )
     else:
         repo_install_dir = relative_install_dir
     for tool_elem in repository_elem:
         # The tool_elem looks something like this: <tool id="EMBOSS: antigenic1" version="5.0.0" file="emboss_antigenic.xml" />
         tool_config = tool_elem.get( 'file' )
         guid = self.get_guid( repository_clone_url, relative_install_dir, tool_config )
         # See if tool_config is defined inside of a section in self.proprietary_tool_panel_elems.
         is_displayed, tool_sections = self.get_containing_tool_sections( tool_config )
         if is_displayed:
             tool_panel_dict_for_tool_config = tool_util.generate_tool_panel_dict_for_tool_config( guid, tool_config, tool_sections=tool_sections )
             for k, v in tool_panel_dict_for_tool_config.items():
                 tool_panel_dict_for_display[ k ] = v
         else:
             print 'The tool "%s" (%s) has not been enabled because it is not defined in a proprietary tool config (%s).' \
             % ( guid, tool_config, ", ".join( self.proprietary_tool_confs or [] ) )
     metadata_dict, invalid_file_tups = metadata_util.generate_metadata_for_changeset_revision( app=self.app,
                                                                                                repository=tool_shed_repository,
                                                                                                changeset_revision=tool_shed_repository.changeset_revision,
                                                                                                repository_clone_url=repository_clone_url,
                                                                                                shed_config_dict = self.shed_config_dict,
                                                                                                relative_install_dir=relative_install_dir,
                                                                                                repository_files_dir=None,
                                                                                                resetting_all_metadata_on_repository=False,
                                                                                                updating_installed_repository=False,
                                                                                                persist=True )
     tool_shed_repository.metadata = metadata_dict
     self.app.sa_session.add( tool_shed_repository )
     self.app.sa_session.flush()
     if 'tool_dependencies' in metadata_dict:
         # All tool_dependency objects must be created before the tools are processed even if no tool dependencies will be installed.
         tool_dependencies = tool_dependency_util.create_tool_dependency_objects( self.app, tool_shed_repository, relative_install_dir, set_status=True )
     else:
         tool_dependencies = None
     if 'tools' in metadata_dict:
         sample_files = metadata_dict.get( 'sample_files', [] )
         sample_files = [ str( s ) for s in sample_files ]
         tool_index_sample_files = tool_util.get_tool_index_sample_files( sample_files )
         tool_util.copy_sample_files( self.app, tool_index_sample_files, tool_path=self.tool_path )
         sample_files_copied = [ s for s in tool_index_sample_files ]
         repository_tools_tups = suc.get_repository_tools_tups( self.app, metadata_dict )
         if repository_tools_tups:
             # Handle missing data table entries for tool parameters that are dynamically generated select lists.
             repository_tools_tups = tool_util.handle_missing_data_table_entry( self.app, relative_install_dir, self.tool_path, repository_tools_tups )
             # Handle missing index files for tool parameters that are dynamically generated select lists.
             repository_tools_tups, sample_files_copied = tool_util.handle_missing_index_file( self.app,
                                                                                               self.tool_path,
                                                                                               sample_files,
                                                                                               repository_tools_tups,
                                                                                               sample_files_copied )
             # Copy remaining sample files included in the repository to the ~/tool-data directory of the local Galaxy instance.
             tool_util.copy_sample_files( self.app, sample_files, tool_path=self.tool_path, sample_files_copied=sample_files_copied )
             if install_dependencies and tool_dependencies and 'tool_dependencies' in metadata_dict:
                 # Install tool dependencies.
                 suc.update_tool_shed_repository_status( self.app,
                                                         tool_shed_repository,
                                                         self.app.model.ToolShedRepository.installation_status.INSTALLING_TOOL_DEPENDENCIES )
                 # Get the tool_dependencies.xml file from disk.
                 tool_dependencies_config = suc.get_config_from_disk( 'tool_dependencies.xml', repo_install_dir )
                 installed_tool_dependencies = common_install_util.handle_tool_dependencies( app=self.app,
                                                                                             tool_shed_repository=tool_shed_repository,
                                                                                             tool_dependencies_config=tool_dependencies_config,
                                                                                             tool_dependencies=tool_dependencies )
                 for installed_tool_dependency in installed_tool_dependencies:
                     if installed_tool_dependency.status == self.app.model.ToolDependency.installation_status.ERROR:
                         print '\nThe following error occurred from the InstallManager while installing tool dependency ', installed_tool_dependency.name, ':'
                         print installed_tool_dependency.error_message, '\n\n'
             tool_util.add_to_tool_panel( self.app,
                                          tool_shed_repository.name,
                                          repository_clone_url,
                                          tool_shed_repository.installed_changeset_revision,
                                          repository_tools_tups,
                                          self.repository_owner,
                                          self.migrated_tools_config,
                                          tool_panel_dict=tool_panel_dict_for_display,
                                          new_install=True )
     if 'datatypes' in metadata_dict:
         tool_shed_repository.status = self.app.model.ToolShedRepository.installation_status.LOADING_PROPRIETARY_DATATYPES
         if not tool_shed_repository.includes_datatypes:
             tool_shed_repository.includes_datatypes = True
         self.app.sa_session.add( tool_shed_repository )
         self.app.sa_session.flush()
         work_dir = tempfile.mkdtemp( prefix="tmp-toolshed-hrc" )
         datatypes_config = suc.get_config_from_disk( suc.DATATYPES_CONFIG_FILENAME, repo_install_dir )
         # Load proprietary data types required by tools.  The value of override is not important here since the Galaxy server will be started
         # after this installation completes.
         converter_path, display_path = datatype_util.alter_config_and_load_prorietary_datatypes( self.app, datatypes_config, repo_install_dir, override=False ) #repo_install_dir was relative_install_dir
         if converter_path or display_path:
             # Create a dictionary of tool shed repository related information.
             repository_dict = datatype_util.create_repository_dict_for_proprietary_datatypes( tool_shed=self.tool_shed,
                                                                                               name=tool_shed_repository.name,
                                                                                               owner=self.repository_owner,
                                                                                               installed_changeset_revision=tool_shed_repository.installed_changeset_revision,
                                                                                               tool_dicts=metadata_dict.get( 'tools', [] ),
                                                                                               converter_path=converter_path,
                                                                                               display_path=display_path )
         if converter_path:
             # Load proprietary datatype converters
             self.app.datatypes_registry.load_datatype_converters( self.toolbox, installed_repository_dict=repository_dict )
         if display_path:
             # Load proprietary datatype display applications
             self.app.datatypes_registry.load_display_applications( installed_repository_dict=repository_dict )
         try:
             shutil.rmtree( work_dir )
         except:
             pass