def verb2_3_name(self, subject, thing, value): """ name([],global_name,role(None,[concrete]),role(to,[abstract])) """ words = action.abstract_wordlist(value) thing = action.concrete_object(thing) ordinal = None try: ordinal = int(words[-1]) words = words[:-1] except: pass print 'set type name of ', thing, ' to ', words, ordinal proxy = self.database.find_item(thing) if not proxy: return async .failure('internal error: no proxy') def co(): yield interpreter.RpcAdapter( proxy.invoke_rpc('set_names', ' '.join(words))) if ordinal is not None: yield interpreter.RpcAdapter( proxy.invoke_rpc('set_ordinal', str(ordinal))) else: yield interpreter.RpcAdapter( proxy.invoke_rpc('clear_ordinal', '')) return async .Coroutine(co(), interpreter.rpcerrorhandler)
def verb2_19_unconnect_from(self, subject, t, f): """ connect([un],global_unconnect_from,role(None,[concrete]),role(from,[concrete,singular])) """ f = self.database.to_database_id(action.concrete_object(f)) for o in action.concrete_objects(t): t2 = self.database.to_database_id(o) print 'un connect', t2, 'from', f tproxy = self.database.find_item(t2) objs = self.database.search_any_key( 'W', T('unconnect_from_list', t2, f, V('W'))) for (s, m) in objs: sproxy = self.database.find_item(s) cnxs = logic.parse_clauselist(sproxy.get_master()) for cnx in cnxs: if logic.is_pred_arity(cnx, 'conn', 5) and self.database.to_database_id( cnx.args[2]) == m: print 'disconnect', cnx, 'from', s yield interpreter.RpcAdapter( sproxy.invoke_rpc('disconnect', logic.render_term(cnx))) yield async .Coroutine.success()
def verb2_21_statemgr(self, subject, sm): """ use([],None,role(None,[concrete,proto(setupmanager),singular])) """ sm = action.concrete_object(sm) self.agent.set_statemgr(sm) print 'using', sm, 'for checkpointing'
def __ctluncreate(self, subj, c): a = action.concrete_object(c) for (i, p) in self.iter_subsys_items(): if p.id() == a: self.__state[2].retract_state(lambda v, s: v == str(i)) return action.removed_return(a) return async .failure('not found')
def __add(self,subject,agent): id = action.concrete_object(agent) if self.__state.find(lambda v,s: s==id): print id,'already in',self.id() return print 'adding',id, 'to',self.id() rpc.invoke_rpc(id,'notify_delete',logic.render_term(self.id())) self.__state.assert_state(id)
def __save_inst(self,subject,arg,name): id = action.concrete_object(arg) name = action.abstract_string(name) rig = self.__instances.find(lambda v,i: v==id) if rig is None: return async.failure('not a rig') return rig.save(name)
def __rigcreateverb(self, subject, plugin, rig): rig = action.concrete_object(rig) plugin = action.abstract_string(plugin) result = rpc.invoke_rpc(rig, "createagent", plugin) yield result if result.status(): yield async .Coroutine.success(logic.parse_clause( result.args()[0])) yield async .Coroutine.failure(*result.args())
def __uncreate_tap(self, subject, tap): subject = action.concrete_object(tap) print 'Delay, un create tap ', subject for k, v in self[7].iteritems(): if v.id() == subject: self[7][k].destroy_tap() del self[7][k] return
def __do_icon(self,a,b,c,d): print 'icon_manager:__do_icon',a,b,c,d (type,thing) = action.crack_ideal(action.arg_objects(d)[0]) print 'crack', type,thing iconstring=self[2].getIconString(thing) id=action.concrete_object(c) print 'set the icon string on ',id, 'to',iconstring rpc.invoke_rpc(id,'set_icon',logic.render_term(iconstring))
def __control(self, s, t): t = action.concrete_object(t) r = self.database.search_any_key('OL', T('find_controls', t, V('OL'))) for target, ctl in r: tag = ':'.join((target, ctl)) i = self[4].find_hole() c = Connector(self, i, tag) p = self.database.find_item(target) self[4][i] = c yield c.opened cs = logic.render_term(logic.make_term('ctl', c.id(), None)) yield interpreter.RpcAdapter(p.invoke_rpc('control', cs)) yield async .Coroutine.success()
def verb2_10_associate(self, subject, part, whole): """ associate([],global_associate,role(None,[or([concrete],[virtual]),singular]),role(to,[concrete,singular])) """ part = action.arg_objects(part)[0] whole = action.concrete_object(whole) rel = 'join(%s,role(to,[instance(~self)]))' % part proxy = self.database.find_item(whole) if not proxy: return async .failure('internal error: no proxy') def co(): yield interpreter.RpcAdapter(proxy.invoke_rpc('add_relation', rel)) return async .Coroutine(co(), interpreter.rpcerrorhandler)
def __controlwith(self, s, t, k): k = int(action.abstract_string(k)) if self[4].has_key(k): yield async .Coroutine.failure('key already defined') t = action.concrete_object(t) p = self.database.find_item(t) ctl = p.domain().hint('control') if not ctl: yield async .Coroutine.failure('%s cannot be controlled' % t) c = Connector(self, k, ':'.join((t, ctl[0]))) self[4][k] = c yield c.opened cs = logic.render_term(logic.make_term('ctl', c.id(), None)) yield interpreter.RpcAdapter(p.invoke_rpc('control', cs)) yield async .Coroutine.success()
def __uncreate_inst(self,subject,arg): id = action.concrete_object(arg) agentd = self.__agentd.get_data().as_string() rig = self.__instances.find(lambda v,i: v==id) rv = [id] if rig is None: yield async.Coroutine.failure('not a rig') f = async.Aggregate() for a in rig.iteragents(): f.add(a,rpc.invoke_rpc(agentd,'destroy',a)) rv.append(a) f.enable() yield f self.__instances.retract_state(lambda v,i: v==id) yield async.Coroutine.success(action.removed_return(*rv))
def __upgrade_sampler(self, subject, target, script): target = action.concrete_object(target) script = action.abstract_string(script) script = script.lower().replace(' ', '_') filename = resource.find_resource('upgrade_manager', 'script_%s' % script) if not filename: return async .failure('upgrade script %s not defined' % script) interp = self.__interp.get_data().as_string() if not paths.valid_id(interp): return async .failure('no agent manager specified and no default') text = file(filename, 'r').read().replace('%target%', target) print 'upgrade on', target, 'with', script, 'using', interp return self.__runner(text, interp)
def verb2_20_connect(self, subject, src, dst, dst_chan, src_chan): """ connect([],global_connect,role(None,[or([concrete],[composite([descriptor])])]),role(to,[concrete,singular]),option(into,[mass([channel])]),option(from,[abstract])) """ if dst_chan is not None: dst_chan = int(action.mass_quantity(dst_chan)) if src_chan is not None: src_chan = action.abstract_string(src_chan) src_match = re.match('^channel\s+([\d\.]+)$', src_chan, re.IGNORECASE) if src_match: src_chan = src_match.group(1) else: yield async .Coroutine.failure("%s is not valid" % src_chan) to_descriptor = (action.concrete_object(dst), None) to_descriptor = self.database.to_database_term(to_descriptor) for ff in action.arg_objects(src): if action.is_concrete(ff): from_descriptors = [(action.crack_concrete(ff), None)] else: from_descriptors = action.crack_composite( ff, action.crack_descriptor) from_descriptors = self.database.to_database_term(from_descriptors) r = plumber.plumber(self.database, to_descriptor, from_descriptors, dst_chan=dst_chan, src_chan=src_chan) yield r if not r.status(): yield async .Coroutine.failure(*r.args(), **r.kwds()) yield async .Coroutine.success()
def verb2_5_number(self, subject, thing, value): """ number([],global_number,role(None,[concrete,singular]),role(to,[abstract])) """ value = action.abstract_string(value) thing = action.concrete_object(thing) try: value = int(value) except: return async .failure('internal error: non numeric ordinal') print 'set ordinal of ', thing, ' to ', value proxy = self.database.find_item(thing) if not proxy: return async .failure('internal error: no proxy') def co(): yield interpreter.RpcAdapter( proxy.invoke_rpc('set_ordinal', str(value))) return async .Coroutine(co(), interpreter.rpcerrorhandler)
def __add_widget(self, subject, dummy, target): target = action.concrete_object(target) self.widgets.create_widget(target)
def crack_voice(self,voice): if action.is_concrete(voice[0]): o = action.concrete_object(voice) (a,p) = paths.breakid_list(o) return p[1] return int(action.abstract_string(voice))
def __usesched(self,subject,sched): sched = action.concrete_object(sched) self.__scheduler.set_address(sched) self.get_private().set_data(piw.makestring(sched,0))
def __create_tmpl(self,subject,name,arg): name = action.abstract_string(name) agentd = self.__agentd.get_data().as_string() if arg is not None: agentd = action.concrete_object(arg) if not paths.valid_id(agentd): yield async.Coroutine.failure('no agent manager specified and no default') print 'loading',name,'onto',agentd file = resource.find_resource(resource.instrument_dir,name) if not file or not os.path.exists(file): yield async.Coroutine.failure('no rig %s' % name) db = state.open_database(file,False) agnts = [] map = state.create_mapping(True) ret = [] # sscount=0 ssid='' ssaddress='' for s,n,a in self.__agentlist(db.get_trunk()): x = a.get_address() if self.__issubsystem(s): #xa=getssid(sscount,ssid) #sscount=sscount+1 xa=self.__getssid(x,ssid) ssaddress='/'+(str(x).split('/')[1]) elif self.__isrig(s): xa = guid.address('rig') self.__instances.assert_state(xa) ssid=xa ssaddress='' # sscount=0 else: c = self.__create_agent(s,agentd) yield c if not c.status(): yield async.Coroutine.failure(*c.args()) xa = c.args()[0] ssid=xa ssaddress='' # sscount=0 map.add('|rig-%s%s-rig|'%(x,ssaddress),xa) print 'map','|rig-%s%s-rig|'%(x,ssaddress),xa if x == '0': ret.append(action.created_return(xa)) elif not self.__issubsystem(s): ret.append(action.initialise_return(xa)) print x,'->',s,xa agnts.append((xa,n)) start = time.time() agg = async.Aggregate(progress=lambda agg,a,b: self.__status(start,agg,a,b)) for i,(a,n) in enumerate(agnts): c = Controller(a) r = c.doload(n,map) agg.add(c,r) print 'loading' agg.enable() self.__bucket.append(agg) yield agg print 'loaded',agg self.__bucket.remove(agg) yield async.Coroutine.success(tuple(ret))
def __use(self,sub,arg): arg = action.concrete_object(arg) self.__agentd.set_data(piw.makestring(arg,0))
def __unadd(self,subject,agent): id = action.concrete_object(agent) self.__do_unadd(id)
def __del_widget(self, subject, dummy, target): target = action.concrete_object(target) self.widgets.destroy_widget(target)