def _getIoLoop(): ''' Get a RemCycle module local IOLoop. Returns: t_ioloop.IoLoop: A Tornado IOLoop. ''' global ioloop if ioloop is None: ioloop = t_ioloop.IOLoop() s_threads.worker(ioloop.start) return ioloop
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 __init__(self, conf=None): s_config.Config.__init__(self, conf) self.epoll = select.epoll() self.socks = {} self.links = {} self.thrd = s_threads.worker(self._runPollLoop) self.onfini(self._onPlexFini) pmax = self.getConfOpt('pool:max') self.pool = s_threads.Pool(maxsize=pmax) self.onfini(self.pool.fini) self.polls = {}
def test_threads_cancelable(self): sock1, sock2 = s_socket.socketpair() data = [] def echoloop(): with s_threads.cancelable(sock1.fini): byts = sock1.recv(1024) data.append(byts) sock1.sendall(byts) thr = s_threads.worker(echoloop) sock2.sendall(b'hi') self.assertEqual( sock2.recv(1024), b'hi') thr.fini() thr.join() sock1.fini() sock2.fini()
def test_threads_cancelable(self): sock1, sock2 = s_socket.socketpair() data = [] def echoloop(): with s_threads.cancelable(sock1.fini): byts = sock1.recv(1024) data.append(byts) sock1.sendall(byts) thr = s_threads.worker(echoloop) sock2.sendall(b'hi') self.eq(sock2.recv(1024), b'hi') thr.fini() thr.join() sock1.fini() sock2.fini()
async def test_asyncqueue(self): # The axon tests test most of the asyncqueue functionality. We just need to test the # draining part async with await s_queue.AsyncQueue.anit(5, drain_level=3) as q: [await q.put(i) for i in range(5)] got_to_end = False waiter = asyncio.Event() last_msg = 0 def sync_worker(): nonlocal got_to_end nonlocal last_msg time.sleep(0.1) last_msg = q.get() # got 0 last_msg = q.get() # got 1 q.schedCallSafe(waiter.set) time.sleep(0.1) last_msg = q.get() # got 2 got_to_end = True t = s_threads.worker(sync_worker) before = time.time() await waiter.wait() await q.put(6) self.lt(0.1, time.time() - before) await asyncio.sleep(0.1) self.eq(last_msg, 2) await asyncio.sleep(0.1) self.true(got_to_end) t.join()
def test_threads_retnwait(self): with s_threads.RetnWait() as retn: def work(): retn.retn(True) thrd = s_threads.worker(work) self.eq(retn.wait(timeout=1), (True, True)) thrd.join() self.eq(retn.wait(timeout=1), (True, True)) # no timeout with s_threads.RetnWait() as retn: def work(): retn.retn(True) thrd = s_threads.worker(work) self.eq(retn.wait(), (True, True)) thrd.join() self.eq(retn.wait(timeout=1), (True, True)) # Let a wait() timeout with s_threads.RetnWait() as retn: def work(): time.sleep(0.5) retn.retn(True) thrd = s_threads.worker(work) ok, retn = retn.wait(timeout=0.01) self.false(ok) self.eq(retn[0], 'TimeOut') thrd.join() with s_threads.RetnWait() as retn: def work(): try: 1 / 0 except ZeroDivisionError as e: retn.errx(e) thrd = s_threads.worker(work) ret = retn.wait(timeout=1) thrd.join() self.false(ret[0]) excfo = ret[1] self.istufo(excfo) self.eq(excfo[0], 'ZeroDivisionError') self.eq(excfo[1].get('msg'), 'division by zero') self.eq(excfo[1].get('name'), 'work') self.isin('test_lib_threads.py', excfo[1].get('file')) self.isin('line', excfo[1]) # Line may change self.isin( 'src', excfo[1]) # source for a inner function may not be available. # Test capture with s_threads.RetnWait() as retn: def work(a, b, c, callback): sum = a + b multiple = sum * c callback(sum, multiple, a=a, b=b, c=c) thrd = s_threads.worker(work, 1, 2, 3, retn.capture) ret = retn.wait(timeout=1) thrd.join() self.true(ret[0]) self.eq(ret[1], ((3, 9), {'a': 1, 'b': 2, 'c': 3}))
def test_sqlite_pool(self): names = ['t1:write:0', 't0:read:0', 't1:done'] steps = self.getTestSteps(names) with self.getTestDir() as dirn: path = os.path.join(dirn, 'db0.db') with s_sqlite.pool(3, path) as pool: self.eq(pool.avail(), 3) with pool.xact() as xact: self.eq(pool.avail(), 2) xact.execute('CREATE TABLE test ( foo VARCHAR, bar INT )') self.eq(pool.avail(), 3) ############################################################### def t1(): with pool.xact() as xact1: xact1.execute( 'INSERT INTO test (foo,bar) VALUES ("lol", 20)') xact1.executemany( 'INSERT INTO test (foo,bar) VALUES (?, ?)', [('lol', 30), ('lol', 40)]) steps.step('t1:write:0', 't0:read:0', timeout=8) steps.done('t1:done') ############################################################### thrd = s_threads.worker(t1) with pool.xact() as xact0: # wait for t1 to hold a write xact open... steps.wait('t1:write:0') # we should be able to see his un-commited write due to shared cache # ( using a select query to specifically avoid the write lock ) rows = list(xact0.select('SELECT * FROM test')) self.isin(('lol', 20), rows) self.isin(('lol', 30), rows) self.isin(('lol', 40), rows) # allow t1 to close the write xact steps.step('t0:read:0', 't1:done', timeout=8) # now we can write... xact0.execute('INSERT INTO test (foo, bar) VALUES (?, ?)', ('hah', 30)) self.none(thrd.join(timeout=8)) with pool.xact() as xact2: # we should see our previously commited write rows = list( xact2.select('SELECT * FROM test WHERE foo = ?', ('hah', ))) self.len(1, rows) self.eq( 1, xact2.update('UPDATE test SET foo = ? WHERE foo = ?', ('heh', 'hah'))) # ensure that the pool commit/fini wrote all data... with s_sqlite.pool(2, path) as pool: with pool.xact() as xact: # we should see our previously commited write rows = list(xact.select('SELECT * FROM test')) self.len(4, rows) with s_sqlite.pool(2, path) as pool: with pool.xact() as xact: pool.fini() # the xact should be fini because the pool is fini self.raises(IsFini, xact.select, 'SELECT * FROM test') self.raises(IsFini, xact.wrlock)