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
