async def getAhaProxy(urlinfo): ''' Return a telepath proxy by looking up a host from an aha registry. ''' host = urlinfo.get('host') if host is None: mesg = f'getAhaProxy urlinfo has no host: {urlinfo}' raise s_exc.NoSuchName(mesg=mesg) laste = None for ahaurl, cnfo in list(aha_clients.items()): client = cnfo.get('client') if client is None: client = await Client.anit(cnfo.get('url')) client._fini_atexit = True cnfo['client'] = client try: proxy = await client.proxy(timeout=5) ahasvc = await asyncio.wait_for(proxy.getAhaSvc(host), timeout=5) if ahasvc is None: continue svcinfo = ahasvc.get('svcinfo', {}) if not svcinfo.get('online'): continue info = mergeAhaInfo(urlinfo, svcinfo.get('urlinfo', {})) return await openinfo(info) except asyncio.CancelledError: # pragma: no cover raise except Exception as e: if isinstance(ahaurl, str): surl = s_urlhelp.sanitizeUrl(ahaurl) else: surl = tuple([s_urlhelp.sanitizeUrl(u) for u in ahaurl]) logger.exception(f'Unable to get aha client ({surl})') laste = e if laste is not None: raise laste mesg = f'aha lookup failed: {host}' raise s_exc.NoSuchName(mesg=mesg)
async def puts(self, name, items, reqid=None): if self.queues.get(name) is None: mesg = f'No queue named {name}.' raise s_exc.NoSuchName(mesg=mesg, name=name) abrv = self.abrv.nameToAbrv(name) offs = retn = self.offsets.get(name, 0) if reqid is not None: if reqid == self.lastreqid.get(name): return retn self.lastreqid.set(name, reqid) for item in items: putv = self.slab.put(abrv + s_common.int64en(offs), s_msgpack.en(item), db=self.qdata) assert putv, 'Put failed' self.sizes.inc(name, 1) offs = self.offsets.inc(name, 1) # wake the sleepers evnt = self.waiters.get(name) if evnt is not None: evnt.set() return retn
def _getHandler(self, directive): handler = self.handlers.get(directive) if handler is None: raise s_exc.NoSuchName( mesg=f'The {directive} directive is not supported', directive=directive) return handler
async def execStormCmd(self, runt, genr): if not self.runtsafe: mesg = 'macro.exec does not support per-node invocation' raise s_exc.StormRuntimeError(mesg=mesg) name = await s_stormtypes.tostr(self.opts.name) hivepath = ('cortex', 'storm', 'macros', name) mdef = await runt.snap.core.getHiveKey(hivepath) if mdef is None: mesg = f'Macro name not found: {name}' raise s_exc.NoSuchName(mesg=mesg) query = await runt.getStormQuery(mdef['storm']) subr = await runt.getScopeRuntime(query) async def wrapgenr(): async for node, path in genr: path.initframe(initrunt=subr) yield node, path async for nnode, npath in subr.iterStormQuery(query, genr=wrapgenr()): yield nnode, npath
async def puts(self, name, items): if self.queues.get(name) is None: mesg = f'No queue named {name}.' raise s_exc.NoSuchName(mesg=mesg, name=name) abrv = self.abrv.nameToAbrv(name) offs = retn = self.offsets.get(name, 0) for item in items: self.slab.put(abrv + s_common.int64en(offs), s_msgpack.en(item), db=self.qdata) self.sizes.inc(name, 1) offs = self.offsets.inc(name, 1) # wake the sleepers evnt = self.waiters.get(name) if evnt is not None: evnt.set() return retn
async def deref(self, name): if name[0] == '_': mesg = f'No proxy method named {name}' raise s_exc.NoSuchName(mesg=mesg) return getattr(self.proxy, name, None)
async def _chkEdgeVerbInView(self, verb): async for vverb in self.runt.snap.view.getEdgeVerbs(): if vverb == verb: return raise s_exc.NoSuchName(mesg=f'No such edge verb in the current view', name=verb)
async def addFeedData(self, name, items, seqn=None): func = self.core.getFeedFunc(name) if func is None: raise s_exc.NoSuchName(name=name) logger.info(f'adding feed data ({name}): {len(items)} {seqn!r}') retn = func(self, items) # If the feed function is an async generator, run it... if isinstance(retn, types.AsyncGeneratorType): retn = [x async for x in retn] elif s_coro.iscoro(retn): await retn if seqn is not None: iden, offs = seqn nextoff = offs + len(items) await self.setOffset(iden, nextoff) return nextoff
async def _libSvcGet(self, name): self.runt.reqAllowed(('storm', 'service', 'get', name)) ssvc = self.runt.snap.core.getStormSvc(name) if ssvc is None: mesg = f'No service with name/iden: {name}' raise s_exc.NoSuchName(mesg=mesg) return ssvc
async def addFeedNodes(self, name, items): ''' Call a feed function and return what it returns (typically yields Node()s). Args: name (str): The name of the feed record type. items (list): A list of records of the given feed type. Returns: (object): The return value from the feed function. Typically Node() generator. ''' func = self.core.getFeedFunc(name) if func is None: raise s_exc.NoSuchName(name=name) logger.info( f'User ({self.user.name}) adding feed data ({name}): {len(items)}') genr = func(self, items) if not isinstance(genr, types.AsyncGeneratorType): if isinstance(genr, types.CoroutineType): genr.close() mesg = f'feed func returned a {type(genr)}, not an async generator.' raise s_exc.BadCtorType(mesg=mesg, name=name) async for node in genr: yield node
async def _methQueueGet(self, name): info = self.runt.snap.core.multiqueue.queues.get(name) if info is None: mesg = f'No queue named {name}.' raise s_exc.NoSuchName(mesg=mesg) return Queue(self.runt, name, info)
async def _onTeleSyn(self, link, mesg): reply = ('tele:syn', { 'vers': self.televers, 'retn': (True, None), }) try: vers = mesg[1].get('vers') if vers[0] != s_telepath.televers[0]: raise s_exc.BadMesgVers(vers=vers, myvers=s_telepath.televers) path = () name = mesg[1].get('name') if not name: name = '*' if '/' in name: name, rest = name.split('/', 1) if rest: path = rest.split('/') item = self.shared.get(name) if item is None: raise s_exc.NoSuchName(name=name) sess = await Sess.anit() async def sessfini(): self.sessions.pop(sess.iden, None) sess.onfini(sessfini) link.onfini(sess.fini) self.sessions[sess.iden] = sess sess.conninfo = link.getAddrInfo() link.set('sess', sess) if isinstance(item, s_telepath.Aware): item = await s_coro.ornot(item.getTeleApi, link, mesg, path) if isinstance(item, s_base.Base): link.onfini(item) reply[1]['sharinfo'] = s_reflect.getShareInfo(item) sess.setSessItem(None, item) reply[1]['sess'] = sess.iden except Exception as e: logger.exception('tele:syn error') reply[1]['retn'] = s_common.retnexc(e) await link.tx(reply)
async def init(name, dirn, *args, **kwargs): ''' Initialize and return a Cell() object by alias. ''' ctor = ctors.get(name) if ctor is None: raise s_exc.NoSuchName(name=name, mesg='No cell ctor by that name') return await ctor.anit(dirn, *args, **kwargs)
async def getAhaProxy(urlinfo): ''' Return a telepath proxy by looking up a host from an aha registry. ''' host = urlinfo.get('host') if host is None: mesg = f'getAhaProxy urlinfo has no host: {urlinfo}' raise s_exc.NoSuchName(mesg=mesg) laste = None for ahaurl, cnfo in list(aha_clients.items()): client = cnfo.get('client') if client is None: client = await Client.anit(cnfo.get('url')) client._fini_atexit = True cnfo['client'] = client try: proxy = await client.proxy(timeout=10) ahasvc = await proxy.getAhaSvc(host) if ahasvc is None: continue svcinfo = ahasvc.get('svcinfo', {}) if not svcinfo.get('online'): continue info = mergeAhaInfo(urlinfo, svcinfo.get('urlinfo', {})) return await openinfo(info) except asyncio.CancelledError: # pragma: no cover raise except Exception as e: logger.exception(f'aha resolver ({ahaurl})') laste = e if laste is not None: raise laste mesg = f'aha lookup failed: {host}' raise s_exc.NoSuchName(mesg=mesg)
async def addFeedData(self, name, items): func = self.core.getFeedFunc(name) if func is None: raise s_exc.NoSuchName(name=name) logger.info( f'User ({self.user.name}) adding feed data ({name}): {len(items)}') await func(self, items)
def _getAuthItem(self, name): user = self.cell.auth.getUserByName(name) if user is not None: return user role = self.cell.auth.getRoleByName(name) if role is not None: return role raise s_exc.NoSuchName(name=name)
async def _liftByIndx(self, oper): # ('indx', (<dbname>, <prefix>, (<indxopers>...)) # indx opers: ('eq', <indx>) ('pref', <indx>) ('range', (<indx>, <indx>) name, pref, iops = oper[1] db = self.dbs.get(name) if db is None: raise s_exc.NoSuchName(name=name) for (name, valu) in iops: func = self.indxfunc.get(name) if func is None: mesg = 'unknown index operation' raise s_exc.NoSuchName(name=name, mesg=mesg) for row in func(db, pref, valu): yield row
async def _onTeleSyn(self, link, mesg): reply = ('tele:syn', { 'vers': self.televers, 'retn': (True, None), }) try: vers = mesg[1].get('vers') if vers[0] != s_telepath.televers[0]: raise s_exc.BadMesgVers(vers=vers, myvers=s_telepath.televers) name = mesg[1].get('name') item = self.shared.get(name) # allow a telepath aware object a shot at dynamic share names if item is None and name.find('/') != -1: path = name.split('/') base = self.shared.get(path[0]) if base is not None and isinstance(base, s_telepath.Aware): item = await s_coro.ornot(base.onTeleOpen, link, path) if item is None: raise s_exc.NoSuchName(name=name) sess = await Sess.anit() async def sessfini(): self.sessions.pop(sess.iden, None) sess.onfini(sessfini) link.onfini(sess.fini) self.sessions[sess.iden] = sess link.set('sess', sess) if isinstance(item, s_telepath.Aware): item = await s_coro.ornot(item.getTeleApi, link, mesg) if isinstance(item, s_base.Base): link.onfini(item.fini) sess.setSessItem(None, item) reply[1]['sess'] = sess.iden except Exception as e: logger.exception('tele:syn error') reply[1]['retn'] = s_common.retnexc(e) await link.tx(reply)
def deref(self, name): locl = self.locls.get(name, s_common.novalu) if locl is not s_common.novalu: return locl ctor = self.ctors.get(name) if ctor is not None: return ctor(path=self.path) raise s_exc.NoSuchName(name=name)
def _getAuthItem(self, name): # return user or role by name. user = self.cell.auth.users.get(name) if user is not None: return user role = self.cell.auth.roles.get(name) if role is not None: return role raise s_exc.NoSuchName(name=name)
async def _methQueueDel(self, name, allow=()): info = self.runt.snap.core.multiqueue.queues.get(name) if info is None: mesg = f'No queue named {name} exists.' raise s_exc.NoSuchName(mesg=mesg) if info.get('user') != self.runt.user.iden: self.runt.reqAllowed(('storm', 'queue', 'del', name)) await self.runt.snap.core.multiqueue.rem(name)
async def _liftByTagProp(self, oper): tag = oper[1].get('tag') form = oper[1].get('form') prop = oper[1].get('prop') iops = oper[1].get('iops') # #:prop name = prop db = self.by_tp_pi # #tag:prop if tag is not None: name = f'#{tag}:{prop}' db = self.by_tp_tpi # form#tag:prop if form is not None: name = f'{form}#{tag}:{prop}' db = self.by_tp_ftpi abrv = self.getNameAbrv(name) if iops is None: for lkey, buid in self.layrslab.scanByPref(abrv, db=db): yield (buid, ) return for iopr in iops: if iopr[0] == 'eq': for lkey, buid in self.layrslab.scanByDups(abrv + iopr[1], db=db): yield (buid, ) continue if iopr[0] == 'pref': for lkey, buid in self.layrslab.scanByPref(abrv + iopr[1], db=db): yield (buid, ) continue if iopr[0] == 'range': kmin = abrv + iopr[1][0] kmax = abrv + iopr[1][1] for lkey, buid in self.layrslab.scanByRange(kmin, kmax, db=db): yield (buid, ) continue #pragma: no cover mesg = f'No such index function for tag props: {iopr[0]}' raise s_exc.NoSuchName(name=iopr[0], mesg=mesg)
def status(self, name): meta = self.queues.get(name) if meta is None: mesg = f'No queue named {name}' raise s_exc.NoSuchName(mesg=mesg, name=name) return { 'name': name, 'meta': meta, 'size': self.sizes.get(name), 'offs': self.offsets.get(name), }
def deref(self, name): try: return StormType.deref(self, name) except s_exc.NoSuchName as e: pass path = self.name + (name, ) slib = self.runt.snap.core.getStormLib(path) if slib is None: raise s_exc.NoSuchName(name=name) ctor = slib[2].get('ctor', Lib) return ctor(self.runt, name=path)
async def rem(self, name): if self.queues.get(name) is None: mesg = f'No queue named {name}.' raise s_exc.NoSuchName(mesg=mesg, name=name) await self.cull(name, 0xffffffffffffffff) self.queues.pop(name) self.offsets.pop(name) evnt = self.waiters.pop(name, None) if evnt is not None: evnt.set()
async def getAuthInfo(self, name): s_common.deprecated('getAuthInfo') user = await self.cell.auth.getUserByName(name) if user is not None: info = user.pack() info['roles'] = [ self.cell.auth.role(r).name for r in info['roles'] ] return info role = await self.cell.auth.getRoleByName(name) if role is not None: return role.pack() raise s_exc.NoSuchName(name=name)
async def _funcMacroDel(self, name): name = await s_stormtypes.tostr(name) path = ('cortex', 'storm', 'macros', name) mdef = await self.runt.snap.core.getHiveKey(path) if mdef is None: mesg = f'Macro name not found: {name}' raise s_exc.NoSuchName(mesg) user = self.runt.user if mdef['user'] != user.iden and not user.isAdmin(): mesg = 'Macro belongs to a different user' raise s_exc.AuthDeny(mesg=mesg) await self.runt.snap.core.popHiveKey(path)
async def addFeedData(self, name, items): func = self.core.getFeedFunc(name) if func is None: raise s_exc.NoSuchName(name=name) logger.info(f'adding feed data ({name}): {len(items)}') retn = func(self, items) # If the feed function is an async generator, run it... if isinstance(retn, types.AsyncGeneratorType): retn = [x async for x in retn] elif s_coro.iscoro(retn): await retn
def _addFormIface(self, form, name): iface = self.ifaces.get(name) if iface is None: mesg = f'Form {form.name} depends on non-existant interface: {name}' raise s_exc.NoSuchName(mesg=mesg) for propname, typedef, propinfo in iface.get('props', ()): self._addFormProp(form, propname, typedef, propinfo) # TODO use this to allow storm: +foo:iface form.ifaces[name] = iface self.formsbyiface[name].append(form) for ifname in iface.get('interfaces', ()): self._addFormIface(form, ifname)
async def run(self, runt, genr): name = self.kids[0].value() argv = self.kids[1].value() ctor = runt.snap.core.getStormCmd(name) if ctor is None: mesg = 'Storm command not found.' raise s_exc.NoSuchName(name=name, mesg=mesg) scmd = ctor(argv) if not await scmd.hasValidOpts(runt.snap): return async for item in scmd.execStormCmd(runt, genr): yield item