def test_telepath_push(self):
# override default timeout=None for tests
with s_scope.enter({'syntimeout': 3}):
env = self.getFooEnv()
port = env.link[1].get('port')
prox0 = s_telepath.openurl('tcp://127.0.0.1/',
port=port) # type: s_telepath.Proxy
prox0.push('foo1', Foo())
prox1 = s_telepath.openurl('tcp://127.0.0.1/foo1',
port=port) # type: s_telepath.Proxy
self.eq(prox1.bar(10, 20), 30)
wait0 = env.dmon.waiter(1, 'tele:push:fini')
prox0.fini()
self.nn(wait0.wait(timeout=2))
self.raises(NoSuchObj, prox1.bar, 10, 20)
prox1.fini()
env.fini()
def test_lib_scope_enter(self):
with s_scope.enter({'woot': 10}):
self.eq(s_scope.get('woot'), 10)
self.assertIsNone(s_scope.get('newp'))
self.assertIsNone(s_scope.get('woot'))
self.assertIsNone(s_scope.get('newp'))
def test_socket_glob_plex(self):
plex0 = s_scope.get('plex')
self.nn(plex0)
with s_scope.enter():
plex1 = s_socket.Plex()
s_scope.set('plex', plex1)
self.ne(id(plex0), id(s_scope.get('plex')))
plex1.fini()
self.eq(id(plex0), id(s_scope.get('plex')))
def loadDmonConf(self, conf):
'''
{
'title':'The Foo Thing',
'vars':{
'foo':10,
'bar':["baz","faz"]
}
'forks':(
('name',{
# nested config for forked dmon
},
),
'includes':(
'~/foo/config.json',
),
'cells':(
(<dirn>, <conf>),
),
'ctors':(
('baz', 'ctor://foo.bar.Baz()'),
('faz', 'ctor://foo.bar.Baz()', {'config':'woot'}),
('mybus', 'tcp://host.com/syn.svcbus'),
),
'services':(
('mybus',(
('baz',{'tags':('foo.bar','baz')}),
),
),
'addons':(
('auth','tcp://host.com:8899/synauth'),
('logging','ctor://mypkg.mymod.MyLogger()'),
),
'configs':{
'woot':{
'fooopt':10,
},
},
}
'''
with s_scope.enter({'dmon': self}):
return self._loadDmonConf(conf)
def runas(user):
'''
Construct and return a with-block object which runs as the given
synapse user name.
Example:
import synapse.lib.auth as s_auth
s_auth.runas('visi@localhost'):
# calls from here down may use check user/perms
dostuff()
'''
with s_scope.enter({'syn:user': user}):
yield
def asSynUser(user, auth=None, **locs):
'''
Construct and return a with-block object which runs as the given
synapse user name. Locs may be optionally populated with additional
items to be added to the LocalScope instance.
Example:
import synapse.lib.userauth as s_userauth
s_userauth.asSynUser('visi@localhost'):
# calls from here down may use check user/perms
dostuff()
'''
with s_scope.enter({'syn:user': user, 'syn:auth': auth}):
yield
def test_async_wait_syntimeout(self):
def longtime():
time.sleep(0.1)
boss = s_async.Boss()
boss.runBossPool(1)
jid = s_async.jobid()
task = s_async.newtask(longtime)
boss.initJob(jid, task=task)
with s_scope.enter({'syntimeout': 0.01}):
self.assertFalse(boss.wait(jid))
self.assertTrue(boss.wait(jid, timeout=1))
boss.fini()
async def test_lib_scope_enter(self):
with s_scope.enter({'woot': 10}):
self.eq(s_scope.get('woot'), 10)
self.none(s_scope.get('newp'))
self.none(s_scope.get('woot'))
self.none(s_scope.get('newp'))
scope = s_scope.Scope()
scope.enter({'yes': 1})
self.eq(scope.get('yes'), 1)
scope.set('no', 0)
frame = scope.leave()
self.eq(frame, {'yes': 1, 'no': 0})
self.none(scope.get('yes'))
self.none(scope.get('no'))
self.raises(IndexError, scope.leave)
async def test_lib_scope_enter(self):
with s_scope.enter({'woot': 10}):
self.eq(s_scope.get('woot'), 10)
self.none(s_scope.get('newp'))
self.none(s_scope.get('woot'))
self.none(s_scope.get('newp'))
scope = s_scope.Scope()
scope.enter({'yes': 1})
self.eq(scope.get('yes'), 1)
scope.set('no', 0)
frame = scope.leave()
self.eq(frame, {'yes': 1, 'no': 0})
self.none(scope.get('yes'))
self.none(scope.get('no'))
self.raises(IndexError, scope.leave)
def test_telepath_push(self):
# override default timeout=None for tests
with s_scope.enter({'syntimeout': 5}):
env = self.getFooEnv()
port = env.link[1].get('port')
prox0 = s_telepath.openurl('tcp://127.0.0.1/', port=port)
prox0.push('foo1', Foo())
prox1 = s_telepath.openurl('tcp://127.0.0.1/foo1', port=port)
self.eq(prox1.bar(10, 20), 30)
prox0.fini()
self.assertRaises(s_async.JobErr, prox1.bar, 10, 20)
prox1.fini()
env.fini()
def _onTeleCallMesg(self, sock, mesg):
# tele:call - call a method on a shared object
jid = mesg[1].get('jid')
sid = mesg[1].get('sid')
# check if the socket knows about their auth
# ( most likely via SSL client cert )
user = sock.get('syn:user')
with s_scope.enter({
'dmon': self,
'sock': sock,
'syn:user': user,
'syn:auth': self.auth
}):
try:
name = mesg[1].get('name')
item = self.shared.get(name)
if item is None:
# is it a pushed object?
pushsock = self.pushed.get(name)
if pushsock is not None:
# pass along how to reply
mesg[1]['suid'] = sock.iden
return pushsock.tx(mesg)
raise s_common.NoSuchObj(name)
task = mesg[1].get('task')
meth, args, kwargs = task
self._reqUserAllowed(user, 'tele:call', name, meth)
func = getattr(item, meth, None)
if func is None:
raise s_common.NoSuchMeth(meth)
if getattr(func, '_tele_clientside', False):
name = s_reflect.getMethName(func)
raise s_common.TeleClientSide(name=name)
ret = func(*args, **kwargs)
# handle generator returns specially
if isinstance(ret, types.GeneratorType):
iden = s_common.guid()
txwait = threading.Event()
# start off set...
txwait.set()
self._dmon_yields.add(iden)
sock.tx(
s_common.tufo('tele:yield:init', jid=jid, iden=iden))
# FIXME opt
maxsize = 100000000
def ontxsize(m):
size = m[1].get('size')
if size >= maxsize:
txwait.clear()
else:
txwait.set()
try:
sock.onfini(txwait.set)
sock.on('sock:tx:size', ontxsize)
for item in ret:
txwait.wait()
# check if we woke due to fini
if sock.isfini:
break
sock.tx(
s_common.tufo('tele:yield:item',
iden=iden,
item=item))
if iden not in self._dmon_yields:
break
finally:
sock.off('sock:tx:size', ontxsize)
self._dmon_yields.discard(iden)
sock.tx(s_common.tufo('tele:yield:fini', iden=iden))
return
sock.tx(s_common.tufo('job:done', jid=jid, ret=ret))
except Exception as e:
sock.tx(
s_common.tufo('job:done', jid=jid, **s_common.excinfo(e)))
