def test_eventbus_link(self):
bus1 = s_eventbus.EventBus()
bus2 = s_eventbus.EventBus()
bus3 = s_eventbus.EventBus()
# gotta hold a reference
bus3dist = bus3.dist
bus1.link(bus2.dist)
bus2.link(bus3dist, weak=True)
data = {}
def woot(event):
data['woot'] = True
def weakwoot(event):
data['weak'] = True
bus2.on('woot', woot)
bus3.on('woot', weakwoot)
bus1.fire('woot')
self.assertTrue(data.get('woot'))
self.assertTrue(data.get('weak'))
def test_eventbus_busref_items(self):
bref = s_eventbus.BusRef()
bus0 = s_eventbus.EventBus()
bus1 = s_eventbus.EventBus()
bus2 = s_eventbus.EventBus()
bref.put('foo', bus0)
bref.put('bar', bus1)
bref.put('baz', bus2)
items = bref.items()
self.isin(('foo', bus0), items)
self.isin(('bar', bus1), items)
self.isin(('baz', bus2), items)
bus1.fini()
items = bref.items()
self.isin(('foo', bus0), items)
self.isin(('baz', bus2), items)
bus2.fini()
items = bref.items()
self.isin(('foo', bus0), items)
bus0.fini()
items = bref.items()
self.eq(items, [])
bref.fini()
items = bref.items()
self.eq(items, [])
def __init__(self, core, form='plugin'):
s_eventbus.EventBus.__init__(self)
self.core = core
self.form = form
self.plugs = {}
self.plugmods = {}
self.plugfuncs = {}
self.plugbus = s_eventbus.EventBus()
model = core.genDataModel()
model.addTufoForm(form, ptype='guid')
model.addTufoProp(form, 'en', ptype='bool')
model.addTufoProp(form, 'name', ptype='str')
model.addTufoProp(form, 'source', ptype='str')
self.core.on('tufo:add:%s' % (form, ), self._onPlugAdd)
self.core.on('tufo:set:%s:en' % (form, ), self._onPlugSetEn)
self.core.on('tufo:set:%s:source' % (form, ), self._onPlugSetSource)
[
self._runInitPlug(plug)
for plug in core.getTufosByProp('%s:en' % form, 1)
]
self.onfini(self._onPlugsFini)
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_eventbus_link(self):
bus1 = s_eventbus.EventBus()
bus2 = s_eventbus.EventBus()
bus1.link(bus2.dist)
data = {}
def woot(event):
data['woot'] = True
bus2.on('woot', woot)
bus1.fire('woot')
self.true(data.get('woot'))
def test_eventbus_refcount(self):
ebus = s_eventbus.EventBus()
self.eq(ebus.incref(), 2)
self.eq(ebus.fini(), 1)
self.false(ebus.isfini)
self.eq(ebus.fini(), 0)
self.true(ebus.isfini)
def test_eventbus_withfini(self):
data = {'count': 0}
def onfini():
data['count'] += 1
with s_eventbus.EventBus() as bus:
bus.onfini(onfini)
self.eq(data['count'], 1)
def test_eventbus_basics(self):
bus = s_eventbus.EventBus()
def foo(event):
x = event[1].get('x')
y = event[1].get('y')
event[1]['ret'] = x + y
bus.on('woot', foo)
event = bus.fire('woot', x=3, y=5, ret=[])
self.eq(event[1]['ret'], 8)
def test_eventbus_log(self):
logs = []
with s_eventbus.EventBus() as ebus:
ebus.on('log', logs.append)
ebus.log(100, 'omg woot', foo=10)
mesg = logs[0]
self.eq(mesg[0], 'log')
self.eq(mesg[1].get('foo'), 10)
self.eq(mesg[1].get('mesg'), 'omg woot')
self.eq(mesg[1].get('level'), 100)
def test_eventbus_exc(self):
logs = []
with s_eventbus.EventBus() as ebus:
ebus.on('log', logs.append)
try:
raise NoSuchObj(name='hehe')
except Exception as e:
ebus.exc(e)
mesg = logs[0]
self.eq(mesg[1].get('err'), 'NoSuchObj')
def test_eventbus_busref(self):
bref = s_eventbus.BusRef()
bus0 = s_eventbus.EventBus()
bus1 = s_eventbus.EventBus()
bus2 = s_eventbus.EventBus()
bref.put('foo', bus0)
bref.put('bar', bus1)
bref.put('baz', bus2)
bus1.fini()
self.nn(bref.get('foo'))
self.none(bref.get('bar'))
self.len(2, list(bref))
self.true(bref.pop('baz') is bus2)
self.len(1, list(bref))
bref.fini()
self.true(bus0.isfini)
def test_eventbus_finionce(self):
data = {'count': 0}
def onfini():
data['count'] += 1
bus = s_eventbus.EventBus()
bus.onfini(onfini)
bus.fini()
bus.fini()
self.eq(data['count'], 1)
def test_eventbus_waiter(self):
bus0 = s_eventbus.EventBus()
wait0 = bus0.waiter(3, 'foo:bar')
bus0.fire('foo:bar')
bus0.fire('foo:bar')
bus0.fire('foo:bar')
evts = wait0.wait(timeout=3)
self.eq(len(evts), 3)
wait1 = bus0.waiter(3, 'foo:baz')
evts = wait1.wait(timeout=0.1)
self.none(evts)
def test_eventbus_waitfini(self):
ebus = s_eventbus.EventBus()
self.false(ebus.waitfini(timeout=0.1))
def callfini():
time.sleep(0.1)
ebus.fini()
thr = s_threads.worker(callfini)
# actually wait...
self.true(ebus.waitfini(timeout=0.3))
# bounce off the isfini block
self.true(ebus.waitfini(timeout=0.3))
def test_eventbus_basics(self):
bus = s_eventbus.EventBus()
def foo(event):
x = event[1].get('x')
y = event[1].get('y')
return event[1]['ret'].append(x + y)
def bar(event):
x = event[1].get('x')
y = event[1].get('y')
return event[1]['ret'].append(x * y)
bus.on('woot', foo)
bus.on('woot', bar, weak=True)
event = bus.fire('woot', x=3, y=5, ret=[])
self.assertEqual(tuple(event[1]['ret']), (8, 15))
def test_eventbus_off_weak(self):
bus = s_eventbus.EventBus()
data = {'count': 0}
def woot(mesg):
data['count'] += 1
bus.on('hehe', woot, weak=True)
bus.fire('hehe')
bus.off('hehe', woot)
bus.fire('hehe')
bus.fini()
self.assertEqual(data['count'], 1)
def test_evenbus_unlink(self):
bus = s_eventbus.EventBus()
mesgs = []
def woot(mesg):
mesgs.append(mesg)
bus.link(woot)
bus.fire('haha')
self.eq(len(mesgs), 1)
bus.unlink(woot)
bus.fire('haha')
self.eq(len(mesgs), 1)
bus.fini()
def block_processing(evt1, evt2):
'''
Function to make an eventbus and call main(). Used as a Process target.
Args:
evt1 (multiprocessing.Event): event to twiddle
evt2 (multiprocessing.Event): event to twiddle
'''
bus = s_eventbus.EventBus()
def onMain(mesg):
evt1.set()
def onFini():
evt2.set()
bus.on('ebus:main', onMain)
bus.onfini(onFini)
bus.main()
sys.exit(137)
def test_eventbus_filt(self):
bus = s_eventbus.EventBus()
def wootfunc(mesg):
mesg[1]['woot'] = True
bus.on('lol', wootfunc)
bus.on('rofl', wootfunc, foo=10)
mesg = bus.fire('lol')
self.true(mesg[1].get('woot'))
mesg = bus.fire('rofl')
self.false(mesg[1].get('woot'))
mesg = bus.fire('rofl', foo=20)
self.false(mesg[1].get('woot'))
mesg = bus.fire('rofl', foo=10)
self.true(mesg[1].get('woot'))
def test_eventbus_onwith(self):
ebus = s_eventbus.EventBus()
l0 = []
l1 = []
def onHehe0(mesg):
l0.append(mesg)
def onHehe1(mesg):
l1.append(mesg)
ebus.on('hehe', onHehe0)
# Temporarily set the 'hehe' callback
with ebus.onWith('hehe', onHehe1) as e:
self.true(e is ebus)
ebus.fire('hehe')
self.len(1, l0)
self.len(1, l1)
# subsequent fires do not call onHehe1
ebus.fire('hehe')
self.len(2, l0)
self.len(1, l1)
# onWith works across Telepath Proxy's and with filts
l2 = []
def onNodeForm(mesg):
l2.append(mesg)
with self.getDmonCore() as core:
with core.onWith('node:form', onNodeForm, form='strform'):
t0 = core.formTufoByProp('strform', 'hehe')
self.nn(t0)
t1 = core.formTufoByProp('intform', 1234)
self.nn(t1)
self.len(1, l2)
def test_eventbus_onwith(self):
ebus = s_eventbus.EventBus()
l0 = []
l1 = []
def onHehe0(mesg):
l0.append(mesg)
def onHehe1(mesg):
l1.append(mesg)
ebus.on('hehe', onHehe0)
# Temporarily set the 'hehe' callback
with ebus.onWith('hehe', onHehe1) as e:
self.true(e is ebus)
ebus.fire('hehe')
self.len(1, l0)
self.len(1, l1)
# subsequent fires do not call onHehe1
ebus.fire('hehe')
self.len(2, l0)
self.len(1, l1)
def ctor(name):
return s_eventbus.EventBus()
def __init__(self, link, **conf):
s_config.Config.__init__(self)
if conf:
self.setConfOpts(conf)
#############################################################
# buses to save/load *raw* save events
#############################################################
self.savebus = s_eventbus.EventBus()
self.loadbus = s_eventbus.EventBus()
self._link = link
self.onfini(self._defaultFiniCoreStor)
# Various locks
self.xlock = threading.Lock()
# Transactions are a storage-layer concept
self._store_xacts = {}
# Dicts for storing retrieval methods
self.sizebymeths = {}
self.rowsbymeths = {}
self.joinsbymeths = {}
# Register handlers for lifting rows/sizes/joins
self.initRowsBy('gt', self.rowsByGt)
self.initRowsBy('lt', self.rowsByLt)
self.initRowsBy('ge', self.rowsByGe)
self.initRowsBy('le', self.rowsByLe)
self.initRowsBy('range', self.rowsByRange)
self.initSizeBy('ge', self.sizeByGe)
self.initSizeBy('le', self.sizeByLe)
self.initSizeBy('range', self.sizeByRange)
self.initJoinsBy('ge', self._joinsByGe)
self.initJoinsBy('gt', self._joinsByGt)
self.initJoinsBy('le', self._joinsByLe)
self.initJoinsBy('lt', self._joinsByLt)
self.initJoinsBy('in', self._joinsByIn)
self.initJoinsBy('range', self._joinsByRange)
# Events for handling savefile loads/saves
self.loadbus.on('core:save:add:rows', self._loadAddRows)
self.loadbus.on('core:save:del:rows:by:iden', self._loadDelRowsById)
self.loadbus.on('core:save:del:rows:by:prop', self._loadDelRowsByProp)
self.loadbus.on('core:save:set:rows:by:idprop',
self._loadSetRowsByIdProp)
self.loadbus.on('core:save:del:rows:by:idprop',
self._loadDelRowsByIdProp)
self.loadbus.on('core:save:set:up:prop', self._loadUpdateProperty)
self.loadbus.on('core:save:set:up:propvalu',
self._loadUpdatePropertyValu)
self.loadbus.on('syn:core:blob:set', self._onSetBlobValu)
self.loadbus.on('syn:core:blob:del', self._onDelBlobValu)
# Cache blob save mesgs which may be fired during storage layer init
_blobMesgCache = []
self.savebus.on('syn:core:blob:set', _blobMesgCache.append)
self.savebus.on('syn:core:blob:del', _blobMesgCache.append)
# Perform storage layer initializations
self._initCoreStor()
# Disable the blob message caching
self.savebus.off('syn:core:blob:set', _blobMesgCache.append)
self.savebus.off('syn:core:blob:del', _blobMesgCache.append)
# process a savefile/savefd if we have one (but only one of the two)
savefd = self._link[1].get('savefd')
if savefd is not None:
self.setSaveFd(savefd)
else:
savefile = self._link[1].get('savefile')
if savefile is not None:
savefd = s_common.genfile(savefile)
self.setSaveFd(savefd, fini=True)
# The storage layer initialization blob events then trump anything
# which may have been set during the savefile load and make sure they
# get saved as well
if 'savefd' in link[1] or 'savefile' in link[1]:
for evtname, info in _blobMesgCache:
self.savebus.fire(evtname, **info)
self.loadbus.fire(evtname, **info)
if not self.hasBlobValu('syn:core:created'):
self.setBlobValu('syn:core:created', s_common.now())
self.onfini(self._finiCoreStore)
def __init__(self, statefd=None):
self.sched = s_threads.Sched()
self.asyncpool = s_async.AsyncBoss()
self.peerbus = s_eventbus.EventBus()
self.peersocks = {} # sockets directly connected to peers
self.peergraph = collections.defaultdict(set)
self.routecache = {}
# persistant data in these...
self.neuinfo = {
'poolsize': 10, # default to 10 neuron threads
}
self.neucores = {}
self.neusocks = {} # <guid> : NeuSock()
self.neushares = {}
self.runinfo = collections.defaultdict(dict)
self.peerinfo = collections.defaultdict(dict)
self.metacore = s_cortex.MetaCortex()
s_daemon.Daemon.__init__(self)
self.onfini(self.sched.fini)
self.onfini(self.peerbus.fini)
self.onfini(self.asyncpool.fini)
self.on('link:sock:init', self._onNeuSockInit)
self.on('neu:peer:init', self._onNeuPeerInit)
self.on('neu:peer:fini', self._onNeuPeerFini)
# application layer peer messages...
self.peerbus.on('ping', self._onPeerBusPing)
self.peerbus.on('pong', self._onPeerBusPong)
self.setMesgMethod('neu:data', self._onMesgNeuData)
self.setMesgMethod('neu:link:syn', self._onMesgNeuLinkSyn)
self.setMesgMethod('neu:link:synack', self._onMesgNeuLinkSynAck)
self.setMesgMethod('neu:link:ack', self._onMesgNeuLinkAck)
self.setMesgMethod('neu:peer:link:up', self._onMesgNeuPeerLinkUp)
self.setMesgMethod('neu:peer:link:down', self._onMesgNeuPeerLinkDown)
def setrsakey(event):
valu = event[1].get('valu')
self.rsakey = RSA.importKey(valu)
self.pubkey = self.rsakey.publickey()
self.pkcs15 = PKCS15.PKCS115_SigScheme(self.rsakey)
def setauthmod(event):
valu = event[1].get('valu')
if valu == None:
self.setAuthModule(None)
return
name, args, kwargs = valu
auth = s_dyndeps.getDynLocal(name)(*args, **kwargs)
self.setAuthModule(auth)
def setpoolsize(event):
valu = event[1].get('valu')
self.asyncpool.setPoolSize(valu)
self.on('neu:info:rsakey', setrsakey)
self.on('neu:info:authmod', setauthmod)
self.on('neu:info:poolsize', setpoolsize)
if statefd:
self.loadStateFd(statefd)
#self._loadNeuAuthModule()
self._loadNeuMetaCortex()
#self._loadNeuSharedObjects()
# check if we're brand new...
if self.neuinfo.get('ident') == None:
# making a shiney new neuron!
self.setNeuInfo('ident', guid())
self.ident = self.getNeuInfo('ident')
poolsize = self.getNeuInfo('poolsize')
self.asyncpool.setPoolSize(poolsize)
