def test_sched_loop(self):
data = {'count': 0}
def foo():
data['count'] += 1
if data['count'] > 3:
return False
ran = threading.Event()
def bar():
data['count'] += 1
if data['count'] > 3:
ran.set()
with s_sched.Sched() as sched:
loop = sched.loop(0.001, foo)
self.true(loop.waitfini(timeout=0.1))
data['count'] = 0
loop = sched.loop(0.001, bar)
self.true(ran.wait(timeout=1))
loop.fini()
ran.clear()
self.false(ran.wait(timeout=0.2))
def test_sched_persec(self):
sched = s_sched.Sched()
evt = threading.Event()
data = {'count': 0}
def woot(x, y=None):
data['x'] = x
data['y'] = y
data['count'] += 1
if data['count'] >= 3:
evt.set()
return False
s = time.time()
sched.persec(10, woot, 10, y='hehe')
evt.wait(timeout=0.5)
self.true(evt.is_set())
elapsed = time.time() - s
self.true(elapsed > 0.2 and elapsed < 0.3)
self.eq(data['x'], 10)
self.eq(data['y'], 'hehe')
self.eq(data['count'], 3)
sched.fini()
def test_sched_cancel(self):
sched = s_sched.Sched()
def woot2(x):
pass
eid = sched.insec(20, woot2, 20)
sched.cancel(eid)
sched.fini()
def __init__(self):
EventBus.__init__(self)
self.lock = threading.Lock()
self.sched = s_sched.Sched()
self.slots = {}
self.hives = {}
self.drones = {}
self.slotq = collections.deque()
def __init__(self):
EventBus.__init__(self)
self.coreok = {}
self.cordefs = {}
self.tagsbyname = {}
self.coresbyname = {}
self.sched = s_sched.Sched()
self.coresbytag = collections.defaultdict(list)
self.onfini(self._onMetaFini)
def test_sched_base(self):
evt = threading.Event()
data = {'woot': []}
def woot1(x):
data['woot'].append(x)
def woot2(x):
data['woot'].append(x)
evt.set()
sched = s_sched.Sched()
sched.insec(0.02, woot2, 20)
sched.insec(0.01, woot1, 10)
evt.wait(timeout=2)
self.true(evt.is_set())
self.eq(data['woot'], [10, 20])
sched.fini()
import threading import multiprocessing lock = threading.RLock() import synapse.lib.sched as s_sched import synapse.lib.threads as s_threads # go high since they will mostly be IO bound tmax = multiprocessing.cpu_count() * 8 pool = s_threads.Pool(maxsize=tmax) sched = s_sched.Sched(pool=pool)
def __init__(self, core=None, pool=None):
s_daemon.Daemon.__init__(self, core=core, pool=pool)
self.sched = s_sched.Sched()
self.core.addTufoForm('neuron')
#self.core.addTufoProp('neuron','name')
#self.core.addTufoProp('neuron','super',ptype='int',defval=0)
#self.core.addTufoProp('neuron','usepki', ptype='bool', defval=0)
self.neur = self.core.formTufoByProp('neuron', 'self')
self.iden = self.neur[0]
self.peers = {} # <peer>:<sock>
self.routes = {} # <dest>:[ (dist,peer), ... ]
#self.mesh = {}
#self.peers = {}
#self.mesh['certs'] = {}
#self.mesh['links'] = {}
#self.mesh['peers'] = { self.iden:self.neur }
#self.sockbyfrom = s_cache.Cache(maxtime=120)
#self.sockbyfrom.setOnMiss( self._getFakeSock )
#self.links = collections.defaultdict(set)
#
#self.linkpaths = s_cache.Cache(maxtime=30)
#self.linkpaths.setOnMiss( self._getLinkPath )
self.setMesgFunc('peer:syn', self._onPeerSynMesg)
self.setMesgFunc('peer:synack', self._onPeerSynAckMesg)
self.setMesgFunc('peer:fin',
self._onPeerFinMesg) # gracefully shut down
self.setMesgFunc('peer:data', self._onPeerDataMesg)
self.setMesgFunc('peer:route',
self._onPeerLinkMesg) # route change information
#self.setMesgFunc('peer:link:init', self._onPeerLinkInitMesg )
#self.setMesgFunc('neu:peer:chal', self._onNeuPeerChal )
#self.setMesgFunc('neu:peer:resp', self._onNeuPeerResp )
#self.setMesgFunc('neu:data', self._onNeuDataMesg )
#self.setMesgFunc('neu:storm', self._onNeuStormMesg )
self.on('neu:link:init', self._onNeuLinkInit)
self.on('neu:link:fini', self._onNeuLinkFini)
self.share('neuron', self)
self.hasopt = {}
# fire any persistent neuron listeners
for url in self.core.getTufoList(self.neur, 'listen'):
try:
self.listen(url)
self.hasopt[('listen', url)] = True
except Exception as e:
logger.error('neu listen: %s', e)
# spin up any persistent neuron connections
for url in self.core.getTufoList(self.neur, 'connect'):
try:
self.connect(url)
self.hasopt[('connect', url)] = True
except Exception as e:
logger.error('neu connect: %s', e)
# load any persistent shared objects
for jsval in self.core.getTufoList(self.neur, 'shared'):
try:
info = json.loads(v)
name = info.get('name')
task = info.get('task')
tags = info.get('tags', ())
item = s_dyndeps.runDynTask(task)
self.share(name, item, tags=tags)
except Exception as e:
logger.error('neu share: %s', e)
('synapse.models.chemistry.ChemMod', {}),
('synapse.models.gov.intl.GovIntlMod', {}),
)
##############################################
# setup glob here to avoid import loops...
import synapse.glob as s_glob
import synapse.lib.net as s_net
import synapse.lib.sched as s_sched
import synapse.lib.threads as s_threads
tmax = multiprocessing.cpu_count() * 8
s_glob.plex = s_net.Plex()
s_glob.pool = s_threads.Pool(maxsize=tmax)
s_glob.sched = s_sched.Sched(pool=s_glob.pool)
##############################################
import synapse.lib.modules as s_modules
for mod, conf in BASE_MODULES:
s_modules.load_ctor(mod, conf)
# Register any CoreModules from envars
mods = os.getenv('SYN_CORE_MODULES')
if mods:
for name in mods.split(','):
name = name.strip()
try:
s_modules.load_ctor(name, {})
except Exception as e:
logger.warning('SYN_CORE_MODULES failed: %s (%s)' % (name, e))
