コード例 #1
0
ファイル: tasks.py プロジェクト: yvanlebras/refinery-platform
def run_analysis_preprocessing(analysis):
    '''perform preprocessing (innermost task, does the actual work)

    '''
    logger.debug("analysis_manager.run_analysis_preprocessing called")

    connection = analysis.get_galaxy_connection()

    # creates new library in galaxy
    try:
        library_id = connection.create_library("{} Analysis - {} ({})".format(
            Site.objects.get_current().name, analysis.uuid, datetime.now()))
    except RuntimeError as exc:
        error_msg = (
            "Pre-processing failed: " +
            "error creating Galaxy library for analysis '{}': {}").format(
                analysis.name, exc.message)
        logger.error(error_msg)
        analysis.set_status(Analysis.FAILURE_STATUS, error_msg)
        run_analysis_preprocessing.update_state(state=celery.states.FAILURE)
        return

    ### generates same ret_list purely based on analysis object ###
    ret_list = get_analysis_config(analysis)

    # getting expanded workflow configured based on input: ret_list
    try:
        new_workflow, history_download, analysis_node_connections = \
            configure_workflow(analysis.workflow, ret_list, connection)
    except RuntimeError as exc:
        error_msg = (
            "Pre-processing failed: " +
            "error configuring Galaxy workflow for analysis '{}': {}").format(
                analysis.name, exc.message)
        logger.error(error_msg)
        analysis.set_status(Analysis.FAILURE_STATUS, error_msg)
        run_analysis_preprocessing.update_state(state=celery.states.FAILURE)
        if not isinstance(exc, (ConnectionError, TimeoutError, AuthError)):
            try:
                analysis.delete_galaxy_library()
            except RuntimeError:
                logger.error("Cleanup failed for analysis '{}'".format(
                    analysis.name))
        return

    # import connections into database
    for analysis_node_connection in analysis_node_connections:
        # lookup node object
        if (analysis_node_connection["node_uuid"]):
            node = Node.objects.get(uuid=analysis_node_connection["node_uuid"])
        else:
            node = None
        AnalysisNodeConnection.objects.create(
            analysis=analysis,
            subanalysis=analysis_node_connection['subanalysis'],
            node=node,
            step=int(analysis_node_connection['step']),
            name=analysis_node_connection['name'],
            filename=analysis_node_connection['filename'],
            filetype=analysis_node_connection['filetype'],
            direction=analysis_node_connection['direction'],
            is_refinery_file=analysis_node_connection['is_refinery_file'])
    # saving ouputs of workflow to download
    for file_dl in history_download:
        temp_dl = WorkflowFilesDL(step_id=file_dl['step_id'],
                                  pair_id=file_dl['pair_id'],
                                  filename=file_dl['name'])
        temp_dl.save()
        analysis.workflow_dl_files.add(temp_dl)
        analysis.save()

    # import newly generated workflow
    try:
        new_workflow_info = connection.import_workflow(new_workflow)
    except RuntimeError as exc:
        error_msg = (
            "Pre-processing failed: " +
            "error importing workflow into Galaxy for analysis '{}': {}"
        ).format(analysis.name, exc.message)
        logger.error(error_msg)
        analysis.set_status(Analysis.FAILURE_STATUS, error_msg)
        run_analysis_preprocessing.update_state(state=celery.states.FAILURE)
        if not isinstance(exc, (ConnectionError, TimeoutError, AuthError)):
            try:
                analysis.delete_galaxy_library()
            except RuntimeError:
                logger.error("Cleanup failed for analysis '{}'".format(
                    analysis.name))
        return

    ######### ANALYSIS MODEL
    # getting number of steps for current workflow
    new_workflow_steps = countWorkflowSteps(new_workflow)

    # creates new history in galaxy
    try:
        history_id = connection.create_history("{} Analysis - {} ({})".format(
            Site.objects.get_current().name, analysis.uuid, datetime.now()))
    except RuntimeError as e:
        error_msg = "Pre-processing failed: " + \
                    "error creating Galaxy history for analysis '{}': {}" \
                    .format(analysis.name, e.message)
        logger.error(error_msg)
        analysis.set_status(Analysis.FAILURE_STATUS, error_msg)
        run_analysis_preprocessing.update_state(state=celery.states.FAILURE)
        if not isinstance(exc, (ConnectionError, TimeoutError, AuthError)):
            try:
                analysis.delete_galaxy_library()
                analysis.delete_galaxy_workflow()
            except RuntimeError:
                logger.error("Cleanup failed for analysis '{}'".format(
                    analysis.name))
        return

    # updating analysis object
    analysis.workflow_copy = new_workflow
    analysis.workflow_steps_num = new_workflow_steps
    analysis.workflow_galaxy_id = new_workflow_info['id']
    analysis.library_id = library_id
    analysis.history_id = history_id
    analysis.save()
    return
コード例 #2
0
ファイル: tasks.py プロジェクト: bennyyu686/refinery-platform
def run_analysis_preprocessing(analysis):
    """perform preprocessing (innermost task, does the actual work)"""
    logger.debug("analysis_manager.run_analysis_preprocessing called")

    connection = analysis.galaxy_connection()
    error_msg = "Pre-processing failed: "

    # creates new library in galaxy
    library_name = "{} Analysis - {} ({})".format(
        Site.objects.get_current().name, analysis.uuid, datetime.now())
    try:
        library_id = connection.libraries.create_library(library_name)['id']
    except galaxy.client.ConnectionError as exc:
        error_msg += "error creating Galaxy library for analysis '%s': %s"
        logger.error(error_msg, analysis.name, exc.message)
        analysis.set_status(Analysis.FAILURE_STATUS, error_msg)
        run_analysis_preprocessing.update_state(state=celery.states.FAILURE)
        return

    # generates same ret_list purely based on analysis object ###
    ret_list = get_analysis_config(analysis)
    try:
        workflow_dict = connection.workflows.export_workflow_json(
            analysis.workflow.internal_id)
    except galaxy.client.ConnectionError as exc:
        error_msg += "error downloading Galaxy workflow for analysis '%s': %s"
        logger.error(error_msg, analysis.name, exc.message)
        analysis.set_status(Analysis.FAILURE_STATUS, error_msg)
        analysis.cleanup()
        run_analysis_preprocessing.update_state(state=celery.states.FAILURE)
        return

    # getting expanded workflow configured based on input: ret_list
    new_workflow, history_download, analysis_node_connections = \
        configure_workflow(workflow_dict, ret_list)

    # import connections into database
    for analysis_node_connection in analysis_node_connections:
        # lookup node object
        if analysis_node_connection["node_uuid"]:
            node = Node.objects.get(uuid=analysis_node_connection["node_uuid"])
        else:
            node = None
        AnalysisNodeConnection.objects.create(
            analysis=analysis,
            subanalysis=analysis_node_connection['subanalysis'],
            node=node,
            step=int(analysis_node_connection['step']),
            name=analysis_node_connection['name'],
            filename=analysis_node_connection['filename'],
            filetype=analysis_node_connection['filetype'],
            direction=analysis_node_connection['direction'],
            is_refinery_file=analysis_node_connection['is_refinery_file']
            )
    # saving outputs of workflow to download
    for file_dl in history_download:
        temp_dl = WorkflowFilesDL(step_id=file_dl['step_id'],
                                  pair_id=file_dl['pair_id'],
                                  filename=file_dl['name'])
        temp_dl.save()
        analysis.workflow_dl_files.add(temp_dl)
        analysis.save()

    # import newly generated workflow
    try:
        new_workflow_info = connection.workflows.import_workflow_json(
            new_workflow)
    except galaxy.client.ConnectionError as exc:
        error_msg += "error importing workflow into Galaxy for "
        error_msg += "analysis '%s': %s"
        logger.error(error_msg, analysis.name, exc.message)
        analysis.set_status(Analysis.FAILURE_STATUS, error_msg)
        analysis.cleanup()
        run_analysis_preprocessing.update_state(state=celery.states.FAILURE)
        return

    # getting number of steps for current workflow
    new_workflow_steps = countWorkflowSteps(new_workflow)

    # creates new history in galaxy
    history_name = "{} Analysis - {} ({})".format(
        Site.objects.get_current().name, analysis.uuid, datetime.now())
    try:
        history_id = connection.histories.create_history(history_name)['id']
    except galaxy.client.ConnectionError as e:
        error_msg += "error creating Galaxy history for analysis '%s': %s"
        logger.error(error_msg, analysis.name, e.message)
        analysis.set_status(Analysis.FAILURE_STATUS, error_msg)
        analysis.cleanup()
        run_analysis_preprocessing.update_state(state=celery.states.FAILURE)
        return

    # updating analysis object
    analysis.workflow_copy = new_workflow
    analysis.workflow_steps_num = new_workflow_steps
    analysis.workflow_galaxy_id = new_workflow_info['id']
    analysis.library_id = library_id
    analysis.history_id = history_id
    analysis.save()
    return
コード例 #3
0
def run_analysis_preprocessing(analysis):
    '''perform preprocessing (innermost task, does the actual work)

    '''
    logger.debug("analysis_manager.run_analysis_preprocessing called")

    connection = analysis.get_galaxy_connection()

    # creates new library in galaxy
    try:
        library_id = connection.create_library(
            "{} Analysis - {} ({})".format(
                Site.objects.get_current().name, analysis.uuid, datetime.now())
            )
    except RuntimeError as exc:
        error_msg = (
            "Pre-processing failed: " +
            "error creating Galaxy library for analysis '{}': {}"
            ).format(analysis.name, exc.message)
        logger.error(error_msg)
        analysis.set_status(Analysis.FAILURE_STATUS, error_msg)
        run_analysis_preprocessing.update_state(state=celery.states.FAILURE)
        return

    ### generates same ret_list purely based on analysis object ###
    ret_list = get_analysis_config(analysis)

    # getting expanded workflow configured based on input: ret_list
    try:
        new_workflow, history_download, analysis_node_connections = \
            configure_workflow(analysis.workflow, ret_list, connection)
    except RuntimeError as exc:
        error_msg = (
            "Pre-processing failed: " +
            "error configuring Galaxy workflow for analysis '{}': {}"
            ).format(analysis.name, exc.message)
        logger.error(error_msg)
        analysis.set_status(Analysis.FAILURE_STATUS, error_msg)
        run_analysis_preprocessing.update_state(state=celery.states.FAILURE)
        if not isinstance(exc, (ConnectionError, TimeoutError, AuthError)):
            try:
                analysis.delete_galaxy_library()
            except RuntimeError:
                logger.error(
                    "Cleanup failed for analysis '{}'".format(analysis.name))
        return

    # import connections into database
    for analysis_node_connection in analysis_node_connections:
        # lookup node object
        if (analysis_node_connection["node_uuid"]):
            node = Node.objects.get(uuid=analysis_node_connection["node_uuid"])
        else:
            node = None
        AnalysisNodeConnection.objects.create(
            analysis=analysis,
            subanalysis=analysis_node_connection['subanalysis'],
            node=node,
            step=int(analysis_node_connection['step']),
            name=analysis_node_connection['name'],
            filename=analysis_node_connection['filename'],
            filetype=analysis_node_connection['filetype'],
            direction=analysis_node_connection['direction'],
            is_refinery_file=analysis_node_connection['is_refinery_file']
            )
    # saving ouputs of workflow to download
    for file_dl in history_download:
        temp_dl = WorkflowFilesDL(step_id=file_dl['step_id'],
                                  pair_id=file_dl['pair_id'],
                                  filename=file_dl['name'])
        temp_dl.save()
        analysis.workflow_dl_files.add( temp_dl ) 
        analysis.save()

    # import newly generated workflow
    try:
        new_workflow_info = connection.import_workflow(new_workflow);
    except RuntimeError as exc:
        error_msg = (
            "Pre-processing failed: " +
            "error importing workflow into Galaxy for analysis '{}': {}"
            ).format(analysis.name, exc.message)
        logger.error(error_msg)
        analysis.set_status(Analysis.FAILURE_STATUS, error_msg)
        run_analysis_preprocessing.update_state(state=celery.states.FAILURE)
        if not isinstance(exc, (ConnectionError, TimeoutError, AuthError)):
            try:
                analysis.delete_galaxy_library()
            except RuntimeError:
                logger.error(
                    "Cleanup failed for analysis '{}'".format(analysis.name))
        return

    ######### ANALYSIS MODEL 
    # getting number of steps for current workflow
    new_workflow_steps = countWorkflowSteps(new_workflow)

    # creates new history in galaxy
    try:
        history_id = connection.create_history(
            "{} Analysis - {} ({})".format(
                Site.objects.get_current().name, analysis.uuid, datetime.now())
            )
    except RuntimeError as e:
        error_msg = "Pre-processing failed: " + \
                    "error creating Galaxy history for analysis '{}': {}" \
                    .format(analysis.name, e.message)
        logger.error(error_msg)
        analysis.set_status(Analysis.FAILURE_STATUS, error_msg)
        run_analysis_preprocessing.update_state(state=celery.states.FAILURE)
        if not isinstance(exc, (ConnectionError, TimeoutError, AuthError)):
            try:
                analysis.delete_galaxy_library()
                analysis.delete_galaxy_workflow()
            except RuntimeError:
                logger.error(
                    "Cleanup failed for analysis '{}'".format(analysis.name))
        return

    # updating analysis object
    analysis.workflow_copy = new_workflow
    analysis.workflow_steps_num = new_workflow_steps
    analysis.workflow_galaxy_id = new_workflow_info['id']
    analysis.library_id = library_id
    analysis.history_id = history_id
    analysis.save()
    return