def __init__(self, process_num = 1):
if MultiProcessProjectImport._instance == None:
self.process_num = process_num
for i in xrange(process_num):
pipe_master, pipe_client = Pipe()
MultiProcessProjectImport.WRITE_LOCKS.append(toro.Lock())
MultiProcessProjectImport.READ_LOCKS.append(toro.Lock())
p = ProjectImportProcess(i, pipe_client)
p.daemon = True
MultiProcessProjectImport.PROCESS_LIST.append(p)
MultiProcessProjectImport.PROCESS_DICT[i] = [p, pipe_master]
p.start()
MultiProcessProjectImport._instance = self
else:
self.process_num = MultiProcessProjectImport._instance.process_num
def test_acquire_release(self):
lock = toro.Lock()
self.assertFalse(lock.locked())
self.assertTrue(lock.acquire())
self.assertTrue(lock.locked())
lock.release()
self.assertFalse(lock.locked())
def test_acquire_callback(self):
lock = toro.Lock()
history = []
lock.acquire().add_done_callback(make_callback('acquire1', history))
lock.acquire().add_done_callback(make_callback('acquire2', history))
lock.release()
history.append('release')
self.assertEqual(['acquire1', 'acquire2', 'release'], history)
def __init__(self, filename, name, description, params, filtered_params,
needs_lock):
self.lock = toro.Lock()
self.filename = filename
self.name = name
self.description = description
self.params = params
self.filtered_params = filtered_params
self.needs_lock = needs_lock
def __init__(self, filename, name, description, params, filtered_params, tags, http_method, output, needs_lock):
self.lock = toro.Lock()
self.filename = filename
self.name = name
self.description = description
self.params = params
self.filtered_params = filtered_params
self.tags = tags
self.http_method = http_method
self.needs_lock = needs_lock
self.output = output
def test_acquire_timeout(self):
lock = toro.Lock()
self.assertTrue(lock.acquire())
self.assertTrue(lock.locked())
st = time.time()
with assert_raises(toro.Timeout):
yield lock.acquire(deadline=timedelta(seconds=0.1))
duration = time.time() - st
self.assertAlmostEqual(0.1, duration, places=1)
self.assertTrue(lock.locked())
def test_acquire_contended(self):
lock = toro.Lock()
self.assertTrue(lock.acquire())
N = 5
@gen.coroutine
def f():
yield lock.acquire()
lock.release()
futures = [f() for _ in range(N)]
lock.release()
yield futures
def __init__(self, connection_pool, refresh_interval, io_loop=None, executor=None):
self.io_loop = io_loop or IOLoop.instance()
self.executor = executor or self.executor
self.connection_pool = connection_pool
self.lock = toro.Lock()
self.name = self.__class__.__name__
self.status = "Started"
self.runtime = 0
self.refresh_finished_at = None
self.refresh_started_at = None
self.refresh_interval = refresh_interval.seconds
self.periodic_callback = PeriodicCallback(self._refresh, refresh_interval.seconds*1000)
def __init__(self, host, port, stream=None, io_loop=None,
read_timeout=DEFAULT_READ_TIMEOUT):
self.host = host
self.port = port
self.io_loop = io_loop or ioloop.IOLoop.current()
self.read_timeout = read_timeout
self.is_queuing_reads = False
self.read_queue = []
self.__wbuf = BytesIO()
self._read_lock = toro.Lock()
# servers provide a ready-to-go stream
self.stream = stream
if self.stream is not None:
self._set_close_callback()
def test_reacquire(self):
# Lock needs to be released before re-acquiring.
lock = toro.Lock()
phase = []
@gen.coroutine
def f():
yield lock.acquire()
self.assertTrue(lock.locked())
phase.append(None)
yield lock.acquire()
self.assertTrue(lock.locked())
phase.append(None)
future = f()
while len(phase) == 0:
yield gen.Task(self.io_loop.add_callback)
self.assertEqual(len(phase), 1)
lock.release()
yield future
self.assertEqual(len(phase), 2)
def test_str(self):
lock = toro.Lock()
# No errors in various states
str(lock)
lock.acquire()
str(lock)
def test_multi_release(self):
lock = toro.Lock()
lock.acquire()
lock.release()
self.assertRaises(RuntimeError, lock.release)
``shutdown`` stops the IOLoop. We want any request that ``poll`` has begun to
complete before the loop stops, so ``poll`` acquires the lock before starting
each HTTP request and releases it when the request completes. ``shutdown`` also
acquires the lock before stopping the IOLoop.
(Inspired by a post_ to the Tornado mailing list.)
.. _post: https://groups.google.com/d/topic/python-tornado/CXg5WwufOvU/discussion
"""
# start-file
import datetime
from tornado import ioloop, gen, httpclient
import toro
lock = toro.Lock()
loop = ioloop.IOLoop.current()
@gen.coroutine
def poll():
client = httpclient.AsyncHTTPClient()
while True:
with (yield lock.acquire()):
print 'Starting request'
response = yield client.fetch('http://www.tornadoweb.org/')
print response.code
# Wait a tenth of a second before next request
yield gen.Task(loop.add_timeout, datetime.timedelta(seconds=0.1))
