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))