示例#1
0
    def __api_import_new_workflow(self, trans, payload, **kwd):
        data = payload['workflow']
        raw_workflow_description = self.__normalize_workflow(trans, data)
        data = raw_workflow_description.as_dict
        import_tools = util.string_as_bool(payload.get("import_tools", False))
        if import_tools and not trans.user_is_admin:
            raise exceptions.AdminRequiredException()

        from_dict_kwds = self.__import_or_update_kwds(payload)

        publish = util.string_as_bool(payload.get("publish", False))
        # If 'publish' set, default to importable.
        importable = util.string_as_bool(payload.get("importable", publish))

        if publish and not importable:
            raise exceptions.RequestParameterInvalidException("Published workflow must be importable.")

        from_dict_kwds["publish"] = publish
        workflow, missing_tool_tups = self._workflow_from_dict(trans, raw_workflow_description, **from_dict_kwds)
        if importable:
            self._make_item_accessible(trans.sa_session, workflow)
            trans.sa_session.flush()
        # galaxy workflow newly created id
        workflow_id = workflow.id
        # api encoded, id
        encoded_id = trans.security.encode_id(workflow_id)
        item = workflow.to_dict(value_mapper={'id': trans.security.encode_id})
        item['annotations'] = [x.annotation for x in workflow.annotations]
        item['url'] = url_for('workflow', id=encoded_id)
        item['owner'] = workflow.user.username
        item['number_of_steps'] = len(workflow.latest_workflow.steps)
        if import_tools:
            tools = {}
            for key in data['steps']:
                item = data['steps'][key]
                if item is not None:
                    if 'tool_shed_repository' in item:
                        tool_shed_repository = item['tool_shed_repository']
                        if 'owner' in tool_shed_repository and 'changeset_revision' in tool_shed_repository and 'name' in tool_shed_repository and 'tool_shed' in tool_shed_repository:
                            toolstr = tool_shed_repository['owner'] \
                                + tool_shed_repository['changeset_revision'] \
                                + tool_shed_repository['name'] \
                                + tool_shed_repository['tool_shed']
                            tools[toolstr] = tool_shed_repository
            irm = InstallRepositoryManager(self.app)
            for k in tools:
                item = tools[k]
                tool_shed_url = 'https://' + item['tool_shed'] + '/'
                name = item['name']
                owner = item['owner']
                changeset_revision = item['changeset_revision']
                irm.install(tool_shed_url,
                            name,
                            owner,
                            changeset_revision,
                            payload)
        return item
示例#2
0
    def __api_import_new_workflow(self, trans, payload, **kwd):
        data = payload['workflow']
        raw_workflow_description = self.__normalize_workflow(trans, data)
        data = raw_workflow_description.as_dict
        import_tools = util.string_as_bool(payload.get("import_tools", False))
        if import_tools and not trans.user_is_admin:
            raise exceptions.AdminRequiredException()

        from_dict_kwds = self.__import_or_update_kwds(payload)

        publish = util.string_as_bool(payload.get("publish", False))
        # If 'publish' set, default to importable.
        importable = util.string_as_bool(payload.get("importable", publish))

        if publish and not importable:
            raise exceptions.RequestParameterInvalidException("Published workflow must be importable.")

        from_dict_kwds["publish"] = publish
        workflow, missing_tool_tups = self._workflow_from_dict(trans, raw_workflow_description, **from_dict_kwds)
        if importable:
            self._make_item_accessible(trans.sa_session, workflow)
            trans.sa_session.flush()
        # galaxy workflow newly created id
        workflow_id = workflow.id
        # api encoded, id
        encoded_id = trans.security.encode_id(workflow_id)
        item = workflow.to_dict(value_mapper={'id': trans.security.encode_id})
        item['url'] = url_for('workflow', id=encoded_id)
        item['owner'] = workflow.user.username
        item['number_of_steps'] = len(workflow.latest_workflow.steps)
        if import_tools:
            tools = {}
            for key in data['steps']:
                item = data['steps'][key]
                if item is not None:
                    if 'tool_shed_repository' in item:
                        tool_shed_repository = item['tool_shed_repository']
                        if 'owner' in tool_shed_repository and 'changeset_revision' in tool_shed_repository and 'name' in tool_shed_repository and 'tool_shed' in tool_shed_repository:
                            toolstr = tool_shed_repository['owner'] \
                                + tool_shed_repository['changeset_revision'] \
                                + tool_shed_repository['name'] \
                                + tool_shed_repository['tool_shed']
                            tools[toolstr] = tool_shed_repository
            irm = InstallRepositoryManager(self.app)
            for k in tools:
                item = tools[k]
                tool_shed_url = 'https://' + item['tool_shed'] + '/'
                name = item['name']
                owner = item['owner']
                changeset_revision = item['changeset_revision']
                irm.install(tool_shed_url,
                            name,
                            owner,
                            changeset_revision,
                            payload)
        return item
示例#3
0
    def install_repository_revision(self, trans, payload, **kwd):
        """
        POST /api/tool_shed_repositories/install_repository_revision
        Install a specified repository revision from a specified tool shed into Galaxy.

        :param key: the current Galaxy admin user's API key

        The following parameters are included in the payload.
        :param tool_shed_url (required): the base URL of the Tool Shed from which to install the Repository
        :param name (required): the name of the Repository
        :param owner (required): the owner of the Repository
        :param changeset_revision (required): the changeset_revision of the RepositoryMetadata object associated with the Repository
        :param new_tool_panel_section_label (optional): label of a new section to be added to the Galaxy tool panel in which to load
                                                        tools contained in the Repository.  Either this parameter must be an empty string or
                                                        the tool_panel_section_id parameter must be an empty string or both must be an empty
                                                        string (both cannot be used simultaneously).
        :param tool_panel_section_id (optional): id of the Galaxy tool panel section in which to load tools contained in the Repository.
                                                 If this parameter is an empty string and the above new_tool_panel_section_label parameter is an
                                                 empty string, tools will be loaded outside of any sections in the tool panel.  Either this
                                                 parameter must be an empty string or the tool_panel_section_id parameter must be an empty string
                                                 of both must be an empty string (both cannot be used simultaneously).
        :param install_repository_dependencies (optional): Set to True if you want to install repository dependencies defined for the specified
                                                           repository being installed.  The default setting is False.
        :param install_tool_dependencies (optional): Set to True if you want to install tool dependencies defined for the specified repository being
                                                     installed.  The default setting is False.
        :param shed_tool_conf (optional): The shed-related tool panel configuration file configured in the "tool_config_file" setting in the Galaxy config file
                                          (e.g., galaxy.ini).  At least one shed-related tool panel config file is required to be configured. Setting
                                          this parameter to a specific file enables you to choose where the specified repository will be installed because
                                          the tool_path attribute of the <toolbox> from the specified file is used as the installation location
                                          (e.g., <toolbox tool_path="database/shed_tools">).  If this parameter is not set, a shed-related tool panel
                                          configuration file will be selected automatically.
        """
        # Get the information about the repository to be installed from the payload.
        tool_shed_url, name, owner, changeset_revision = self.__parse_repository_from_payload(
            payload, include_changeset=True)
        self.__ensure_can_install_repos(trans)
        irm = InstallRepositoryManager(self.app)
        installed_tool_shed_repositories = irm.install(tool_shed_url, name,
                                                       owner,
                                                       changeset_revision,
                                                       payload)

        def to_dict(tool_shed_repository):
            tool_shed_repository_dict = tool_shed_repository.as_dict(
                value_mapper=self.__get_value_mapper(trans,
                                                     tool_shed_repository))
            tool_shed_repository_dict['url'] = web.url_for(
                controller='tool_shed_repositories',
                action='show',
                id=trans.security.encode_id(tool_shed_repository.id))
            return tool_shed_repository_dict

        if installed_tool_shed_repositories:
            return list(map(to_dict, installed_tool_shed_repositories))
        message = "No repositories were installed, possibly because the selected repository has already been installed."
        return dict(status="ok", message=message)
示例#4
0
    def install_repository_revision( self, trans, payload, **kwd ):
        """
        POST /api/tool_shed_repositories/install_repository_revision
        Install a specified repository revision from a specified tool shed into Galaxy.

        :param key: the current Galaxy admin user's API key

        The following parameters are included in the payload.
        :param tool_shed_url (required): the base URL of the Tool Shed from which to install the Repository
        :param name (required): the name of the Repository
        :param owner (required): the owner of the Repository
        :param changeset_revision (required): the changeset_revision of the RepositoryMetadata object associated with the Repository
        :param new_tool_panel_section_label (optional): label of a new section to be added to the Galaxy tool panel in which to load
                                                        tools contained in the Repository.  Either this parameter must be an empty string or
                                                        the tool_panel_section_id parameter must be an empty string or both must be an empty
                                                        string (both cannot be used simultaneously).
        :param tool_panel_section_id (optional): id of the Galaxy tool panel section in which to load tools contained in the Repository.
                                                 If this parameter is an empty string and the above new_tool_panel_section_label parameter is an
                                                 empty string, tools will be loaded outside of any sections in the tool panel.  Either this
                                                 parameter must be an empty string or the tool_panel_section_id parameter must be an empty string
                                                 of both must be an empty string (both cannot be used simultaneously).
        :param install_repository_dependencies (optional): Set to True if you want to install repository dependencies defined for the specified
                                                           repository being installed.  The default setting is False.
        :param install_tool_dependencies (optional): Set to True if you want to install tool dependencies defined for the specified repository being
                                                     installed.  The default setting is False.
        :param shed_tool_conf (optional): The shed-related tool panel configuration file configured in the "tool_config_file" setting in the Galaxy config file
                                          (e.g., galaxy.ini).  At least one shed-related tool panel config file is required to be configured. Setting
                                          this parameter to a specific file enables you to choose where the specified repository will be installed because
                                          the tool_path attribute of the <toolbox> from the specified file is used as the installation location
                                          (e.g., <toolbox tool_path="../shed_tools">).  If this parameter is not set, a shed-related tool panel configuration
                                          file will be selected automatically.
        """
        # Get the information about the repository to be installed from the payload.
        tool_shed_url, name, owner, changeset_revision = self.__parse_repository_from_payload( payload, include_changeset=True )
        self.__ensure_can_install_repos( trans )
        irm = InstallRepositoryManager( self.app )
        installed_tool_shed_repositories = irm.install( tool_shed_url,
                                                        name,
                                                        owner,
                                                        changeset_revision,
                                                        payload )

        def to_dict( tool_shed_repository ):
            tool_shed_repository_dict = tool_shed_repository.as_dict( value_mapper=self.__get_value_mapper( trans, tool_shed_repository ) )
            tool_shed_repository_dict[ 'url' ] = web.url_for( controller='tool_shed_repositories',
                                                              action='show',
                                                              id=trans.security.encode_id( tool_shed_repository.id ) )
            return tool_shed_repository_dict
        if installed_tool_shed_repositories:
            return map( to_dict, installed_tool_shed_repositories )
        message = "No repositories were installed, possibly because the selected repository has already been installed."
        return dict( status="ok", message=message )
    def install(self, trans, **kwd):
        """
        POST /api/tool_shed_repositories/install
        Initiate the installation of a repository.

        :param install_tool_dependencies: True to install tool dependencies.
        :param install_repository_dependencies: True to install repository dependencies.
        :param tool_panel_section_id: The unique identifier for an existing tool panel section
        :param new_tool_panel_section_label: Create a new tool panel section with this label
        :param shed_tool_conf: The shed tool config file to use for this installation
        :param tool_shed_url: The URL for the toolshed whence this repository is being installed
        :param changeset: The changeset to update to after cloning the repository
        """
        params = dict()
        irm = InstallRepositoryManager(self.app)
        changeset = kwd.get('changeset', None)
        tool_shed_url = kwd.get('tool_shed_url', None)
        params['name'] = kwd.get('name', None)
        params['owner'] = kwd.get('owner', None)
        params['tool_panel_section_id'] = kwd.get('tool_panel_section_id',
                                                  None)
        params['new_tool_panel_section_label'] = kwd.get(
            'new_tool_panel_section', None)
        params['tool_panel_section_mapping'] = json.loads(
            kwd.get('tool_panel_section', '{}'))
        params['install_tool_dependencies'] = util.asbool(
            kwd.get('install_tool_dependencies', False))
        params['install_repository_dependencies'] = util.asbool(
            kwd.get('install_repository_dependencies', False))
        params['shed_tool_conf'] = kwd.get('shed_tool_conf', None)
        params['tool_path'] = suc.get_tool_path_by_shed_tool_conf_filename(
            self.app, params['shed_tool_conf'])
        try:
            tool_shed_repositories = irm.install(tool_shed_url, params['name'],
                                                 params['owner'], changeset,
                                                 params)
            if tool_shed_repositories is None:
                message = "No repositories were installed, possibly because the selected repository has already been installed."
                return dict(status="ok", message=message)
            tsr_ids_for_monitoring = [
                trans.security.encode_id(tsr.id)
                for tsr in tool_shed_repositories
            ]
            url = web.url_for(
                controller='admin_toolshed',
                action='monitor_repository_installation',
                tool_shed_repository_ids=','.join(tsr_ids_for_monitoring))
            return url
        except RepositoriesInstalledException as e:
            log.exception(e)
            return dict(message=e.message, status='error')
    def install( self, trans, **kwd ):
        """
        POST /api/tool_shed_repositories/install
        Initiate the installation of a repository.

        :param install_resolver_dependencies: True to install resolvable dependencies.
        :param install_tool_dependencies: True to install tool dependencies.
        :param install_repository_dependencies: True to install repository dependencies.
        :param tool_panel_section_id: The unique identifier for an existing tool panel section
        :param new_tool_panel_section_label: Create a new tool panel section with this label
        :param shed_tool_conf: The shed tool config file to use for this installation
        :param tool_shed_url: The URL for the toolshed whence this repository is being installed
        :param changeset: The changeset to update to after cloning the repository
        """
        params = dict()
        irm = InstallRepositoryManager( self.app )
        changeset = kwd.get( 'changeset', None )
        tool_shed_url = kwd.get( 'tool_shed_url', None )
        params[ 'name' ] = kwd.get( 'name', None )
        params[ 'owner' ] = kwd.get( 'owner', None )
        params[ 'tool_panel_section_id' ] = kwd.get( 'tool_panel_section_id', None )
        params[ 'new_tool_panel_section_label' ] = kwd.get( 'new_tool_panel_section', None )
        params[ 'tool_panel_section_mapping' ] = json.loads( kwd.get( 'tool_panel_section', '{}' ) )
        params[ 'install_resolver_dependencies' ] = util.asbool( kwd.get( 'install_resolver_dependencies', False ) )
        params[ 'install_tool_dependencies' ] = util.asbool( kwd.get( 'install_tool_dependencies', False ) )
        params[ 'install_repository_dependencies' ] = util.asbool( kwd.get( 'install_repository_dependencies', False ) )
        params[ 'shed_tool_conf' ] = kwd.get( 'shed_tool_conf', None )
        params[ 'tool_path' ] = suc.get_tool_path_by_shed_tool_conf_filename( self.app, params[ 'shed_tool_conf' ] )
        try:
            tool_shed_repositories = irm.install(
                tool_shed_url,
                params[ 'name' ],
                params[ 'owner' ],
                changeset,
                params
            )
            if tool_shed_repositories is None:
                message = "No repositories were installed, possibly because the selected repository has already been installed."
                return dict( status="ok", message=message )
            tsr_ids_for_monitoring = [ trans.security.encode_id( tsr.id ) for tsr in tool_shed_repositories ]
            url = web.url_for( controller='admin_toolshed', action='monitor_repository_installation', tool_shed_repository_ids=','.join( tsr_ids_for_monitoring ) )
            return url
        except RepositoriesInstalledException as e:
            log.exception( e )
            return dict( message=e.message,
                         status='error' )
示例#7
0
    def __api_import_new_workflow(self, trans, payload, **kwd):
        data = payload['workflow']

        import_tools = util.string_as_bool(payload.get("import_tools", False))
        if import_tools and not trans.user_is_admin():
            raise exceptions.AdminRequiredException()

        publish = util.string_as_bool(payload.get("publish", False))
        # If 'publish' set, default to importable.
        importable = util.string_as_bool(payload.get("importable", publish))
        # Galaxy will try to upgrade tool versions that don't match exactly during import,
        # this prevents that.
        exact_tools = util.string_as_bool(payload.get("exact_tools", False))

        if publish and not importable:
            raise exceptions.RequestParameterInvalidException("Published workflow must be importable.")

        from_dict_kwds = dict(
            source="API",
            publish=publish,
            exact_tools=exact_tools,
        )
        workflow, missing_tool_tups = self._workflow_from_dict(trans, data, **from_dict_kwds)

        if importable:
            self._make_item_accessible(trans.sa_session, workflow)
            trans.sa_session.flush()

        # galaxy workflow newly created id
        workflow_id = workflow.id
        # api encoded, id
        encoded_id = trans.security.encode_id(workflow_id)

        # return list
        rval = []

        item = workflow.to_dict(value_mapper={'id': trans.security.encode_id})
        item['url'] = url_for('workflow', id=encoded_id)
        item['owner'] = workflow.user.username
        item['number_of_steps'] = len(workflow.latest_workflow.steps)
        rval.append(item)

        #
        if import_tools:
            tools = {}
            for key in data['steps']:
                item = data['steps'][key]
                if item is not None:
                    if 'tool_shed_repository' in item:
                        tool_shed_repository = item['tool_shed_repository']
                        if 'owner' in tool_shed_repository and 'changeset_revision' in tool_shed_repository and 'name' in tool_shed_repository and 'tool_shed' in tool_shed_repository:
                            toolstr = tool_shed_repository['owner'] \
                                + tool_shed_repository['changeset_revision'] \
                                + tool_shed_repository['name'] \
                                + tool_shed_repository['tool_shed']
                            tools[toolstr] = tool_shed_repository
            irm = InstallRepositoryManager(self.app)
            for k in tools:
                item = tools[k]
                tool_shed_url = 'https://' + item['tool_shed'] + '/'
                name = item['name']
                owner = item['owner']
                changeset_revision = item['changeset_revision']
                irm.install(tool_shed_url,
                            name,
                            owner,
                            changeset_revision,
                            payload)
        return item
示例#8
0
    def install(self, trans, **kwd):
        """
        POST /api/tool_shed_repositories/install
        Initiate the installation of a repository.

        :param install_resolver_dependencies: True to install resolvable dependencies.
        :param install_tool_dependencies: True to install tool dependencies.
        :param install_repository_dependencies: True to install repository dependencies.
        :param tool_panel_section_id: The unique identifier for an existing tool panel section
        :param new_tool_panel_section_label: Create a new tool panel section with this label
        :param shed_tool_conf: The shed tool config file to use for this installation
        :param tool_shed_url: The URL for the toolshed whence this repository is being installed
        :param changeset: The changeset to update to after cloning the repository
        """
        irm = InstallRepositoryManager(self.app)
        tool_shed_url = kwd.get('tool_shed_url', None)
        repositories = json.loads(kwd.get('repositories', '[]'))
        repo_info_dict = self.__get_repo_info_dict(trans, repositories,
                                                   tool_shed_url)
        includes_tools = False
        includes_tools_for_display_in_tool_panel = False
        has_repository_dependencies = False
        includes_tool_dependencies = False
        install_resolver_dependencies = util.asbool(
            kwd.get('install_resolver_dependencies', False))
        for encoded_repo_info_dict in repo_info_dict.get(
                'repo_info_dicts', []):
            decoded_repo_info_dict = encoding_util.tool_shed_decode(
                encoded_repo_info_dict)
            if not includes_tools:
                includes_tools = util.string_as_bool(
                    decoded_repo_info_dict.get('includes_tools', False))
            if not includes_tools_for_display_in_tool_panel:
                includes_tools_for_display_in_tool_panel = \
                    util.string_as_bool( decoded_repo_info_dict.get( 'includes_tools_for_display_in_tool_panel', False ) )
            if not has_repository_dependencies:
                has_repository_dependencies = util.string_as_bool(
                    repo_info_dict.get('has_repository_dependencies', False))
            if not includes_tool_dependencies:
                includes_tool_dependencies = util.string_as_bool(
                    repo_info_dict.get('includes_tool_dependencies', False))
        encoded_repo_info_dicts = util.listify(
            repo_info_dict.get('repo_info_dicts', []))
        repo_info_dicts = [
            encoding_util.tool_shed_decode(encoded_repo_info_dict)
            for encoded_repo_info_dict in encoded_repo_info_dicts
        ]
        tool_panel_section_id = kwd.get('tool_panel_section_id', None)
        new_tool_panel_section_label = kwd.get('new_tool_panel_section', None)
        tool_panel_section_mapping = json.loads(
            kwd.get('tool_panel_section', '{}'))
        install_tool_dependencies = util.asbool(
            kwd.get('install_tool_dependencies', False))
        install_repository_dependencies = util.asbool(
            kwd.get('install_repository_dependencies', False))
        shed_tool_conf = kwd.get('shed_tool_conf', None)
        tool_path = suc.get_tool_path_by_shed_tool_conf_filename(
            self.app, shed_tool_conf)
        installation_dict = dict(
            install_repository_dependencies=install_repository_dependencies,
            new_tool_panel_section_label=new_tool_panel_section_label,
            no_changes_checked=False,
            repo_info_dicts=repo_info_dicts,
            tool_panel_section_id=tool_panel_section_id,
            tool_path=tool_path,
            tool_shed_url=tool_shed_url)
        new_repositories, tool_panel_keys, repo_info_dicts, filtered_repos = irm.handle_tool_shed_repositories(
            installation_dict)
        if new_repositories:
            installation_dict = dict(
                created_or_updated_tool_shed_repositories=new_repositories,
                filtered_repo_info_dicts=filtered_repos,
                has_repository_dependencies=has_repository_dependencies,
                includes_tool_dependencies=includes_tool_dependencies,
                includes_tools=includes_tools,
                includes_tools_for_display_in_tool_panel=
                includes_tools_for_display_in_tool_panel,
                install_repository_dependencies=install_repository_dependencies,
                install_tool_dependencies=install_tool_dependencies,
                message='',
                new_tool_panel_section_label=new_tool_panel_section_label,
                tool_panel_section_mapping=tool_panel_section_mapping,
                install_resolver_dependencies=install_resolver_dependencies,
                shed_tool_conf=shed_tool_conf,
                status='ok',
                tool_panel_section_id=tool_panel_section_id,
                tool_panel_section_keys=tool_panel_keys,
                tool_path=tool_path,
                tool_shed_url=tool_shed_url)
            encoded_kwd, query, tool_shed_repositories, encoded_repository_ids = \
                irm.initiate_repository_installation( installation_dict )
            return json.dumps(
                dict(
                    operation='install',
                    api=True,
                    install_resolver_dependencies=install_resolver_dependencies,
                    install_tool_dependencies=install_tool_dependencies,
                    encoded_kwd=encoded_kwd,
                    reinstalling=False,
                    tool_shed_repository_ids=json.dumps(
                        [repo[0] for repo in repositories]),
                    repositories=[
                        trans.security.encode_id(repo.id)
                        for repo in new_repositories
                    ]))
示例#9
0
    def install( self, trans, **kwd ):
        """
        POST /api/tool_shed_repositories/install
        Initiate the installation of a repository.

        :param install_resolver_dependencies: True to install resolvable dependencies.
        :param install_tool_dependencies: True to install tool dependencies.
        :param install_repository_dependencies: True to install repository dependencies.
        :param tool_panel_section_id: The unique identifier for an existing tool panel section
        :param new_tool_panel_section_label: Create a new tool panel section with this label
        :param shed_tool_conf: The shed tool config file to use for this installation
        :param tool_shed_url: The URL for the toolshed whence this repository is being installed
        :param changeset: The changeset to update to after cloning the repository
        """
        irm = InstallRepositoryManager( self.app )
        tool_shed_url = kwd.get( 'tool_shed_url', None )
        repositories = json.loads( kwd.get( 'repositories', '[]' ) )
        repo_info_dict = self.__get_repo_info_dict( trans, repositories, tool_shed_url )
        includes_tools = False
        includes_tools_for_display_in_tool_panel = False
        has_repository_dependencies = False
        includes_tool_dependencies = False
        install_resolver_dependencies = util.asbool( kwd.get( 'install_resolver_dependencies', False ) )
        for encoded_repo_info_dict in repo_info_dict.get( 'repo_info_dicts', [] ):
            decoded_repo_info_dict = encoding_util.tool_shed_decode( encoded_repo_info_dict )
            if not includes_tools:
                includes_tools = util.string_as_bool( decoded_repo_info_dict.get( 'includes_tools', False ) )
            if not includes_tools_for_display_in_tool_panel:
                includes_tools_for_display_in_tool_panel = \
                    util.string_as_bool( decoded_repo_info_dict.get( 'includes_tools_for_display_in_tool_panel', False ) )
            if not has_repository_dependencies:
                has_repository_dependencies = util.string_as_bool( repo_info_dict.get( 'has_repository_dependencies', False ) )
            if not includes_tool_dependencies:
                includes_tool_dependencies = util.string_as_bool( repo_info_dict.get( 'includes_tool_dependencies', False ) )
        encoded_repo_info_dicts = util.listify( repo_info_dict.get( 'repo_info_dicts', [] ) )
        repo_info_dicts = [ encoding_util.tool_shed_decode( encoded_repo_info_dict ) for encoded_repo_info_dict in encoded_repo_info_dicts ]
        tool_panel_section_id = kwd.get( 'tool_panel_section_id', None )
        new_tool_panel_section_label = kwd.get( 'new_tool_panel_section', None )
        tool_panel_section_mapping = json.loads( kwd.get( 'tool_panel_section', '{}' ) )
        install_tool_dependencies = util.asbool( kwd.get( 'install_tool_dependencies', False ) )
        install_repository_dependencies = util.asbool( kwd.get( 'install_repository_dependencies', False ) )
        shed_tool_conf = kwd.get( 'shed_tool_conf', None )
        tool_path = suc.get_tool_path_by_shed_tool_conf_filename( self.app, shed_tool_conf )
        installation_dict = dict( install_repository_dependencies=install_repository_dependencies,
                                  new_tool_panel_section_label=new_tool_panel_section_label,
                                  no_changes_checked=False,
                                  repo_info_dicts=repo_info_dicts,
                                  tool_panel_section_id=tool_panel_section_id,
                                  tool_path=tool_path,
                                  tool_shed_url=tool_shed_url )
        new_repositories, tool_panel_keys, repo_info_dicts, filtered_repos = irm.handle_tool_shed_repositories( installation_dict )
        if new_repositories:
            installation_dict = dict( created_or_updated_tool_shed_repositories=new_repositories,
                                      filtered_repo_info_dicts=filtered_repos,
                                      has_repository_dependencies=has_repository_dependencies,
                                      includes_tool_dependencies=includes_tool_dependencies,
                                      includes_tools=includes_tools,
                                      includes_tools_for_display_in_tool_panel=includes_tools_for_display_in_tool_panel,
                                      install_repository_dependencies=install_repository_dependencies,
                                      install_tool_dependencies=install_tool_dependencies,
                                      message='',
                                      new_tool_panel_section_label=new_tool_panel_section_label,
                                      tool_panel_section_mapping=tool_panel_section_mapping,
                                      install_resolver_dependencies=install_resolver_dependencies,
                                      shed_tool_conf=shed_tool_conf,
                                      status='ok',
                                      tool_panel_section_id=tool_panel_section_id,
                                      tool_panel_section_keys=tool_panel_keys,
                                      tool_path=tool_path,
                                      tool_shed_url=tool_shed_url )
            encoded_kwd, query, tool_shed_repositories, encoded_repository_ids = \
                irm.initiate_repository_installation( installation_dict )
            return json.dumps( dict( operation='install',
                                     api=True,
                                     install_resolver_dependencies=install_resolver_dependencies,
                                     install_tool_dependencies=install_tool_dependencies,
                                     encoded_kwd=encoded_kwd,
                                     reinstalling=False,
                                     tool_shed_repository_ids=json.dumps( [ repo[0] for repo in repositories ] ),
                                     repositories=[ trans.security.encode_id( repo.id ) for repo in new_repositories ] ) )
示例#10
0
    def __api_import_new_workflow(self, trans, payload, **kwd):
        data = payload['workflow']

        import_tools = util.string_as_bool(payload.get("import_tools", False))
        if import_tools and not trans.user_is_admin():
            raise exceptions.AdminRequiredException()

        publish = util.string_as_bool(payload.get("publish", False))
        # If 'publish' set, default to importable.
        importable = util.string_as_bool(payload.get("importable", publish))
        # Galaxy will try to upgrade tool versions that don't match exactly during import,
        # this prevents that.
        exact_tools = util.string_as_bool(payload.get("exact_tools", False))

        if publish and not importable:
            raise exceptions.RequestParameterInvalidException(
                "Published workflow must be importable.")

        from_dict_kwds = dict(
            source="API",
            publish=publish,
            exact_tools=exact_tools,
        )
        workflow, missing_tool_tups = self._workflow_from_dict(
            trans, data, **from_dict_kwds)

        if importable:
            self._make_item_accessible(trans.sa_session, workflow)
            trans.sa_session.flush()

        # galaxy workflow newly created id
        workflow_id = workflow.id
        # api encoded, id
        encoded_id = trans.security.encode_id(workflow_id)

        # return list
        rval = []

        item = workflow.to_dict(value_mapper={'id': trans.security.encode_id})
        item['url'] = url_for('workflow', id=encoded_id)
        item['owner'] = workflow.user.username
        item['number_of_steps'] = len(workflow.latest_workflow.steps)
        rval.append(item)

        #
        if import_tools:
            tools = {}
            for key in data['steps']:
                item = data['steps'][key]
                if item is not None:
                    if 'tool_shed_repository' in item:
                        tool_shed_repository = item['tool_shed_repository']
                        if 'owner' in tool_shed_repository and 'changeset_revision' in tool_shed_repository and 'name' in tool_shed_repository and 'tool_shed' in tool_shed_repository:
                            toolstr = tool_shed_repository['owner'] \
                                + tool_shed_repository['changeset_revision'] \
                                + tool_shed_repository['name'] \
                                + tool_shed_repository['tool_shed']
                            tools[toolstr] = tool_shed_repository
            irm = InstallRepositoryManager(self.app)
            for k in tools:
                item = tools[k]
                tool_shed_url = 'https://' + item['tool_shed'] + '/'
                name = item['name']
                owner = item['owner']
                changeset_revision = item['changeset_revision']
                irm.install(tool_shed_url, name, owner, changeset_revision,
                            payload)
        return item
 def setUp(self):
     super(InstallRepositoryManagerTestCase, self).setUp()
     self.irm = InstallRepositoryManager(self.app)
     self.app.config.enable_tool_shed_check = False
     self.app.update_repository_manager = UpdateRepositoryManager(self.app)
class InstallRepositoryManagerTestCase(ToolShedRepoBaseTestCase):
    def setUp(self):
        super(InstallRepositoryManagerTestCase, self).setUp()
        self.irm = InstallRepositoryManager(self.app)
        self.app.config.enable_tool_shed_check = False
        self.app.update_repository_manager = UpdateRepositoryManager(self.app)

    def test_tool_shed_repository_install(self):
        hg_util.clone_repository = MagicMock(return_value=(True, None))
        self._install_tool_shed_repository(start_status='New',
                                           end_status='Installed',
                                           changeset_revision='1')
        hg_util.clone_repository.assert_called_with(
            'github.com/repos/galaxyproject/example',
            os.path.abspath(
                os.path.join(
                    '../shed_tools',
                    'github.com/repos/galaxyproject/example/1/example')),
            '1',
        )

    def test_tool_shed_repository_update(self):
        common_util.get_tool_shed_url_from_tool_shed_registry = MagicMock(
            return_value='https://github.com')
        repository_util.get_tool_shed_status_for_installed_repository = MagicMock(
            return_value={'revision_update': 'false'})
        hg_util.pull_repository = MagicMock()
        hg_util.update_repository = MagicMock(return_value=(True, None))
        self._install_tool_shed_repository(start_status='Installed',
                                           end_status='Installed',
                                           changeset_revision='2')
        assert hg_util.pull_repository.call_args[0][0].endswith(
            'github.com/repos/galaxyproject/example/1/example')
        assert hg_util.pull_repository.call_args[0][
            1] == 'https://github.com/repos/galaxyproject/example'
        assert hg_util.pull_repository.call_args[0][2] == '2'
        assert hg_util.update_repository.call_args[0][0].endswith(
            'github.com/repos/galaxyproject/example/1/example')
        assert hg_util.update_repository.call_args[0][1] == '2'

    def _install_tool_shed_repository(self, start_status, end_status,
                                      changeset_revision):
        repository = self._setup_repository()
        repository.status = start_status
        repo_info_dict = {
            'example': (
                'description',
                'github.com/repos/galaxyproject/example',
                changeset_revision,
                changeset_revision,
                'galaxyproject',
                [],
                [],
            )
        }
        self.irm.install_tool_shed_repository(
            repository,
            repo_info_dict,
            'section_key',
            self.app.config.tool_configs[0],
            '../shed_tools',
            False,
            False,
            reinstalling=False,
        )
        assert repository.status == end_status
        assert repository.changeset_revision == changeset_revision