def getLastNodeThruBinding(appdata,to_node_alias,binding_name,last_node_baseclass_name):
	'''
	Use the binding in the application to get the last/previous node of a defined base class.
	'''
	last_class = noderegistry.getNodeClass(last_node_baseclass_name)
	# Try 10 iteration before giving up
	for iter in range(10):
		q = leginondata.BindingSpecData(application=appdata)
		q['event class string'] = binding_name
		q['to node alias'] = to_node_alias
		r = q.query()
		if not r:
			# no node bound by the binding
			return None
		if len(r) > 1:
			# Should always bound to one node, right?
			return False
		last_alias = r[0]['from node alias']
		q = leginondata.NodeSpecData(application=appdata,alias=last_alias)
		r = q.query()
		if r:
			for lastnodedata in r:
				if issubclass(noderegistry.getNodeClass(lastnodedata['class string']),last_class):
					return lastnodedata
			# next bound node is a filter.  Try again from there.
			to_node_alias = last_alias
			continue
Example #2
0
    def onCreateNode(self, ievent):
        targetclass = ievent['targetclass']
        try:
            nodeclass = noderegistry.getNodeClass(targetclass)
        except noderegistry.NotFoundError:
            self.confirmEvent(ievent, status='failed')
            return

        nodename = ievent['node']
        session = ievent['session']
        managerlocation = ievent['manager location']

        kwargs = {}
        kwargs['launcher'] = self
        kwargs['otherdatabinder'] = self.databinder

        if nodeclass.panelclass is not None:
            evt = leginon.gui.wx.Launcher.CreateNodePanelEvent(
                nodeclass, nodename)
            self.panel.GetEventHandler().AddPendingEvent(evt)
            evt.event.wait()
            kwargs['panel'] = evt.panel

        n = nodeclass(nodename, session, managerlocation, **kwargs)
        self.nodes.append(n)

        evt = leginon.gui.wx.Launcher.CreateNodeEvent(n)
        self.panel.GetEventHandler().AddPendingEvent(evt)

        self.confirmEvent(ievent)
Example #3
0
	def onCreateNode(self, ievent):
		targetclass = ievent['targetclass']
		try:
			nodeclass = noderegistry.getNodeClass(targetclass)
		except noderegistry.NotFoundError:
			self.confirmEvent(ievent, status='failed')
			return

		nodename = ievent['node']
		session = ievent['session']
		managerlocation = ievent['manager location']

		kwargs = {}
		kwargs['launcher'] = self
		kwargs['otherdatabinder'] = self.databinder

		if nodeclass.panelclass is not None:
			evt = leginon.gui.wx.Launcher.CreateNodePanelEvent(nodeclass, nodename)
			self.panel.GetEventHandler().AddPendingEvent(evt)
			evt.event.wait()
			kwargs['panel'] = evt.panel

		n = nodeclass(nodename, session, managerlocation, **kwargs)
		self.nodes.append(n)

		evt = leginon.gui.wx.Launcher.CreateNodeEvent(n)
		self.panel.GetEventHandler().AddPendingEvent(evt)

		self.confirmEvent(ievent)
Example #4
0
	def getNodeClass(self, name):
		nodelocationdata = self.nodelocations[name]
		classname = nodelocationdata['class string']
		if self.isLauncher(classname):
			return launcher.Launcher
		else:
			nodeclass = noderegistry.getNodeClass(classname)
		return nodeclass
Example #5
0
 def getNodeClass(self, name):
     nodelocationdata = self.nodelocations[name]
     classname = nodelocationdata['class string']
     if self.isLauncher(classname):
         return launcher.Launcher
     else:
         nodeclass = noderegistry.getNodeClass(classname)
     return nodeclass
Example #6
0
    def sortNodes(self, nodeclasses=[]):
        allclassnames = noderegistry.getNodeClassNames()
        classtypes = ['Priority', 'Pipeline', 'Calibrations', 'Utility']
        sortclasses = {}
        for classtype in classtypes:
            sortclasses[classtype] = []
        for classname in allclassnames:
            for appnodealias, appnodeclassname in nodeclasses:
                if appnodeclassname == classname:
                    nodeclass = noderegistry.getNodeClass(classname)
                    classtype = nodeclass.classtype
                    sortclasses[classtype].append(appnodealias)
        # sort pipeline nodes by bindings
        if sortclasses['Pipeline']:
            froms = {}
            tos = {}
            for node in sortclasses['Pipeline']:
                froms[node] = []
                tos[node] = []
            for eventclass, fromnode in self.distmap.items():
                for node in sortclasses['Pipeline']:
                    if issubclass(
                            eventclass,
                        (event.ImageTargetListPublishEvent,
                         event.ImagePublishEvent, event.MakeTargetListEvent)):
                        if node in fromnode:
                            for tonode in sortclasses['Pipeline']:
                                if tonode in fromnode[node]:
                                    froms[node].append(tonode)
                                    tos[tonode].append(fromnode)
            starters = []
            for key, value in tos.items():
                if not value:
                    starters.append(key)

            sorted = []
            for starter in starters:
                sorted += depth(starter, froms)
            for node in sortclasses['Pipeline']:
                if node not in sorted:
                    sorted.append(node)
            sortclasses['Pipeline'] = []
            for s in sorted:
                if s not in sortclasses['Pipeline']:
                    sortclasses['Pipeline'].append(s)

        nodeorder = []
        for sortcls in classtypes:
            try:
                nodeorder += sortclasses[sortcls]
                del sortclasses[sortcls]
            except KeyError:
                pass

        for nodes in sortclasses.values():
            nodeorder += nodes

        return nodeorder
Example #7
0
	def sortNodes(self, nodeclasses=[]):
		allclassnames = noderegistry.getNodeClassNames()
		classtypes = ['Priority', 'Pipeline', 'Calibrations', 'Utility']
		sortclasses = {}
		for classtype in classtypes:
			sortclasses[classtype] = []
		for classname in allclassnames:
			for appnodealias, appnodeclassname in nodeclasses:
				if appnodeclassname == classname:
					nodeclass = noderegistry.getNodeClass(classname)
					classtype = nodeclass.classtype
					sortclasses[classtype].append(appnodealias)
		# sort pipeline nodes by bindings
		if sortclasses['Pipeline']:
			froms = {}
			tos = {}
			for node in sortclasses['Pipeline']:
				froms[node] = []
				tos[node] = []
			for eventclass, fromnode in self.distmap.items():
				for node in sortclasses['Pipeline']:
					if issubclass(eventclass,
								(event.ImageTargetListPublishEvent, event.ImagePublishEvent, event.MakeTargetListEvent)):
						if node in fromnode:
							for tonode in sortclasses['Pipeline']:
								if tonode in fromnode[node]:
									froms[node].append(tonode)
									tos[tonode].append(fromnode)
			starters = []
			for key, value in tos.items():
				if not value:
					starters.append(key)

			sorted = []
			for starter in starters:
				sorted += depth(starter, froms)
			for node in sortclasses['Pipeline']:
				if node not in sorted:
					sorted.append(node)
			sortclasses['Pipeline'] = []
			for s in sorted:
				if s not in sortclasses['Pipeline']:
					sortclasses['Pipeline'].append(s)

		nodeorder = []
		for sortcls in classtypes:
			try:
				nodeorder += sortclasses[sortcls]
				del sortclasses[sortcls]
			except KeyError:
				pass

		for nodes in sortclasses.values():
			nodeorder += nodes

		return nodeorder