def test_daemon_on(self):
class Foo:
def bar(self):
return 'baz'
dmon = s_daemon.Daemon()
link = dmon.listen('tcp://127.0.0.1:0/')
bus = s_eventbus.EventBus()
foo = Foo()
dmon.share('bus', bus)
dmon.share('foo', foo)
port = link[1].get('port')
bprox = s_telepath.openurl('tcp://127.0.0.1/bus', port=port)
fprox = s_telepath.openurl('tcp://127.0.0.1/foo', port=port)
evt = threading.Event()
def woot(mesg):
evt.set()
bprox.on('woot', woot)
fprox.on('woot', woot)
bus.fire('woot')
evt.wait(timeout=2)
fprox.off('woot', woot)
self.true(evt.is_set())
def test_daemon_on(self):
class Foo:
def bar(self):
return "baz"
dmon = s_daemon.Daemon()
link = dmon.listen("tcp://127.0.0.1:0/")
bus = s_eventbus.EventBus()
foo = Foo()
dmon.share("bus", bus)
dmon.share("foo", foo)
port = link[1].get("port")
bprox = s_telepath.openurl("tcp://127.0.0.1/bus", port=port)
fprox = s_telepath.openurl("tcp://127.0.0.1/foo", port=port)
evt = threading.Event()
def woot(mesg):
evt.set()
bprox.on("woot", woot)
fprox.on("woot", woot)
bus.fire("woot")
evt.wait(timeout=2)
fprox.off("woot", woot)
self.assertTrue(evt.is_set())
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_telepath_events(self):
with s_daemon.Daemon() as dmon:
with s_service.SvcBus() as sbus:
urlt = 'tcp://127.0.0.1:%d'
url = urlt % (0)
link = dmon.listen(url)
port = link[1].get('port')
url = urlt % (port)
dmon.share('sbus', sbus)
proxy0 = s_telepath.openurl(url + '/sbus')
proxy1 = s_telepath.openurl(url + '/sbus')
counters = [0, 0]
def count(offset):
def on(*args, **kwargs):
counters[offset] += 1
return on
proxy0.on('tufo:tag:add', count(0))
proxy1.on('tufo:tag:add', count(1))
wait = s_eventbus.Waiter(proxy1, 1, 'tufo:tag:add')
proxy0.fire('tufo:tag:add',
tag='tagu',
tufo=('iden', {
'prop': 'valu'
}))
wait.wait()
self.assertEqual(counters[0], 1)
self.assertEqual(counters[1], 1)
def test_daemon_on(self):
class Foo:
def bar(self):
return 'baz'
dmon = s_daemon.Daemon()
link = dmon.listen('tcp://127.0.0.1:0/')
bus = s_eventbus.EventBus()
foo = Foo()
dmon.share('bus', bus)
dmon.share('foo', foo)
port = link[1].get('port')
bprox = s_telepath.openurl('tcp://127.0.0.1/bus', port=port)
fprox = s_telepath.openurl('tcp://127.0.0.1/foo', port=port)
evt = threading.Event()
def woot(mesg):
evt.set()
bprox.on('woot', woot)
fprox.on('woot', woot)
bus.fire('woot')
evt.wait(timeout=2)
fprox.off('woot', woot)
self.assertTrue( evt.is_set() )
def test_telepath_events(self):
with s_daemon.Daemon() as dmon:
with s_service.SvcBus() as sbus:
urlt = 'tcp://127.0.0.1:%d'
url = urlt % (0)
link = dmon.listen(url)
port = link[1].get('port')
url = urlt % (port)
dmon.share('sbus', sbus)
proxy0 = s_telepath.openurl(url + '/sbus')
proxy1 = s_telepath.openurl(url + '/sbus')
counters = collections.defaultdict(int)
def count(name):
def onmesg(mesg):
counters[name] += 1
return onmesg
proxy0.on('foo:bar', count('p0'))
proxy1.on('foo:bar', count('p1'))
func = count('f0')
proxy1.on('foo:bar', func, tag='hehe')
wait = proxy1.waiter(1, 'foo:bar')
proxy0.fire('foo:bar', tag='tagu', tufo=('iden', {'prop': 'valu'}))
self.nn(wait.wait(timeout=2))
self.eq(counters['p0'], 1)
self.eq(counters['p1'], 1)
self.eq(counters['f0'], 0)
wait = proxy1.waiter(1, 'foo:bar')
proxy0.fire('foo:bar', tag='hehe', tufo=('iden', {'prop': 'valu'}))
self.nn(wait.wait(timeout=2))
self.eq(counters['p0'], 2)
self.eq(counters['p1'], 2)
self.eq(counters['f0'], 1)
proxy1.off('foo:bar', func)
wait = proxy1.waiter(1, 'foo:bar')
proxy0.fire('foo:bar', tag='hehe', tufo=('iden', {'prop': 'valu'}))
self.nn(wait.wait(timeout=2))
self.eq(counters['p0'], 3)
self.eq(counters['p1'], 3)
self.eq(counters['f0'], 1)
proxy0.fini()
proxy1.fini()
def getHiveEnv(self):
#FIXME remove when synapse link local:// supports windows
self.thisHostMustNot(platform='windows')
dmon = s_daemon.Daemon()
queen = s_hivemind.Queen()
dmon.share('syn.queen', queen)
link = dmon.listen('tcp://127.0.0.1:0/')
port = link[1].get('port')
qprox = s_telepath.openurl('tcp://127.0.0.1/syn.queen', port=port)
hive = s_hivemind.Hive(qprox, size=32)
drone = s_hivemind.Drone(qprox, size=2)
env = TestEnv()
# order matters for fini calls...
env.add('hive', hive, fini=True)
env.add('drone', drone, fini=True)
env.add('qprox', qprox, fini=True)
env.add('queen', queen, fini=True)
env.add('dmon', dmon, fini=True)
return env
def test_model_file_bytes_axon(self):
self.skipLongTest()
with self.getAxonCore() as env:
with s_daemon.Daemon() as dmon:
dmonlink = dmon.listen('tcp://127.0.0.1:0/')
dmonport = dmonlink[1].get('port')
dmon.share('core', env.core)
coreurl = 'tcp://127.0.0.1:%d/core' % dmonport
core = s_telepath.openurl(coreurl)
node = core.formNodeByBytes(b'visi', name='visi.bin')
self.eq(node[1].get('file:bytes:size'), 4)
self.eq(node[1].get('file:bytes:name'), 'visi.bin')
self.eq(node[1].get('file:bytes'), '442f602ecf8230b2a59a44b4f845be27')
self.eq(node[1].get('file:bytes:md5'), '1b2e93225959e3722efed95e1731b764')
self.eq(node[1].get('file:bytes:sha1'), '93de0c7d579384feb3561aa504acd8f23f388040')
self.eq(node[1].get('file:bytes:sha256'), 'e45bbb7e03acacf4d1cca4c16af1ec0c51d777d10e53ed3155bd3d8deb398f3f')
self.eq(node[1].get('file:bytes:sha512'), '8238be12bcc3c10da7e07dbea528e9970dc809c07c5aef545a14e5e8d2038563b'
'29c2e818d167b06e6a33412e6beb8347fcc44520691347aea9ee21fcf804e39')
fd = io.BytesIO(b'foobar')
node = core.formNodeByFd(fd, name='foobar.exe')
self.eq(node[1].get('file:bytes:size'), 6)
self.eq(node[1].get('file:bytes:name'), 'foobar.exe')
def initCellAuth(self):
# To avoid import cycle
import synapse.lib.auth as s_auth
valu = self.boot.get('auth:en')
if not valu:
return
url = self.boot.get('auth:url')
if url is not None:
self.auth = s_telepath.openurl(url)
return
# setup local auth
dirn = s_common.gendir(self.dirn, 'auth')
self.auth = s_auth.Auth(dirn) # FIXME this is not imported, but would cause circular import
# let them hard code an initial admin user:passwd
admin = self.boot.get('auth:admin')
if admin is not None:
name, passwd = admin.split(':', 1)
user = self.auth.getUser(name)
if user is None:
user = self.auth.addUser(name)
user.setAdmin(True)
user.setPasswd(passwd)
def getDmonCore(self):
'''
Context manager to make a ram:/// cortex which has test models loaded into it and shared via daemon.
Yields:
s_cores_common.Cortex: A proxy object to the Ram backed cortex with test models.
'''
dmon = s_daemon.Daemon()
core = s_cortex.openurl('ram:///')
self.addTstForms(core)
link = dmon.listen('tcp://127.0.0.1:0/')
dmon.share('core00', core)
port = link[1].get('port')
prox = s_telepath.openurl('tcp://127.0.0.1/core00', port=port)
s_scope.set('syn:test:link', link)
s_scope.set('syn:cmd:core', prox)
try:
yield prox
except: # pragma: no cover
raise
finally:
prox.fini()
core.fini()
dmon.fini()
def test_telepath_reshare(self):
env0 = self.getFooEnv()
env1 = self.getFooEnv()
port = env0.link[1].get('port')
prox0 = s_telepath.openurl('tcp://127.0.0.1/foo', port=port)
env1.dmon.share('bar', prox0)
port = env1.link[1].get('port')
prox1 = s_telepath.openurl('tcp://127.0.0.1/bar', port=port)
self.eq(prox1.bar(33, 44), 77)
env0.fini()
env1.fini()
def test_cortex_xact_deadlock(self):
N = 100
prop = 'testform'
fd = tempfile.NamedTemporaryFile()
dmon = s_daemon.Daemon()
pool = s_threads.Pool(size=4, maxsize=8)
wait = s_eventbus.Waiter(pool, 1, 'pool:work:fini')
with s_cortex.openurl('sqlite:///%s' % fd.name) as core:
def populate():
for i in range(N):
#print('wrote %d tufos' % i)
core.formTufoByProp(prop, str(i), **{})
dmon.share('core', core)
link = dmon.listen('tcp://127.0.0.1:0/core')
prox = s_telepath.openurl('tcp://127.0.0.1:%d/core' % link[1]['port'])
pool.wrap(populate)()
for i in range(N):
tufos = prox.getTufosByProp(prop)
#print('got %d tufos' % len(tufos))
wait.wait()
pool.fini()
async def test_cell_nonstandard_admin(self):
boot = {
'auth:admin': 'pennywise:cottoncandy',
'type': 'echoauth',
}
pconf = {'user': '******', 'passwd': 'cottoncandy'}
with self.getTestDir('cellauth') as dirn:
s_common.yamlsave(boot, dirn, 'boot.yaml')
async with await EchoAuth.anit(dirn) as echo:
echo.insecure = False
# start a regular network listener so we can auth
host, port = await echo.dmon.listen('tcp://127.0.0.1:0/')
async with await s_telepath.openurl(f'tcp://127.0.0.1:{port}/', **pconf) as proxy:
self.true(await proxy.isadmin())
self.true(await proxy.allowed(('hehe', 'haha')))
url = f'tcp://[email protected]:{port}/'
await self.asyncraises(s_exc.AuthDeny, s_telepath.openurl(url))
# Ensure the cell and its auth have been fini'd
self.true(echo.isfini)
self.true(echo.auth.isfini)
self.true(echo.auth.getUserByName('root').isfini)
self.true(echo.auth.getUserByName('pennywise').isfini)
def test_telepath_fakesync(self):
env = self.getFooEnv()
port = env.link[1].get('port')
class DeadLock(s_eventbus.EventBus):
def hork(self):
self.fire('foo:bar')
def bar(self, x, y):
return x + y
dead = DeadLock()
env.dmon.share('dead', dead)
data = {}
evt = threading.Event()
prox = s_telepath.openurl('tcp://127.0.0.1/dead', port=port)
def foobar(mesg):
data['foobar'] = prox.bar(10, 20)
evt.set()
prox.on('foo:bar', foobar)
prox.hork()
evt.wait(timeout=2)
self.eq(data.get('foobar'), 30)
prox.fini()
dead.fini()
env.fini()
def test_service_base(self):
sbus = s_service.SvcBus()
dmon = s_daemon.Daemon()
dmon.share('syn.svcbus', sbus)
link = dmon.listen('tcp://127.0.0.1:0/')
port = link[1].get('port')
prox = s_telepath.openurl('tcp://127.0.0.1/syn.svcbus', port=port)
woot = Woot()
s_service.runSynSvc('syn.woot', woot, prox)
svcs = prox.getSynSvcs()
self.assertEqual( len(svcs), 1 )
self.assertEqual( svcs[0][1].get('name'), 'syn.woot' )
dyntask = s_async.newtask('foo',10,y=30)
job = prox.callx(svcs[0][0], dyntask)
self.assertEqual( prox.sync(job), 40 )
prox.fini()
dmon.fini()
sbus.fini()
def getHiveEnv(self):
#FIXME remove when synapse link local:// supports windows
self.thisHostMustNot(platform='windows')
dmon = s_daemon.Daemon()
queen = s_hivemind.Queen()
dmon.share('syn.queen', queen)
link = dmon.listen('tcp://127.0.0.1:0/')
port = link[1].get('port')
qprox = s_telepath.openurl('tcp://127.0.0.1/syn.queen', port=port)
hive = s_hivemind.Hive(qprox, size=32)
drone = s_hivemind.Drone(qprox, size=2)
env = TestEnv()
# order matters for fini calls...
env.add('hive', hive, fini=True)
env.add('drone', drone, fini=True)
env.add('qprox', qprox, fini=True)
env.add('queen', queen, fini=True)
env.add('dmon', dmon, fini=True)
return env
def test_telepath_reshare(self):
env0 = self.getFooEnv()
env1 = self.getFooEnv()
port = env0.link[1].get('port')
prox0 = s_telepath.openurl('tcp://127.0.0.1/foo', port=port)
env1.dmon.share('bar', prox0)
port = env1.link[1].get('port')
prox1 = s_telepath.openurl('tcp://127.0.0.1/bar', port=port)
self.assertEqual( prox1.bar(33,44), 77 )
env0.fini()
env1.fini()
def test_service_base(self):
with s_daemon.Daemon() as dmon:
sbus = s_service.SvcBus()
dmon.share('syn.svcbus', sbus, fini=True)
link = dmon.listen('tcp://127.0.0.1:0/')
port = link[1].get('port')
with s_telepath.openurl('tcp://127.0.0.1/syn.svcbus',
port=port) as prox:
woot = Woot()
s_service.runSynSvc('syn.woot', woot, prox)
svcs = prox.getSynSvcs()
self.eq(len(svcs), 1)
self.eq(svcs[0][1].get('name'), 'syn.woot')
dyntask = s_async.newtask('foo', 10, y=30)
job = prox.callx(svcs[0][0], dyntask)
self.eq(prox.syncjob(job), 40)
def test_telepath_reconnect(self):
tenv = self.getFooEnv()
port = tenv.link[1].get('port')
prox = s_telepath.openurl('tcp://127.0.0.1/foo', port=port)
url = 'tcp://127.0.0.1:%d/foo' % (port, )
self.eq(prox.bar(10, 20), 30)
waiter = self.getTestWait(prox, 1, 'tele:sock:init')
# shut down the daemon
tenv.dmon.fini()
dmon = s_daemon.Daemon()
dmon.share('foo', Foo())
dmon.listen(url)
waiter.wait()
self.eq(prox.bar(10, 20), 30)
prox.fini()
dmon.fini()
tenv.fini()
def test_telepath_fakesync(self):
env = self.getFooEnv()
port = env.link[1].get('port')
class DeadLock(s_eventbus.EventBus):
def hork(self):
self.fire('foo:bar')
def bar(self, x, y):
return x + y
dead = DeadLock()
env.dmon.share('dead',dead)
data = {}
evt = threading.Event()
prox = s_telepath.openurl('tcp://127.0.0.1/dead', port=port)
def foobar(mesg):
data['foobar'] = prox.bar(10,20)
evt.set()
prox.on('foo:bar', foobar)
prox.hork()
evt.wait(timeout=2)
self.assertEqual( data.get('foobar'), 30 )
prox.fini()
dead.fini()
env.fini()
async def test_cell_nonstandard_admin(self):
boot = {
'auth:admin': 'pennywise:cottoncandy',
'type': 'echoauth',
}
pconf = {'user': '******', 'passwd': 'cottoncandy'}
with self.getTestDir('cellauth') as dirn:
s_common.yamlsave(boot, dirn, 'boot.yaml')
async with await EchoAuth.anit(dirn) as echo:
echo.insecure = False
# start a regular network listener so we can auth
host, port = await echo.dmon.listen('tcp://127.0.0.1:0/')
async with await s_telepath.openurl(f'tcp://127.0.0.1:{port}/',
**pconf) as proxy:
self.true(await proxy.isadmin())
self.true(await proxy.allowed('hehe', 'haha'))
url = f'tcp://[email protected]:{port}/'
await self.asyncraises(s_exc.AuthDeny, s_telepath.openurl(url))
# Ensure the cell and its auth have been fini'd
self.true(echo.isfini)
self.true(echo.auth.isfini)
self.true(echo.auth.getUserByName('root').isfini)
self.true(echo.auth.getUserByName('pennywise').isfini)
def test_daemon_conf_fork(self):
self.thisHostMustNot(platform='windows')
iden = guid()
conf = {
'forks': (('fork0', {
'ctors':
(('haha', 'ctor://synapse.tests.test_daemon.Woot()'), ),
'share': (('haha', {}), ),
'listen': ('local://%s' % (iden, ), ),
}), ),
}
dmon = s_daemon.Daemon()
dmon.loadDmonConf(conf)
prox = s_telepath.openurl('local://%s/haha?retry=20' % (iden, ))
pid0 = prox.pid()
self.ne(pid0, os.getpid())
prox.fini()
#dmon.killDmonFork('fork0')
#prox = s_telepath.openurl('local://%s/haha?retry=6' % (iden,))
#pid1 = prox.pid()
#self.assertNotEqual( pid0, pid1 )
#self.assertNotEqual( pid1, os.getpid() )
#prox.fini()
dmon.fini()
def test_telepath_reconnect(self):
tenv = self.getFooEnv()
port = tenv.link[1].get('port')
prox = s_telepath.openurl('tcp://127.0.0.1/foo', port=port)
url = 'tcp://127.0.0.1:%d/foo' % (port,)
self.assertEqual( prox.bar(10,20), 30 )
waiter = self.getTestWait(prox, 1, 'tele:sock:init')
# shut down the daemon
tenv.dmon.fini()
dmon = s_daemon.Daemon()
dmon.share('foo',Foo())
dmon.listen(url)
waiter.wait()
self.assertEqual( prox.bar(10,20), 30 )
prox.fini()
dmon.fini()
tenv.fini()
def main(argv, outp=None):
if outp is None:
outp = s_output.OutPut()
p = getArgParser()
opts = p.parse_args(argv)
core = s_telepath.openurl(opts.cortex)
tags = []
if opts.tags:
for tag in opts.tags.split(','):
tags.append(tag)
if tags:
outp.printf('adding tags: %r' % (tags, ))
for path in opts.filenames:
with open(path, 'rb') as fd:
base = os.path.basename(path)
node = core.formNodeByFd(fd, name=base)
core.addTufoTags(node, tags)
iden = node[1].get('file:bytes')
size = node[1].get('file:bytes:size')
name = node[1].get('file:bytes:name')
outp.printf('file: %s (%d) added (%s) as %s' %
(base, size, iden, name))
def test_link_ssl_auth(self):
# FIXME some kind of cert validation diffs in *py* vers killed us
cafile = getTestPath('ca.crt')
keyfile = getTestPath('server.key')
certfile = getTestPath('server.crt')
userkey = getTestPath('user.key')
usercert = getTestPath('user.crt')
with s_daemon.Daemon() as dmon:
dmon.share('foobar', FooBar())
link = dmon.listen('ssl://localhost:0/',
cafile=cafile,
keyfile=keyfile,
certfile=certfile)
port = link[1].get('port')
url = 'ssl://localhost/foobar'
with s_telepath.openurl(url,
port=port,
cafile=cafile,
keyfile=userkey,
certfile=usercert) as foo:
self.assertEqual(foo.foo(), 'bar')
def test_service_base(self):
sbus = s_service.SvcBus()
dmon = s_daemon.Daemon()
dmon.share('syn.svcbus', sbus)
link = dmon.listen('tcp://127.0.0.1:0/')
port = link[1].get('port')
prox = s_telepath.openurl('tcp://127.0.0.1/syn.svcbus', port=port)
woot = Woot()
s_service.runSynSvc('syn.woot', woot, prox)
svcs = prox.getSynSvcs()
self.assertEqual( len(svcs), 1 )
self.assertEqual( svcs[0][1].get('name'), 'syn.woot' )
dyntask = s_async.newtask('foo',10,y=30)
job = prox.callx(svcs[0][0], dyntask)
self.assertEqual( prox.syncjob(job), 40 )
prox.fini()
dmon.fini()
sbus.fini()
def test_telepath_nosuchobj(self):
dmon,link = self.getFooServ()
port = link[1].get('port')
newp = s_telepath.openurl('tcp://localhost:%d/newp' % (port,))
self.assertRaises( JobErr, newp.foo )
dmon.fini()
def test_telepath_nosuchobj(self):
dmon, link = self.getFooServ()
port = link[1].get('port')
newp = s_telepath.openurl('tcp://localhost:%d/newp' % (port, ))
self.raises(SynErr, newp.foo)
dmon.fini()
def test_telepath_push(self):
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 test_telepath_push(self):
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()
async def test_telepath_auth(self):
item = TeleAuth()
async with self.getTestDmon() as dmon:
dmon.share('auth', item)
host, port = dmon.addr
url = 'tcp://localhost/auth'
await self.asyncraises(s_exc.AuthDeny,
s_telepath.openurl(url, port=port))
url = 'tcp://visi@localhost/auth'
await self.asyncraises(s_exc.AuthDeny,
s_telepath.openurl(url, port=port))
url = 'tcp://*****:*****@localhost/auth'
async with await s_telepath.openurl(url, port=port) as proxy:
self.eq(17, await proxy.getFooBar(10, 7))
def test_hypnos_with_telepath(self):
# Setup the Hypnos object using telepath, then get the proxy object and
# issue the fireWebApi calls via telepath, validate that they worked
# against ingested tufo in the hypnos cortex. Use daemon to handle
# telepath proxying.
self.thisHostMustNot(platform='windows')
self.skipIfNoInternet()
gconf = get_fake_ipify_ingest_global_config(port=self.port)
dconf = {
'vars': {
'hopts': {
s_remcycle.MIN_WORKER_THREADS: 1,
},
'hioloop': self.io_loop,
'cortex_url': 'ram://'
},
'ctors':
[['core', 'ctor://synapse.cortex.openurl(cortex_url)'],
[
'hypnos',
'ctor://synapse.lib.remcycle.Hypnos(core=core, ioloop=hioloop,opts=hopts)'
]],
'share': [['hypnos', {}], ['core', {}]],
'listen': ['tcp://127.0.0.1:50001']
}
dmon = s_daemon.Daemon()
dmon.loadDmonConf(dconf)
hypnos_proxy = s_telepath.openurl('tcp://127.0.0.1:50001/hypnos')
core_proxy = s_telepath.openurl('tcp://127.0.0.1:50001/core')
# Lets do a remote config load!
hypnos_proxy.addWebConfig(config=gconf)
description = hypnos_proxy.getWebDescription()
self.true('fakeipify' in description)
# Fire the web api
jid = hypnos_proxy.fireWebApi(name='fakeipify:jsonip')
self.nn(jid)
hypnos_proxy.webJobWait(jid)
tufos = core_proxy.getTufosByProp('inet:ipv4')
self.eq(len(tufos), 1)
ip = s_inet.ipv4str(tufos[0][1].get('inet:ipv4'))
self.true(len(ip) >= 7)
async def test_telepath_basics(self):
foo = Foo()
evt = asyncio.Event()
async with self.getTestDmon() as dmon:
addr = await dmon.listen('tcp://127.0.0.1:0')
dmon.share('foo', foo)
await self.asyncraises(s_exc.BadUrl,
s_telepath.openurl('noscheme/foo'))
prox = await s_telepath.openurl('tcp://127.0.0.1/foo',
port=addr[1])
# Prox exposes remote synapse version
self.eq(prox._getSynVers(), s_version.version)
# Prox exposes reflected classes
self.eq(prox._getClasses(), ('synapse.tests.test_telepath.Foo', ))
# Add an additional prox.fini handler.
prox.onfini(evt.set)
# check a standard return value
self.eq(30, await prox.bar(10, 20))
# check a coroutine return value
self.eq(25, await prox.corovalu(10, 5))
# check a generator return channel
genr = await prox.genr()
self.true(isinstance(genr, s_coro.GenrHelp))
self.eq((10, 20, 30), await genr.list())
# check generator explodes channel
genr = await prox.genrboom()
await self.asyncraises(s_exc.SynErr, genr.list())
# check an async generator return channel
genr = prox.corogenr(3)
self.true(isinstance(genr, s_telepath.GenrIter))
self.eq((0, 1, 2), await alist(genr))
await self.asyncraises(s_exc.NoSuchMeth, prox.raze())
await self.asyncraises(s_exc.NoSuchMeth, prox.fake())
await self.asyncraises(s_exc.SynErr, prox.boom())
# Fini'ing a daemon fini's proxies connected to it.
self.true(await s_coro.event_wait(evt, 2))
self.true(prox.isfini)
await self.asyncraises(s_exc.IsFini, prox.bar((10, 20)))
def getNeuNet(self):
env = TestEnv()
dmon = s_daemon.Daemon()
env.add('dmon',dmon,fini=True)
link = dmon.listen('tcp://127.0.0.1:0/')
neu0 = s_neuron.Neuron()
env.add('neu0', s_neuron.Neuron(), fini=True)
env.add('neu1', s_neuron.Neuron(), fini=True)
env.add('neu2', s_neuron.Neuron(), fini=True)
env.dmon.share('neu0', env.neu0)
env.dmon.share('neu1', env.neu1)
env.dmon.share('neu2', env.neu2)
#dmon.onfini( neu0.fini )
#dmon.onfini( neu1.fini )
#dmon.onfini( neu2.fini )
#dmon.share('neu0',neu0)
#dmon.share('neu1',neu1)
#dmon.share('neu2',neu2)
port = link[1].get('port')
env.add('neup0', s_telepath.openurl('tcp://127.0.0.1/neu0', port=port), fini=True)
env.add('neup1', s_telepath.openurl('tcp://127.0.0.1/neu1', port=port), fini=True)
env.add('neup2', s_telepath.openurl('tcp://127.0.0.1/neu2', port=port), fini=True)
wai0 = TestWaiter(env.neu1, 1, 'neu:link:init')
env.neu0.link( env.neup1 )
wai0.wait()
wai0 = TestWaiter(env.neu1, 1, 'neu:link:init')
env.neu0.link( env.neup2 )
wai0.wait()
return env
async def test_telepath_server_badvers(self):
async with self.getTestDmon() as dmon:
dmon.televers = (0, 0)
host, port = await dmon.listen('tcp://127.0.0.1:0/')
await self.asyncraises(
s_exc.BadMesgVers,
s_telepath.openurl('tcp://127.0.0.1/', port=port))
def main(argv):
if len(argv) != 2:
print('usage: python -m synapse.tools.cmdr <url>')
return -1
item = s_telepath.openurl(argv[1])
cmdr = s_cmdr.getItemCmdr(item)
cmdr.runCmdLoop()
def openurl(url, **opts):
'''
Open a remote service bus and return a SvcProxy class.
Example:
svcprox = openbus('tcp://svcbus.com/mybus')
'''
svcbus = s_telepath.openurl(url,**opts)
return SvcProxy(svcbus)
def openurl(url, **opts):
'''
Open a remote service bus and return a SvcProxy class.
Example:
svcprox = openbus('tcp://svcbus.com/mybus')
'''
svcbus = s_telepath.openurl(url, **opts)
return SvcProxy(svcbus)
def test_model_file_bytes_axon(self):
fd = io.BytesIO(b'foobar')
# create an cortex with access to an axon
with self.getTestDir() as dirname:
conf = {
'ctors': (
('axon00', 'syn:axon', {
'datadir': dirname
}),
('core00', 'syn:cortex', {
'url': 'ram:///',
'axon:url': 'dmon://axon00'
}),
),
'share': (('core00', {}), ),
}
with s_daemon.Daemon() as dmon:
dmon.loadDmonConf(conf)
link = dmon.listen('tcp://127.0.0.1:0/')
port = link[1].get('port')
core = s_telepath.openurl('tcp://127.0.0.1/core00', port=port)
node = core.formNodeByBytes(b'visi', name='visi.bin')
self.eq(node[1].get('file:bytes:size'), 4)
self.eq(node[1].get('file:bytes:name'), 'visi.bin')
self.eq(node[1].get('file:bytes'),
'442f602ecf8230b2a59a44b4f845be27')
self.eq(node[1].get('file:bytes:md5'),
'1b2e93225959e3722efed95e1731b764')
self.eq(node[1].get('file:bytes:sha1'),
'93de0c7d579384feb3561aa504acd8f23f388040')
self.eq(
node[1].get('file:bytes:sha256'),
'e45bbb7e03acacf4d1cca4c16af1ec0c51d777d10e53ed3155bd3d8deb398f3f'
)
self.eq(
node[1].get('file:bytes:sha512'),
'8238be12bcc3c10da7e07dbea528e9970dc809c07c5aef545a14e5e8d2038563b29c2e818d167b06e6a33412e6beb8347fcc44520691347aea9ee21fcf804e39'
)
node = core.formNodeByFd(fd, name='foobar.exe')
self.eq(node[1].get('file:bytes:size'), 6)
self.eq(node[1].get('file:bytes:name'), 'foobar.exe')
def test_telepath_clientside(self):
with s_daemon.Daemon() as dmon:
link = dmon.listen('tcp://127.0.0.1:0/')
port = link[1].get('port')
dmon.share('foo', Foo())
with s_telepath.openurl('tcp://127.0.0.1/foo', port=port) as prox:
self.eq(prox.localthing(20), 20)
self.eq(prox.localthing(30), 30)
def test_telepath_chop(self):
dmon,link = self.getFooServ()
port = link[1].get('port')
foo = s_telepath.openurl('tcp://localhost:%d/foo' % (port,))
self.assertEqual( foo.bar(10,20), 30 )
foo.fini()
dmon.fini()
def test_telepath_chop(self):
dmon, link = self.getFooServ()
port = link[1].get('port')
foo = s_telepath.openurl('tcp://localhost:%d/foo' % (port, ))
self.eq(foo.bar(10, 20), 30)
foo.fini()
dmon.fini()
def main(argv):
p = argparse.ArgumentParser()
p.add_argument('--size', default=mproc.cpu_count(), type=int, help='Number of parallel work units to run')
p.add_argument('queenurl', help='synapse link URL to connect to queen')
args = p.parse_args(argv)
queen = s_telepath.openurl(args.queenurl)
drone = s_hivemind.Drone(queen, size=args.size)
drone.main()
def test_telepath_reqproxy(self):
self.raises(MustBeProxy, s_telepath.reqIsProxy, 'woot')
with s_daemon.Daemon() as dmon:
dmon.share('foo', 'woot')
link = dmon.listen('tcp://127.0.0.1:0/')
port = link[1].get('port')
with s_telepath.openurl('tcp://127.0.0.1/foo', port=port) as foo:
self.raises(MustBeLocal, s_telepath.reqNotProxy, foo)
def test_telepath_push(self):
# override default timeout=None for tests
with s_threads.ScopeLocal(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 main(argv, outp=s_output.stdout):
pars = argparse.ArgumentParser(prog='cryo.cat', description='display data items from a cryo cell')
pars.add_argument('cryotank', help='The telepath URL for the remote cryotank.')
pars.add_argument('--offset', default=0, type=int, help='Begin at offset index')
pars.add_argument('--size', default=10, type=int, help='How many items to display')
pars.add_argument('--omit-offset', default=False, action='store_true', help='Output raw items with no offsets.')
# TODO: synapse.tools.cryo.list <cryocell>
#pars.add_argument('--list', default=False, action='store_true', help='List tanks in the remote cell and return')
group = pars.add_mutually_exclusive_group()
group.add_argument('--jsonl', action='store_true', help='Input/Output items in jsonl format')
group.add_argument('--msgpack', action='store_true', help='Input/Output items in msgpack format')
pars.add_argument('--verbose', '-v', default=False, action='store_true', help='Verbose output')
pars.add_argument('--ingest', '-i', default=False, action='store_true',
help='Reverses direction: feeds cryotank from stdin in msgpack or jsonl format')
opts = pars.parse_args(argv)
if opts.verbose:
logger.setLevel(logging.INFO)
if opts.ingest and not opts.jsonl and not opts.msgpack:
outp.printf('Must specify exactly one of --jsonl or --msgpack if --ingest is specified')
return 1
logger.info(f'connecting to: {opts.cryotank}')
with s_telepath.openurl(opts.cryotank) as tank:
if opts.ingest:
if opts.msgpack:
items = list(s_msgpack.iterfd(sys.stdin.buffer))
tank.puts(items)
return 0
items = [json.loads(l) for l in sys.stdin]
tank.puts(items)
return 0
for item in tank.slice(opts.offset, opts.size):
if opts.jsonl:
outp.printf(json.dumps(item[1], sort_keys=True))
elif opts.msgpack:
sys.stdout.buffer.write(s_msgpack.en(item[1]))
else:
outp.printf(pprint.pformat(item))
return 0
def test_link_local(self):
self.thisHostMustNot(platform='windows')
name = guid()
dmon = s_daemon.Daemon()
dmon.share('foo',FooBar())
link = dmon.listen('local://%s' % (name,))
prox = s_telepath.openurl('local://%s/foo' % name)
self.assertEqual( prox.foo(), 'bar' )
prox.fini()
dmon.fini()
def main(argv, outp=s_output.stdout):
pars = argparse.ArgumentParser(prog='cryo.list', description='List tanks within a cryo cell.')
pars.add_argument('cryocell', nargs='+', help='Telepath URLs to cryo cells.')
opts = pars.parse_args(argv)
for url in opts.cryocell:
outp.printf(url)
with s_telepath.openurl(url) as cryo:
for name, info in cryo.list():
outp.printf(f' {name}: {info}')
def test_telepath_pki(self):
env = self.getFooEnv(url='tcp://127.0.0.1:0/foo?pki=1')
port = env.link[1].get('port')
pki = env.dmon.pki # steal his...
user = pki.genUserToken('visi',bits=512)
host = pki.genHostToken('127.0.0.1',bits=512)
root = pki.genUserToken('root', bits=512, root=True)
pki.genTokenCert(user, signas=root[0])
pki.genTokenCert(host, signas=root[0])
prox = s_telepath.openurl('tcp://127.0.0.1/foo?pki=1', port=port, pkistor=pki)
self.assertEqual( prox.bar(10,20), 30 )
env.fini()
def getSwarmEnv(self):
tenv = TestEnv()
core0 = s_cortex.openurl('ram://')
core1 = s_cortex.openurl('ram://')
tenv.add('core0',core0,fini=True)
tenv.add('core1',core1,fini=True)
tufo0 = core0.formTufoByProp('foo:bar','baz',vvv='visi')
tufo1 = core0.formTufoByProp('foo:bar','faz',vvv='visi')
tufo2 = core1.formTufoByProp('foo:bar','lol',vvv='visi')
tufo3 = core1.formTufoByProp('foo:bar','hai',vvv='visi')
tufo4 = core0.formTufoByProp('zzz:woot',10,vvv='visi')
tufo5 = core1.formTufoByProp('zzz:woot',12,vvv='romp')
tenv.add('tufo0',tufo0)
tenv.add('tufo1',tufo1)
tenv.add('tufo2',tufo2)
tenv.add('tufo3',tufo3)
dmon = s_daemon.Daemon()
link = dmon.listen('tcp://127.0.0.1:0')
tenv.add('link',link)
tenv.add('dmon',dmon,fini=True)
port = link[1].get('port')
svcbus = s_service.SvcBus()
tenv.add('svcbus',svcbus,fini=True)
dmon.share('syn.svcbus',svcbus)
svcrmi = s_telepath.openurl('tcp://127.0.0.1/syn.svcbus', port=port)
tenv.add('svcrmi',svcrmi,fini=True)
s_service.runSynSvc('cortex',core0,svcrmi,tags=('hehe.haha',))
s_service.runSynSvc('cortex',core1,svcrmi,tags=('hehe.hoho',))
runt = s_runtime.Runtime(svcrmi)
tenv.add('runt',runt,fini=True)
return tenv
def test_service_proxy(self):
sbus = s_service.SvcBus()
dmon = s_daemon.Daemon()
dmon.share('syn.svcbus', sbus)
link = dmon.listen('tcp://127.0.0.1:0/')
port = link[1].get('port')
prox = s_telepath.openurl('tcp://127.0.0.1/syn.svcbus', port=port)
woot0 = Woot()
woot1 = Woot()
s_service.runSynSvc('woots.woot0', woot0, prox)
s_service.runSynSvc('woots.woot1', woot1, prox, tags=('foo.bar',))
svcp = s_service.SvcProxy(prox)
foos = svcp.getTagProxy('foo')
woots = svcp.getTagProxy('woots')
vals = tuple( sorted( foos.foo(20,y=20) ) )
self.assertEqual( vals, (40,) )
vals = tuple( sorted( woots.foo(10,y=20) ) )
self.assertEqual( vals, (30,30) )
def runNewpMeth():
for foo in woots.newp(44,y=33):
pass
self.assertEqual( 2, len(svcp.getSynSvcs()) )
self.assertEqual( 2, len(svcp.getSynSvcsByTag('woots')) )
#self.assertRaises( JobErr, runNewpMeth )
woots = svcp.getTagProxy('class.synapse.tests.test_service.Woot')
vals = tuple( sorted( woots.foo(10,y=20) ) )
self.assertEqual( vals, (30,30) )
prox.fini()
dmon.fini()
sbus.fini()
def getSwarmEnv(self):
tenv = TestEnv()
core0 = s_cortex.openurl("ram://")
core1 = s_cortex.openurl("ram://")
tenv.add("core0", core0, fini=True)
tenv.add("core1", core1, fini=True)
tufo0 = core0.formTufoByProp("foo:bar", "baz", vvv="visi")
tufo1 = core0.formTufoByProp("foo:bar", "faz", vvv="visi")
tufo2 = core1.formTufoByProp("foo:bar", "lol", vvv="visi")
tufo3 = core1.formTufoByProp("foo:bar", "hai", vvv="visi")
tufo4 = core0.formTufoByProp("zzz:woot", 10, vvv="visi")
tufo5 = core1.formTufoByProp("zzz:woot", 12, vvv="romp")
tenv.add("tufo0", tufo0)
tenv.add("tufo1", tufo1)
tenv.add("tufo2", tufo2)
tenv.add("tufo3", tufo3)
dmon = s_daemon.Daemon()
link = dmon.listen("tcp://127.0.0.1:0")
tenv.add("link", link)
tenv.add("dmon", dmon, fini=True)
port = link[1].get("port")
svcbus = s_service.SvcBus()
tenv.add("svcbus", svcbus, fini=True)
dmon.share("syn.svcbus", svcbus)
svcrmi = s_telepath.openurl("tcp://127.0.0.1/syn.svcbus", port=port)
tenv.add("svcrmi", svcrmi, fini=True)
s_service.runSynSvc("cortex", core0, svcrmi, tags=("hehe.haha",))
s_service.runSynSvc("cortex", core1, svcrmi, tags=("hehe.hoho",))
runt = s_runtime.Runtime(svcrmi)
tenv.add("runt", runt, fini=True)
return tenv
def test_telepath_callx(self):
class Baz:
def faz(self, x, y=10):
return '%d:%d' % (x,y)
env = self.getFooEnv()
env.dmon.share('baz', Baz())
port = env.link[1].get('port')
foo = s_telepath.openurl('tcp://127.0.0.1/foo', port=port)
# make sure proxy is working normally...
self.assertEqual( foo.bar(10,20), 30 )
# carry out a cross item task
job = foo.callx( 'baz', ('faz', (30,), {'y':40}), )
self.assertEqual( foo.sync(job), '30:40' )
def test_link_ssl_nocheck(self):
cafile = getTestPath('ca.pem')
keyfile = getTestPath('server.key')
certfile = getTestPath('server.pem')
dmon = s_daemon.Daemon()
dmon.share('foobar', FooBar() )
link = dmon.listen('ssl://localhost:0/', keyfile=keyfile, certfile=certfile)
port = link[1].get('port')
url = 'ssl://localhost/foobar'
self.assertRaises( LinkErr, s_telepath.openurl, url, port=port )
foo = s_telepath.openurl(url, port=port, nocheck=True)
foo.fini()
dmon.fini()
def test_daemon_conf_fork(self):
self.thisHostMustNot(platform='windows')
iden = guid()
conf = {
'forks':(
('fork0',{
'ctors':(
('haha','ctor://synapse.tests.test_daemon.Woot()'),
),
'share': (
('haha',{}),
),
'listen':(
'local://%s' % (iden,),
),
}),
),
}
dmon = s_daemon.Daemon()
dmon.loadDmonConf(conf)
prox = s_telepath.openurl('local://%s/haha?retry=6' % (iden,))
pid0 = prox.pid()
self.assertNotEqual( pid0, os.getpid() )
prox.fini()
#dmon.killDmonFork('fork0')
#prox = s_telepath.openurl('local://%s/haha?retry=6' % (iden,))
#pid1 = prox.pid()
#self.assertNotEqual( pid0, pid1 )
#self.assertNotEqual( pid1, os.getpid() )
#prox.fini()
dmon.fini()
def newp_link_ssl_basic(self):
# FIXME some kind of cert validation diffs in *py* vers killed us
cafile = getTestPath('ca.pem')
keyfile = getTestPath('server.key')
certfile = getTestPath('server.pem')
dmon = s_daemon.Daemon()
dmon.share('foobar', FooBar() )
link = dmon.listen('ssl://localhost:0/', keyfile=keyfile, certfile=certfile)
port = link[1].get('port')
url = 'ssl://localhost/foobar'
foo = s_telepath.openurl(url, port=port, cafile=cafile)
self.assertEqual( foo.foo(), 'bar' )
foo.fini()
dmon.fini()
def main(argv, outp=None):
pars = setup()
opts = pars.parse_args(argv)
if outp is None: # pragma: no cover
outp = s_output.OutPut()
if opts.output is None:
opts.output = '.'
outdir = pathlib.Path(opts.output)
s_common.gendir(opts.output)
with s_telepath.openurl(opts.axon) as axon:
# reminder: these are the hashes *not* available
awants = axon.wants([binascii.unhexlify(h) for h in opts.hashes])
for a in awants:
outp.printf(f'{binascii.hexlify(a)} not in axon store')
exists = [h for h in opts.hashes if binascii.unhexlify(h) not in awants]
for h in exists:
try:
outp.printf(f'Fetching {h} to file')
with open(outdir.joinpath(h), 'wb') as fd:
for b in axon.get(binascii.unhexlify(h)):
fd.write(b)
outp.printf(f'Fetched {h} to file')
except Exception as e:
outp.printf('Error: Hit Exception: %s' % (str(e),))
continue
return 0
def test_daemon_conf_fork(self):
self.thisHostMustNot(platform="windows")
iden = guid()
conf = {
"forks": (
(
"fork0",
{
"ctors": (("haha", "ctor://synapse.tests.test_daemon.Woot()"),),
"share": (("haha", {}),),
"listen": ("local://%s" % (iden,),),
},
),
)
}
dmon = s_daemon.Daemon()
dmon.loadDmonConf(conf)
prox = s_telepath.openurl("local://%s/haha?retry=6" % (iden,))
pid0 = prox.pid()
self.assertNotEqual(pid0, os.getpid())
prox.fini()
# dmon.killDmonFork('fork0')
# prox = s_telepath.openurl('local://%s/haha?retry=6' % (iden,))
# pid1 = prox.pid()
# self.assertNotEqual( pid0, pid1 )
# self.assertNotEqual( pid1, os.getpid() )
# prox.fini()
dmon.fini()
def subtask(job):
jid = job[0]
slot = job[1].get('slot')
meld = job[1].get('meld')
if meld != None:
s_mindmeld.loadMindMeld(meld)
hive = slot[1].get('hive')
queen = s_telepath.openurl( job[1].get('queen') )
s_threads.put('syn.queen',queen)
try:
dyntask = job[1].get('dyntask')
ret = s_dyndeps.runDynTask(dyntask)
queen.tell(hive, 'job:done', jid=jid, ret=ret)
except Exception as e:
queen.tell(hive, 'job:done', jid=jid, **excinfo(e))
async def test_cell_auth(self):
with self.getTestDir() as dirn:
async with await EchoAuth.anit(dirn) as echo:
echo.insecure = False
echo.dmon.share('echo00', echo)
root = echo.auth.getUserByName('root')
await root.setPasswd('secretsauce')
host, port = await echo.dmon.listen('tcp://127.0.0.1:0/')
url = f'tcp://127.0.0.1:{port}/echo00'
await self.asyncraises(s_exc.AuthDeny, s_telepath.openurl(url))
url = f'tcp://[email protected]:{port}/echo00'
await self.asyncraises(s_exc.NoSuchUser, s_telepath.openurl(url))
url = f'tcp://[email protected]:{port}/echo00'
await self.asyncraises(s_exc.AuthDeny, s_telepath.openurl(url))
url = f'tcp://*****:*****@127.0.0.1:{port}/echo00'
await self.asyncraises(s_exc.AuthDeny, s_telepath.openurl(url))
root_url = f'tcp://*****:*****@127.0.0.1:{port}/echo00'
async with await s_telepath.openurl(root_url) as proxy:
self.true(await proxy.isadmin())
self.true(await proxy.allowed(('hehe', 'haha')))
user = await echo.auth.addUser('visi')
await user.setPasswd('foo')
await user.addRule((True, ('foo', 'bar')))
visi_url = f'tcp://*****:*****@127.0.0.1:{port}/echo00'
async with await s_telepath.openurl(visi_url) as proxy:
self.true(await proxy.allowed(('foo', 'bar')))
self.false(await proxy.isadmin())
self.false(await proxy.allowed(('hehe', 'haha')))
async with await s_telepath.openurl(root_url) as proxy:
await proxy.setUserLocked('visi', True)
info = await proxy.getAuthInfo('visi')
self.true(info[1].get('locked'))
await self.asyncraises(s_exc.AuthDeny,
s_telepath.openurl(visi_url))
await proxy.setUserLocked('visi', False)
info = await proxy.getAuthInfo('visi')
self.false(info[1].get('locked'))
async with await s_telepath.openurl(visi_url) as visi_proxy:
self.false(await visi_proxy.isadmin())
async with await s_telepath.openurl(root_url) as proxy:
await self.asyncraises(s_exc.NoSuchUser,
proxy.setUserArchived('newp', True))
await proxy.setUserArchived('visi', True)
info = await proxy.getAuthInfo('visi')
self.true(info[1].get('archived'))
self.true(info[1].get('locked'))
users = await proxy.getAuthUsers()
self.len(1, users)
users = await proxy.getAuthUsers(archived=True)
self.len(2, users)
await self.asyncraises(s_exc.AuthDeny,
s_telepath.openurl(visi_url))
await proxy.setUserArchived('visi', False)
info = await proxy.getAuthInfo('visi')
self.false(info[1].get('archived'))
self.true(info[1].get('locked'))
users = await proxy.getAuthUsers(archived=True)
self.len(2, users)
await self.asyncraises(s_exc.AuthDeny,
s_telepath.openurl(visi_url))
async with echo.getLocalProxy() as proxy:
await proxy.setHiveKey(('foo', 'bar'), [1, 2, 3, 4])
self.eq([1, 2, 3, 4], await proxy.getHiveKey(('foo', 'bar')))
self.isin('foo', await proxy.listHiveKey())
self.eq(['bar'], await proxy.listHiveKey(('foo', )))
await proxy.popHiveKey(('foo', 'bar'))
self.eq([], await proxy.listHiveKey(('foo', )))
