def updateVistrail(self, url, vistrail=None):
        """ updateVistrail(self, string:url, Vistrail:vistrail)
        Update the specified entity url. Delete or reload as necessary.
        Need to make sure workspaces are updated if the entity is changed.
        """
        entities = [e for e in self.entities.itervalues() if e.url == url]
        entity = entities[0] if len(entities) else None
        while entity and entity.parent:
            entity = entity.parent 
            url = entity.url
        workspaces = [p for p in self.workspaces if entity in self.workspaces[p]]
        if entity:
            for p in workspaces:
                self.del_from_workspace(entity, p)
            self.delete_entity(entity)

        locator = BaseLocator.from_url(url)
        if locator.is_valid():
            if not vistrail:
                (vistrail, abstractions, thumbnails, mashups) = load_vistrail(locator)
                vistrail.abstractions = abstractions
                vistrail.thumbnails = thumbnails
                vistrail.mashups = mashups
            entity = self.create_vistrail_entity(vistrail)
            for p in workspaces:
                self.add_to_workspace(entity, p)
            return entity
        else:
            # probably an unsaved vistrail
            pass
def get_vt_graph(vt_list, tree_info, pdf=False):
    """get_vt_graph(vt_list: list of locator, tree_info:str)
    Load all vistrails in vt_list and dump their tree to tree_info.
    
    """
    result = []
    if is_running_gui():
        from gui.vistrail_controller import VistrailController as \
             GUIVistrailController
        for locator in vt_list:
            try:
                (v, abstractions , thumbnails, mashups)  = load_vistrail(locator)
                controller = GUIVistrailController()
                if tree_info is not None:
                        from gui.version_view import QVersionTreeView
                        version_view = QVersionTreeView()
                        from gui.pipeline_view import QPipelineView
                        pipeline_view = QPipelineView()
                        controller.current_pipeline_view = pipeline_view.scene()
                        controller.set_vistrail(v, locator, abstractions, thumbnails,
                                        mashups)
                        version_view.scene().setupScene(controller)
                        if pdf:
                            base_fname = "graph_%s.pdf" % locator.short_name
                            filename = os.path.join(tree_info, base_fname)
                            version_view.scene().saveToPDF(filename)
                        else:
                            base_fname = "graph_%s.png" % locator.short_name
                            filename = os.path.join(tree_info, base_fname)
                            version_view.scene().saveToPNG(filename)
                        del version_view
                        result.append((True, ""))
            except Exception, e:
                result.append((False, str(e)))
Beispiel #3
0
    def updateVistrail(self, url, vistrail=None):
        """ updateVistrail(self, string:url, Vistrail:vistrail)
        Update the specified entity url. Delete or reload as necessary.
        Need to make sure workspaces are updated if the entity is changed.
        """
        entities = [e for e in self.entities.itervalues() if e.url == url]
        entity = entities[0] if len(entities) else None
        while entity and entity.parent:
            entity = entity.parent
            url = entity.url
        workspaces = [
            p for p in self.workspaces if entity in self.workspaces[p]
        ]
        if entity:
            for p in workspaces:
                self.del_from_workspace(entity, p)
            self.delete_entity(entity)

        locator = BaseLocator.from_url(url)
        if locator.is_valid():
            if not vistrail:
                (vistrail, abstractions, thumbnails,
                 mashups) = load_vistrail(locator)
                vistrail.abstractions = abstractions
                vistrail.thumbnails = thumbnails
                vistrail.mashups = mashups
            entity = self.create_vistrail_entity(vistrail)
            for p in workspaces:
                self.add_to_workspace(entity, p)
            return entity
        else:
            # probably an unsaved vistrail
            pass
Beispiel #4
0
def get_vt_graph(vt_list, tree_info, pdf=False):
    """get_vt_graph(vt_list: list of locator, tree_info:str)
    Load all vistrails in vt_list and dump their tree to tree_info.
    
    """
    result = []
    if is_running_gui():
        from gui.vistrail_controller import VistrailController as \
             GUIVistrailController
        for locator in vt_list:
            try:
                (v, abstractions, thumbnails, mashups) = load_vistrail(locator)
                controller = GUIVistrailController()
                if tree_info is not None:
                    from gui.version_view import QVersionTreeView
                    version_view = QVersionTreeView()
                    from gui.pipeline_view import QPipelineView
                    pipeline_view = QPipelineView()
                    controller.current_pipeline_view = pipeline_view.scene()
                    controller.set_vistrail(v, locator, abstractions,
                                            thumbnails, mashups)
                    version_view.scene().setupScene(controller)
                    if pdf:
                        base_fname = "graph_%s.pdf" % locator.short_name
                        filename = os.path.join(tree_info, base_fname)
                        version_view.scene().saveToPDF(filename)
                    else:
                        base_fname = "graph_%s.png" % locator.short_name
                        filename = os.path.join(tree_info, base_fname)
                        version_view.scene().saveToPNG(filename)
                    del version_view
                    result.append((True, ""))
            except Exception, e:
                result.append((False, str(e)))
Beispiel #5
0
    def open_vistrail(self, locator, version=None, is_abstraction=False):
        """open_vistrail(locator: Locator, version = None: int or str,
                         is_abstraction: bool)

        opens a new vistrail from the given locator, selecting the
        given version.

        """
        self.close_first_vistrail_if_necessary()
        if self.single_document_mode and self.currentView():
            self.closeVistrail()
        view = self.ensureVistrail(locator)
        if view:
            if version is not None:
                if type(version) == type(""):
                    try:
                        version = view.vistrail.get_version_number(version)
                    except:
                        version = None
                if version is not None:
                    view.setup_view(version)
            return view
        try:
            (vistrail, abstraction_files, thumbnail_files, _) = \
                                        load_vistrail(locator, is_abstraction)
            result = self.set_vistrail_view(vistrail, locator, 
                                            abstraction_files, thumbnail_files,
                                            version)
            # update collection
            try:
                vistrail.thumbnails = thumbnail_files
                vistrail.abstractions = abstraction_files
                collection = Collection.getInstance()
                url = locator.to_url()
                # create index if not exist
                entity = collection.fromUrl(url)
                if entity:
                    # find parent vistrail
                    while entity.parent:
                        entity = entity.parent 
                else:
                    entity = collection.updateVistrail(url, vistrail)
                # add to relevant workspace categories
                collection.add_to_workspace(entity)
                collection.commit()
            except Exception, e:
                import traceback
                debug.critical('Failed to index vistrail', str(e) + traceback.format_exc())
            return result
Beispiel #6
0
def get_wf_graph(w_list, workflow_info=None, pdf=False):
    """run_and_get_results(w_list: list of (locator, version), 
                           workflow_info:str, pdf:bool)
    Load all workflows in wf_list and dump their graph to workflow_info.
    
    """
    result = []
    if is_running_gui():
        from gui.vistrail_controller import VistrailController as \
             GUIVistrailController
        for locator, workflow in w_list:
            try:
                (v, abstractions, thumbnails, mashups) = load_vistrail(locator)
                controller = GUIVistrailController()
                if type(workflow) == type("str"):
                    version = v.get_version_number(workflow)
                elif type(workflow) in [type(1), long]:
                    version = workflow
                elif workflow is None:
                    version = controller.get_latest_version_in_graph()
                else:
                    msg = "Invalid version tag or number: %s" % workflow
                    raise VistrailsInternalError(msg)
                controller.change_selected_version(version)

                if (workflow_info is not None
                        and controller.current_pipeline is not None):
                    from gui.pipeline_view import QPipelineView
                    pipeline_view = QPipelineView()
                    controller.current_pipeline_view = pipeline_view.scene()
                    controller.set_vistrail(v, locator, abstractions,
                                            thumbnails, mashups)
                    pipeline_view.scene().setupScene(
                        controller.current_pipeline)
                    if pdf:
                        base_fname = "%s_%s_pipeline.pdf" % (
                            locator.short_name, version)
                        filename = os.path.join(workflow_info, base_fname)
                        pipeline_view.scene().saveToPDF(filename)
                    else:
                        base_fname = "%s_%s_pipeline.png" % (
                            locator.short_name, version)
                        filename = os.path.join(workflow_info, base_fname)
                        pipeline_view.scene().saveToPNG(filename)
                    del pipeline_view
                    result.append((True, ""))
            except Exception, e:
                result.append((False, str(e)))
def get_wf_graph(w_list, workflow_info=None, pdf=False):
    """run_and_get_results(w_list: list of (locator, version), 
                           workflow_info:str, pdf:bool)
    Load all workflows in wf_list and dump their graph to workflow_info.
    
    """
    result = []
    if is_running_gui():
        from gui.vistrail_controller import VistrailController as \
             GUIVistrailController
        for locator, workflow in w_list:
            try:
                (v, abstractions , thumbnails, mashups)  = load_vistrail(locator)
                controller = GUIVistrailController()
                if type(workflow) == type("str"):
                    version = v.get_version_number(workflow)
                elif type(workflow) in [ type(1), long]:
                    version = workflow
                elif workflow is None:
                    version = controller.get_latest_version_in_graph()
                else:
                    msg = "Invalid version tag or number: %s" % workflow
                    raise VistrailsInternalError(msg)
                controller.change_selected_version(version)
            
                if (workflow_info is not None and 
                    controller.current_pipeline is not None):
                    from gui.pipeline_view import QPipelineView
                    pipeline_view = QPipelineView()
                    controller.current_pipeline_view = pipeline_view.scene()
                    controller.set_vistrail(v, locator, abstractions, thumbnails,
                                        mashups)
                    pipeline_view.scene().setupScene(controller.current_pipeline)
                    if pdf:
                        base_fname = "%s_%s_pipeline.pdf" % (locator.short_name, version)
                        filename = os.path.join(workflow_info, base_fname)
                        pipeline_view.scene().saveToPDF(filename)
                    else:
                        base_fname = "%s_%s_pipeline.png" % (locator.short_name, version)
                        filename = os.path.join(workflow_info, base_fname)
                        pipeline_view.scene().saveToPNG(filename)
                    del pipeline_view
                    result.append((True, ""))
            except Exception, e:
                result.append((False, str(e)))
 def update_from_database(self, db_locator):
     # db_conn = db_locator.get_connection()
     config = (('host', db_locator._host),
               ('port', int(db_locator._port)),
               ('db', db_locator._db),
               ('user', db_locator._user),
               ('passwd', db_locator._passwd))
     rows = db.services.io.get_db_object_list(dict(config), 'vistrail')
     for row in rows:
         if row[0] in [1,]:
             continue
         kwargs = {'obj_type': 'vistrail', 'obj_id': row[0]}
         locator = DBLocator(*[x[1] for x in config], **kwargs)
         (vistrail, abstractions, thumbnails, mashups) = load_vistrail(locator)
         vistrail.abstractions = abstractions
         vistrail.thumbnails = thumbnails
         vistrail.mashups = mashups
         self.create_vistrail_entity(vistrail)
Beispiel #9
0
 def update_from_database(self, db_locator):
     # db_conn = db_locator.get_connection()
     config = (('host', db_locator._host), ('port', int(db_locator._port)),
               ('db', db_locator._db), ('user', db_locator._user),
               ('passwd', db_locator._passwd))
     rows = db.services.io.get_db_object_list(dict(config), 'vistrail')
     for row in rows:
         if row[0] in [
                 1,
         ]:
             continue
         kwargs = {'obj_type': 'vistrail', 'obj_id': row[0]}
         locator = DBLocator(*[x[1] for x in config], **kwargs)
         (vistrail, abstractions, thumbnails,
          mashups) = load_vistrail(locator)
         vistrail.abstractions = abstractions
         vistrail.thumbnails = thumbnails
         vistrail.mashups = mashups
         self.create_vistrail_entity(vistrail)
Beispiel #10
0
    def newVistrail(self, recover_files=True):
        """ newVistrail() -> (None or QVistrailView)
        Create a new vistrail with no name. If user cancels process,
        returns None.

        FIXME: We should do the interactive parts separately.
        
        """
        if self.single_document_mode and self.currentView():
            if not self.closeVistrail():
                return None
        if recover_files and untitled_locator().has_temporaries():
            locator = copy.copy(untitled_locator())
        else:
            locator = None
        try:
            (vistrail, abstraction_files, thumbnail_files, _) = load_vistrail(locator)
        except ModuleRegistryException, e:
            debug.critical("Module registry error for %s" %
                           str(e.__class__.__name__), str(e))
Beispiel #11
0
def load_workflow_as_function(vt_filename, workflow):
    """load_workflow_as_function(vt_filename: str, 
                                 workflow: str or int) -> function 
    vt_filename is the path to a vistrail and workflow can be a workflow 
    version or a workflow tag
    
    """
    from core.vistrail.controller import VistrailController
    from core.db.locator import FileLocator
    from core.db.io import load_vistrail

    def getfunction(controller, doc, **kwargs):
        def makefunction(*args, **kwargs):
            return controller.execute_current_workflow(
                custom_aliases=kwargs,
                reason='API load_workflow_as_function call')

        makefunction.__doc__ = doc
        return makefunction

    locator = FileLocator(vt_filename)
    (v, abstractions, thumbnails, mashups) = load_vistrail(locator)
    controller = VistrailController()
    controller.set_vistrail(v, locator, abstractions, thumbnails, mashups)
    if type(workflow) == type("str"):
        version = v.get_version_number(workflow)
    elif type(workflow) in [type(1), long]:
        version = workflow
    controller.change_selected_version(version)
    notes = v.get_notes(version)
    pipeline = controller.current_pipeline
    docstring = "parameters of the function: \n  ("
    kw_aliases = {}
    for (a, info) in pipeline.aliases.iteritems():
        parameter = pipeline.db_get_object(info[0], info[1])
        kw_aliases[a] = parameter.strValue
        docstring += "%s=%s,\n   " % (a, parameter.strValue)
    docstring = docstring[:-5] + ")\n"
    if notes != None:
        docstring += str(notes)
    return getfunction(controller, docstring, **kw_aliases)
    def open_vistrail(self, locator, version=None, is_abstraction=False):
        """open_vistrail(locator: Locator, version = None: int or str,
                         is_abstraction: bool)

        opens a new vistrail from the given locator, selecting the
        given version.

        """
        # self.close_first_vistrail_if_necessary()
        # if self.single_document_mode and self.currentView():
        #     self.closeVistrail()
        # view = self.ensureVistrail(locator)
        # if view:
        #     if version is not None:
        #         if type(version) == type(""):
        #             try:
        #                 version = view.vistrail.get_version_number(version)
        #             except:
        #                 version = None
        #         if version is not None:
        #             view.setup_view(version)
        #     return view
        try:
            (vistrail, abstraction_files, thumbnail_files, _) = \
                                        load_vistrail(locator, is_abstraction)
            window = self.add_window(vistrail)
            self.window_changed(None, window)
            # self.window_changed(window)
            # result = self.set_vistrail_view(vistrail, locator, 
            #                                 abstraction_files, thumbnail_files,
            #                                 version)
            # return result
        # except ModuleRegistryException, e:
        #     debug.critical("Module registry error for %s" %
        #                    str(e.__class__.__name__), str(e))
        except Exception, e:
            # debug.critical('An error has occurred', str(e))
            print "An error has occurred", str(e)
            raise
Beispiel #13
0
    def open_vistrail(self, locator, version=None, is_abstraction=False):
        """open_vistrail(locator: Locator, version = None: int or str,
                         is_abstraction: bool)

        opens a new vistrail from the given locator, selecting the
        given version.

        """
        # self.close_first_vistrail_if_necessary()
        # if self.single_document_mode and self.currentView():
        #     self.closeVistrail()
        # view = self.ensureVistrail(locator)
        # if view:
        #     if version is not None:
        #         if type(version) == type(""):
        #             try:
        #                 version = view.vistrail.get_version_number(version)
        #             except:
        #                 version = None
        #         if version is not None:
        #             view.setup_view(version)
        #     return view
        try:
            (vistrail, abstraction_files, thumbnail_files, _) = \
                                        load_vistrail(locator, is_abstraction)
            window = self.add_window(vistrail)
            self.window_changed(None, window)
            # self.window_changed(window)
            # result = self.set_vistrail_view(vistrail, locator,
            #                                 abstraction_files, thumbnail_files,
            #                                 version)
            # return result
        # except ModuleRegistryException, e:
        #     debug.critical("Module registry error for %s" %
        #                    str(e.__class__.__name__), str(e))
        except Exception, e:
            # debug.critical('An error has occurred', str(e))
            print "An error has occurred", str(e)
            raise
Beispiel #14
0
def load_workflow_as_function(vt_filename, workflow):
    """load_workflow_as_function(vt_filename: str, 
                                 workflow: str or int) -> function 
    vt_filename is the path to a vistrail and workflow can be a workflow 
    version or a workflow tag
    
    """
    from core.vistrail.controller import VistrailController
    from core.db.locator import FileLocator
    from core.db.io import load_vistrail

    def getfunction(controller, doc, **kwargs):
        def makefunction(*args, **kwargs):
            return controller.execute_current_workflow(custom_aliases=kwargs,
                    reason='API load_workflow_as_function call') 
        makefunction.__doc__ = doc
        return makefunction    
    locator = FileLocator(vt_filename) 
    (v, abstractions , thumbnails, mashups)  = load_vistrail(locator)
    controller = VistrailController()
    controller.set_vistrail(v, locator, abstractions, thumbnails, mashups)
    if type(workflow) == type("str"):
        version = v.get_version_number(workflow)
    elif type(workflow) in [ type(1), long]:
        version = workflow
    controller.change_selected_version(version)
    notes = v.get_notes(version)
    pipeline = controller.current_pipeline
    docstring = "parameters of the function: \n  ("
    kw_aliases = {}
    for (a, info) in pipeline.aliases.iteritems():
        parameter = pipeline.db_get_object(info[0],info[1])
        kw_aliases[a] = parameter.strValue
        docstring += "%s=%s,\n   "%(a,parameter.strValue)
    docstring = docstring[:-5] + ")\n"
    if notes != None:
        docstring += str(notes)
    return getfunction(controller, docstring, **kw_aliases)
Beispiel #15
0
 def test_cache(self):
     from core.db.locator import XMLFileLocator
     from core.vistrail.controller import VistrailController
     from core.db.io import load_vistrail
     
     """Test if basic caching is working."""
     locator = XMLFileLocator(core.system.vistrails_root_directory() +
                         '/tests/resources/dummy.xml')
     (v, abstractions, thumbnails, mashups) = load_vistrail(locator)
     
     # the controller will take care of upgrades
     controller = VistrailController()
     controller.set_vistrail(v, locator, abstractions, thumbnails, mashups)
     p1 = v.getPipeline('int chain')
     n = v.get_version_number('int chain')
     controller.change_selected_version(n)
     controller.flush_delayed_actions()
     p1 = controller.current_pipeline
     
     view = DummyView()
     interpreter = core.interpreter.cached.CachedInterpreter.get()
     result = interpreter.execute(p1, 
                                  locator=v,
                                  current_version=n,
                                  view=view,
                                  )
     # to force fresh params
     p2 = v.getPipeline('int chain')
     controller.change_selected_version(n)
     controller.flush_delayed_actions()
     p2 = controller.current_pipeline
     result = interpreter.execute(p2, 
                                  locator=v,
                                  current_version=n,
                                  view=view,
                                  )
     assert len(result.modules_added) == 1
Beispiel #16
0
    def load(self, loadworkflow=True):
        config = ConfigParser.ConfigParser()
        if config.read(self.config_file):
            if config.has_section('global'):
                if config.has_option('global', 'cellnum'):
                    self.cellnum = config.getint('global', 'cellnum')
                if config.has_option('global', 'filenum'):
                    self.filenum = config.getint('global', 'filenum')
                if config.has_option('global', 'varnum'):
                    self.varnum = config.getint('global', 'varnum')
                    print "   ------ Loaded plot %s, varnum = %d ------ " % ( self.name, self.varnum )
                if config.has_option('global', 'workflow_tag'):
                    self.workflow_tag = config.get('global', 'workflow_tag')
#                else:
#                    debug.warning("CDAT Package: file %s does not contain a required option 'workflow_tag'. Widget will not be loaded."%self.config_file)
#                    self.loaded = False
#                    return
                if config.has_option('global', 'filetypes'):
                    types = config.get('global', 'filetypes')
                    tlist = [t.strip() for t in types.split(";")]
                    for t in tlist:
                        kv = t.split(":")
                        self.filetypes[kv[0].strip()] = [v.strip() 
                                                         for v in kv[1].split(",")]
                if config.has_option('global', 'qt_filter'):
                    self.qt_filter = config.get('global', 'qt_filter')
                if config.has_option('global', 'dependencies'):
                    deps = config.get('global', 'dependencies')
                    self.dependencies = [d.strip() for d in deps.split(",")]
            
                if config.has_option('global', 'serialized_config_alias'):
                    self.serializedConfigAlias = config.get('global', 'serialized_config_alias')

                    for y in range(self.filenum):
                        self.files.append( 'Filename' + str(y+1) )
                            
                    for v in range(self.varnum):
                        self.vars.append( 'VariableName' + str(v+1) )
                        self.axes.append( 'Axes' + str(v+1) )

                    for x in range(self.cellnum):
                        section_name = 'cell' + str(x+1)
                        if config.has_section(section_name):
                            cellType = config.get(section_name, 'celltype')
                            if config.has_option(section_name, 'address_alias'):
                                self.cells.append( Cell( cellType, None, None,
                                                     config.get(section_name, 'address_alias') ) )
                            else:
                                self.cells.append(Cell( cellType,"Row"+str(x+1), "Column"+str(x+1) ) )                                                              
                else:
                    
                    for y in range(self.filenum):
                        option_name = 'filename_alias' + str(y+1)
                        if config.has_option('global', option_name):
                            self.files.append(config.get('global', option_name))
                            
                    for v in range(self.varnum):
                        option_name = 'varname_alias' + str(v+1)
                        if config.has_option('global', option_name):
                            self.vars.append(config.get('global', option_name))
                        axes_name = 'axes_alias' + str(v+1)
                        if config.has_option('global', axes_name):
                            self.axes.append(config.get('global', axes_name))
                        
                    for x in range(self.cellnum):
                        section_name = 'cell' + str(x+1)
                        if (config.has_section(section_name) and
                            config.has_option(section_name, 'celltype') and
                            config.has_option(section_name, 'row_alias') and
                            config.has_option(section_name, 'col_alias')):
                            self.cells.append(Cell(config.get(section_name, 'celltype'),
                                                   config.get(section_name, 'row_alias'),
                                                   config.get(section_name, 'col_alias')))
                
                if loadworkflow:
                    #load workflow in vistrail
                    #only if dependencies are enabled
                    manager = get_package_manager()
                    self.unsatisfied_deps = []
                    for dep in self.dependencies:
                        if not manager.has_package(dep):
                            self.unsatisfied_deps.append(dep)
                    if len(self.unsatisfied_deps) == 0:
                        try:
                            (self.plot_vistrail, abstractions , thumbnails, mashups) = load_vistrail(self.locator)
                            controller = VistrailController()
                            controller.set_vistrail(self.plot_vistrail, self.locator, 
                                                    abstractions, thumbnails,
                                                    mashups) 
    
                            self.workflow_version = self.plot_vistrail.get_version_number(self.workflow_tag) if self.workflow_tag else controller.get_latest_version_in_graph()
                            print " Loaded %s version: %s" % (  self.name, str( self.workflow_version ) )
                            controller.change_selected_version(self.workflow_version)
                            self.workflow = controller.current_pipeline
                            self.loaded = True
                        except Exception, err:
                            debug.warning( "Error loading workflow %s: %s" % ( self.name, err ) )
                            self.loaded = False
                    else:
                        debug.warning("UV-CDAT: %s widget could not be loaded \
    because it depends on packages that are not loaded:"%self.name)
                        debug.warning("  %s"%", ".join(self.unsatisfied_deps))
                        self.loaded = False
            else:
                debug.warning("UV-CDAT: file %s does not contain a 'global'\
 section. Widget will not be loaded."%self.config_file)
                self.loaded = False
Beispiel #17
0
    def push_vistrail_to_repository(self, branching=False):
        """ uploads current VisTrail to web repository """

        self._repository_status['details'] = "Pushing to repository..."
        self._push_button.setEnabled(False)
        self._branch_button.setEnabled(False)
        self.update_push_information()
        try:
            # create temp file
            self.directory = tempfile.mkdtemp(prefix='vt_tmp')
            (fd, filename) = tempfile.mkstemp(suffix='.vt',
                                              prefix='vt_tmp',
                                              dir=self.directory)
            os.close(fd)

            # writing tmp vt and switching back to orginal vt
            locator = ZIPFileLocator(filename)
            controller = api.get_current_controller()
            tmp_controller = VistrailController()
            tmp_controller.set_vistrail(controller.vistrail.do_copy(), locator)
            tmp_controller.changed = True
            tmp_controller.write_vistrail(locator)

            # check if this vt is from the repository
            if controller.vistrail.get_annotation('repository_vt_id'):
                repository_vt_id = controller.vistrail.get_annotation(
                    'repository_vt_id').value
            else:
                repository_vt_id = -1

            # upload vistrail temp file to repository
            register_openers(cookiejar=self.dialog.cookiejar)
            project = self.serverCombo.itemData(
                self.serverCombo.currentIndex()).toList()[0].toString()
            if project == "Default": project = ""

            params = {'vistrail_file': open(filename, 'rb'),
                      'action': 'upload',
                      'name': controller.locator.short_name,
                      'repository_vt_id': repository_vt_id if not branching else -1,
                      'is_runnable': not bool(len(self.unsupported_packages)+ \
                                              len(self.local_data_modules)),
                      'vt_id': 0,
                      'branched_from': "" if not branching else repository_vt_id,
                      'project': project,
                      'everyone_can_view': self.perm_view.checkState(),
                      'everyone_can_edit': self.perm_edit.checkState(),
                      'everyone_can_download': self.perm_download.checkState()
                     }

            upload_url = "%s/vistrails/remote_upload/" % \
                    self.config.webRepositoryURL

            datagen, headers = multipart_encode(params)
            request = urllib2.Request(upload_url, datagen, headers)
            result = urllib2.urlopen(request)
            updated_response = result.read()

            os.unlink(filename)

            if updated_response[:6] == "upload":
                # No update, just upload
                if result.code != 200:
                    self._repository_status['details'] = \
                            "Push to repository failed"
                else:
                    repository_vt_id = int(updated_response[8:])
                    controller.vistrail.set_annotation('repository_vt_id',
                                                       repository_vt_id)
                    controller.vistrail.set_annotation(
                        'repository_creator', self.dialog.loginUser.text())
                    # ensure that the annotations get saved
                    controller.set_changed(True)
                    self._repository_status['details'] = \
                            "Push to repository was successful"
            else:
                # update, load updated vistrail
                if result.code != 200:
                    self._repository_status['details'] = "Update Failed"
                else:
                    debug.log("getting version from web")
                    # request file to download
                    download_url = "%s/vistrails/download/%s/" % \
                            (self.config.webRepositoryURL, updated_response)

                    request = urllib2.Request(download_url)
                    result = urllib2.urlopen(request)
                    updated_file = result.read()

                    # create temp file of updated vistrail
                    self.directory = tempfile.mkdtemp(prefix='vt_tmp')
                    (fd,
                     updated_filename) = tempfile.mkstemp(suffix='.vtl',
                                                          prefix='vtl_tmp',
                                                          dir=self.directory)
                    os.close(fd)
                    updated_vt = open(updated_filename, 'w')
                    updated_vt.write(updated_file)
                    updated_vt.close()

                    # switch vistrails to updated one
                    controller = api.get_current_controller()

                    updated_locator = FileLocator(updated_filename)

                    (up_vistrail, abstractions, thumbnails, mashups) = \
                            load_vistrail(updated_locator)

                    controller.set_vistrail(up_vistrail,
                                            controller.vistrail.locator,
                                            abstractions, thumbnails, mashups)

                    # update version tree drawing
                    controller.recompute_terse_graph()
                    controller.invalidate_version_tree()

                    os.remove(updated_filename)
                    os.remove(updated_filename[:-1])
                    os.rmdir(self.directory)

                    self._repository_status['details'] = \
                            "Update to repository was successful"

        except Exception, e:
            debug.critical(str(e))
            self._repository_status['details'] = "An error occurred"
Beispiel #18
0
def run_and_get_results(w_list,
                        parameters='',
                        workflow_info=None,
                        update_vistrail=True,
                        extra_info=None,
                        reason='Console Mode Execution'):
    """run_and_get_results(w_list: list of (locator, version), parameters: str,
                           workflow_info:str, update_vistrail: boolean,
                           extra_info:dict)
    Run all workflows in w_list, and returns an interpreter result object.
    version can be a tag name or a version id.
    
    """
    elements = parameters.split("$&$")
    aliases = {}
    result = []
    for locator, workflow in w_list:
        (v, abstractions, thumbnails, mashups) = load_vistrail(locator)
        controller = VistrailController(auto_save=update_vistrail)
        controller.set_vistrail(v, locator, abstractions, thumbnails, mashups)
        if type(workflow) == type("str"):
            version = v.get_version_number(workflow)
        elif type(workflow) in [type(1), long]:
            version = workflow
        elif workflow is None:
            version = controller.get_latest_version_in_graph()
        else:
            msg = "Invalid version tag or number: %s" % workflow
            raise VistrailsInternalError(msg)
        controller.change_selected_version(version)

        for e in elements:
            pos = e.find("=")
            if pos != -1:
                key = e[:pos].strip()
                value = e[pos + 1:].strip()

                if controller.current_pipeline.has_alias(key):
                    aliases[key] = value

        if workflow_info is not None and controller.current_pipeline is not None:
            if is_running_gui():
                from gui.pipeline_view import QPipelineView
                pipeline_view = QPipelineView()
                pipeline_view.scene().setupScene(controller.current_pipeline)
                base_fname = "%s_%s_pipeline.pdf" % (locator.short_name,
                                                     version)
                filename = os.path.join(workflow_info, base_fname)
                pipeline_view.scene().saveToPDF(filename)
                del pipeline_view
            else:
                debug.critical("Cannot save pipeline figure when not "
                               "running in gui mode")
            base_fname = "%s_%s_pipeline.xml" % (locator.short_name, version)
            filename = os.path.join(workflow_info, base_fname)
            core.db.io.save_workflow(controller.current_pipeline, filename)
        if not update_vistrail:
            conf = get_vistrails_configuration()
            if conf.has('thumbs'):
                conf.thumbs.autoSave = False

        (results, _) = \
            controller.execute_current_workflow(custom_aliases=aliases,
                                                extra_info=extra_info,
                                                reason=reason)
        new_version = controller.current_version
        if new_version != version:
            debug.warning("Version '%s' (%s) was upgraded. The actual "
                          "version executed was %s" % \
                              (workflow, version, new_version))
        run = results[0]
        run.workflow_info = (locator.name, new_version)
        run.pipeline = controller.current_pipeline

        if update_vistrail:
            controller.write_vistrail(locator)
        result.append(run)
    return result
def run_and_get_results(w_list, parameters='', workflow_info=None, 
                        update_vistrail=True, extra_info=None, 
                        reason='Console Mode Execution'):
    """run_and_get_results(w_list: list of (locator, version), parameters: str,
                           workflow_info:str, update_vistrail: boolean,
                           extra_info:dict)
    Run all workflows in w_list, and returns an interpreter result object.
    version can be a tag name or a version id.
    
    """
    elements = parameters.split("$&$")
    aliases = {}
    result = []
    for locator, workflow in w_list:
        (v, abstractions , thumbnails, mashups)  = load_vistrail(locator)
        controller = VistrailController(auto_save=update_vistrail)
        controller.set_vistrail(v, locator, abstractions, thumbnails, mashups)
        if type(workflow) == type("str"):
            version = v.get_version_number(workflow)
        elif type(workflow) in [ type(1), long]:
            version = workflow
        elif workflow is None:
            version = controller.get_latest_version_in_graph()
        else:
            msg = "Invalid version tag or number: %s" % workflow
            raise VistrailsInternalError(msg)
        controller.change_selected_version(version)
        
        for e in elements:
            pos = e.find("=")
            if pos != -1:
                key = e[:pos].strip()
                value = e[pos+1:].strip()
            
                if controller.current_pipeline.has_alias(key):
                    aliases[key] = value
                    
        if workflow_info is not None and controller.current_pipeline is not None:
            if is_running_gui():
                from gui.pipeline_view import QPipelineView
                pipeline_view = QPipelineView()
                pipeline_view.scene().setupScene(controller.current_pipeline)
                base_fname = "%s_%s_pipeline.pdf" % (locator.short_name, version)
                filename = os.path.join(workflow_info, base_fname)
                pipeline_view.scene().saveToPDF(filename)
                del pipeline_view
            else:
                debug.critical("Cannot save pipeline figure when not "
                               "running in gui mode")
            base_fname = "%s_%s_pipeline.xml" % (locator.short_name, version)
            filename = os.path.join(workflow_info, base_fname)
            core.db.io.save_workflow(controller.current_pipeline, filename)
        if not update_vistrail:
            conf = get_vistrails_configuration()
            if conf.has('thumbs'):
                conf.thumbs.autoSave = False
        
        (results, _) = \
            controller.execute_current_workflow(custom_aliases=aliases,
                                                extra_info=extra_info,
                                                reason=reason)
        new_version = controller.current_version
        if new_version != version:
            debug.warning("Version '%s' (%s) was upgraded. The actual "
                          "version executed was %s" % \
                              (workflow, version, new_version))
        run = results[0]
        run.workflow_info = (locator.name, new_version)
        run.pipeline = controller.current_pipeline

        if update_vistrail:
            controller.write_vistrail(locator)
        result.append(run)
    return result
    def push_vistrail_to_repository(self, branching=False):
        """ uploads current VisTrail to web repository """

        self._repository_status['details'] = "Pushing to repository..."
        self._push_button.setEnabled(False)
        self._branch_button.setEnabled(False)
        self.update_push_information()
        try:
            # create temp file
            self.directory = tempfile.mkdtemp(prefix='vt_tmp')
            (fd, filename) = tempfile.mkstemp(suffix='.vt', prefix='vt_tmp',
                                              dir=self.directory)
            os.close(fd)

            # writing tmp vt and switching back to orginal vt
            locator = ZIPFileLocator(filename)
            controller = api.get_current_controller()
            tmp_controller = VistrailController()
            tmp_controller.set_vistrail(controller.vistrail.do_copy(), locator)
            tmp_controller.changed = True
            tmp_controller.write_vistrail(locator)

            # check if this vt is from the repository
            if controller.vistrail.get_annotation('repository_vt_id'):
                repository_vt_id = controller.vistrail.get_annotation('repository_vt_id').value
            else:
                repository_vt_id = -1

            # upload vistrail temp file to repository
            register_openers(cookiejar=self.dialog.cookiejar)
            project = self.serverCombo.itemData(self.serverCombo.currentIndex()).toList()[0].toString()
            if project == "Default": project = ""

            params = {'vistrail_file': open(filename, 'rb'),
                      'action': 'upload',
                      'name': controller.locator.short_name,
                      'repository_vt_id': repository_vt_id if not branching else -1,
                      'is_runnable': not bool(len(self.unsupported_packages)+ \
                                              len(self.local_data_modules)),
                      'vt_id': 0,
                      'branched_from': "" if not branching else repository_vt_id,
                      'project': project,
                      'everyone_can_view': self.perm_view.checkState(),
                      'everyone_can_edit': self.perm_edit.checkState(),
                      'everyone_can_download': self.perm_download.checkState()
                     }

            upload_url = "%s/vistrails/remote_upload/" % \
                    self.config.webRepositoryURL

            datagen, headers = multipart_encode(params)
            request = urllib2.Request(upload_url, datagen, headers)
            result = urllib2.urlopen(request)
            updated_response = result.read()

            os.unlink(filename)

            if updated_response[:6] == "upload":
                # No update, just upload
                if result.code != 200:
                    self._repository_status['details'] = \
                            "Push to repository failed"
                else:
                    repository_vt_id = int(updated_response[8:])
                    controller.vistrail.set_annotation('repository_vt_id',
                                                       repository_vt_id)
                    controller.vistrail.set_annotation('repository_creator',
                                                       self.dialog.loginUser.text())
                    # ensure that the annotations get saved
                    controller.set_changed(True)
                    self._repository_status['details'] = \
                            "Push to repository was successful"
            else:
                # update, load updated vistrail
                if result.code != 200:
                    self._repository_status['details'] = "Update Failed"
                else:
                    debug.log("getting version from web")
                    # request file to download
                    download_url = "%s/vistrails/download/%s/" % \
                            (self.config.webRepositoryURL, updated_response)

                    request = urllib2.Request(download_url)
                    result = urllib2.urlopen(request)
                    updated_file = result.read()

                    # create temp file of updated vistrail
                    self.directory = tempfile.mkdtemp(prefix='vt_tmp')
                    (fd, updated_filename) = tempfile.mkstemp(suffix='.vtl',
                                                              prefix='vtl_tmp',
                                                              dir=self.directory)
                    os.close(fd)
                    updated_vt = open(updated_filename, 'w')
                    updated_vt.write(updated_file)
                    updated_vt.close()

                    # switch vistrails to updated one
                    controller = api.get_current_controller()

                    updated_locator = FileLocator(updated_filename)

                    (up_vistrail, abstractions, thumbnails, mashups) = \
                            load_vistrail(updated_locator)

                    controller.set_vistrail(up_vistrail,
                                            controller.vistrail.locator,
                                            abstractions, thumbnails, mashups)

                    # update version tree drawing
                    controller.recompute_terse_graph()
                    controller.invalidate_version_tree()

                    os.remove(updated_filename)
                    os.remove(updated_filename[:-1])
                    os.rmdir(self.directory)

                    self._repository_status['details'] = \
                            "Update to repository was successful"

        except Exception, e:
            debug.critical(str(e))
            self._repository_status['details'] = "An error occurred"
Beispiel #21
0
 def loadVistrailFromFile(self, filename):
     locator = FileLocator(filename)
     (v, abstractions, thumbnails) = load_vistrail(locator)
     controller = VistrailController()
     controller.set_vistrail(v, locator, abstractions, thumbnails)
     return (v, controller)
Beispiel #22
0
 def loadVistrailFromFile(self, filename):
     locator = FileLocator(filename)
     (v, abstractions , thumbnails)  = load_vistrail(locator)
     controller = VistrailController()
     controller.set_vistrail(v, locator, abstractions, thumbnails)
     return (v, controller)