def _run_impl(self):
sync = Greenlet(retry_and_report_killed, self.sync,
account_id=self.account_id, logger=self.log,
fail_classes=self.retry_fail_classes)
sync.start()
while not sync.ready():
try:
cmd = self.inbox.get_nowait()
if not self.process_command(cmd):
# ctrl-c, basically!
self.log.info("Stopping sync", email=self.email_address)
# make sure the parent can't start/stop any folder monitors
# first
sync.kill(block=True)
self.folder_monitors.kill()
return
except Empty:
sleep(self.heartbeat)
if sync.successful():
self.folder_monitors.kill()
return
# We just want the name of the exception so don't bother with
# sys.exc_info()
self.log.error('mail sync should run forever',
provider=self.provider_name,
account_id=self.account_id,
exception=type(sync.exception).__name__)
raise sync.exception
def _run_impl(self):
sync = Greenlet(retry_with_logging,
self.sync,
account_id=self.account_id,
logger=self.log)
sync.start()
while not sync.ready():
if self.shutdown.is_set():
# Ctrl-c, basically!
self.log.info('Stopping sync',
email=self.email_address,
account_id=self.account_id)
# Make sure the parent can't start/stop any folder monitors
# first
sync.kill(block=True)
return self._cleanup()
else:
sleep(self.heartbeat)
if sync.successful():
return self._cleanup()
# We just want the name of the exception so don't bother with
# sys.exc_info()
self.log.error('mail sync should run forever',
provider=self.provider_name,
account_id=self.account_id,
exception=type(sync.exception).__name__)
raise sync.exception
def _run_impl(self):
sync = Greenlet(retry_with_logging, self.sync,
account_id=self.account_id, logger=self.log)
sync.start()
while not sync.ready():
if self.shutdown.is_set():
# Ctrl-c, basically!
self.log.info('Stopping sync', email=self.email_address,
account_id=self.account_id)
# Make sure the parent can't start/stop any folder monitors
# first
sync.kill(block=True)
return self._cleanup()
else:
sleep(self.heartbeat)
if sync.successful():
return self._cleanup()
# We just want the name of the exception so don't bother with
# sys.exc_info()
self.log.error('mail sync should run forever',
provider=self.provider_name,
account_id=self.account_id,
exception=type(sync.exception).__name__)
raise sync.exception
def _run_impl(self):
sync = Greenlet(retry_and_report_killed, self.sync,
account_id=self.account_id, logger=self.log)
sync.start()
while not sync.ready():
try:
cmd = self.inbox.get_nowait()
if not self.process_command(cmd):
# ctrl-c, basically!
self.log.info("Stopping sync", email=self.email_address)
# make sure the parent can't start/stop any folder monitors
# first
sync.kill(block=True)
self.folder_monitors.kill()
return
except Empty:
sleep(self.heartbeat)
if sync.successful():
self.folder_monitors.kill()
return
self.log.error("mail sync should run forever",
provider=self.provider_name,
account_id=self.account_id)
raise sync.exception
def _run_impl(self):
sync = Greenlet(retry_and_report_killed,
self.sync,
account_id=self.account_id,
logger=self.log)
sync.link_value(lambda _: report_stopped(account_id=self.account_id))
sync.start()
while not sync.ready():
try:
cmd = self.inbox.get_nowait()
if not self.process_command(cmd):
# ctrl-c, basically!
self.log.info("Stopping sync", email=self.email_address)
# make sure the parent can't start/stop any folder monitors
# first
sync.kill(block=True)
self.folder_monitors.kill()
return
except Empty:
sleep(self.heartbeat)
if sync.successful():
self.folder_monitors.kill()
return
self.log.error("mail sync should run forever",
provider=self.provider_name,
account_id=self.account_id)
raise sync.exception
def _run_impl(self):
sync = Greenlet(retry_and_report_killed,
self.sync,
account_id=self.account_id,
logger=self.log,
fail_classes=self.retry_fail_classes)
sync.start()
while not sync.ready():
try:
cmd = self.inbox.get_nowait()
if not self.process_command(cmd):
# ctrl-c, basically!
self.log.info("Stopping sync", email=self.email_address)
# make sure the parent can't start/stop any folder monitors
# first
sync.kill(block=True)
self.folder_monitors.kill()
return
except Empty:
sleep(self.heartbeat)
if sync.successful():
self.folder_monitors.kill()
return
# We just want the name of the exception so don't bother with
# sys.exc_info()
self.log.error('mail sync should run forever',
provider=self.provider_name,
account_id=self.account_id,
exception=type(sync.exception).__name__)
raise sync.exception
def check_stream(client, namespace, stream, start, end, limit, timeout,
latency):
def run():
for event in client.get(stream, start, end, limit=limit, timeout=latency):
# Yeah, I'm useless.
pass
read_greenlet = Greenlet(run)
read_greenlet.start()
read_greenlet.join(timeout)
if not read_greenlet.ready():
read_greenlet.kill()
success = False
else:
success = read_greenlet.successful()
return success
def check_stream(client, namespace, stream, start, end, limit, timeout,
latency):
def run():
for event in client.get(stream,
start,
end,
limit=limit,
timeout=latency):
# Yeah, I'm useless.
pass
read_greenlet = Greenlet(run)
read_greenlet.start()
read_greenlet.join(timeout)
if not read_greenlet.ready():
read_greenlet.kill()
success = False
else:
success = read_greenlet.successful()
return success
def _run_impl(self):
sync = Greenlet(retry_and_report_killed, self.sync,
account_id=self.account_id, logger=self.log)
sync.link_value(lambda _: report_stopped(account_id=self.account_id))
sync.start()
while not sync.ready():
try:
cmd = self.inbox.get_nowait()
if not self.process_command(cmd):
# ctrl-c, basically!
self.log.info("Stopping sync for {0}".format(
self.email_address))
# make sure the parent can't start/stop any folder monitors
# first
sync.kill(block=True)
self.folder_monitors.kill()
return
except Empty:
sleep(self.heartbeat)
assert not sync.successful(), \
"mail sync for {} account {} should run forever!"\
.format(self.provider, self.account_id)
raise sync.exception
class BaseMailSyncMonitor(Greenlet):
"""
The SYNC_MONITOR_CLS for all mail sync providers should subclass this.
Parameters
----------
account_id : int
Which account to sync.
email_address : str
Email address for `account_id`.
provider : str
Provider for `account_id`.
heartbeat : int
How often to check for commands.
"""
def __init__(self, account, heartbeat=1):
bind_context(self, "mailsyncmonitor", account.id)
self.shutdown = event.Event()
# how often to check inbox, in seconds
self.heartbeat = heartbeat
self.log = log.new(component="mail sync", account_id=account.id)
self.account_id = account.id
self.namespace_id = account.namespace.id
self.email_address = account.email_address
self.provider_name = account.verbose_provider
Greenlet.__init__(self)
def _run(self):
try:
return retry_with_logging(
self._run_impl,
account_id=self.account_id,
provider=self.provider_name,
logger=self.log,
)
except GreenletExit:
self._cleanup()
raise
def _run_impl(self):
self.sync = Greenlet(
retry_with_logging,
self.sync,
account_id=self.account_id,
provider=self.provider_name,
logger=self.log,
)
self.sync.start()
self.sync.join()
if self.sync.successful():
return self._cleanup()
self.log.error(
"mail sync should run forever",
provider=self.provider_name,
account_id=self.account_id,
exc=self.sync.exception,
)
raise self.sync.exception
def sync(self):
raise NotImplementedError
def _cleanup(self):
self.sync.kill()
with session_scope(self.namespace_id) as mailsync_db_session:
map(lambda x: x.set_stopped(mailsync_db_session), self.folder_monitors)
self.folder_monitors.kill()
# Block until all threads complete.
gevent.joinall(threads)
"""
def foo():
print "foo"
print gevent.getcurrent()
gevent.sleep(2)
return "foo"
def foo2(green):
print("foo2")
print gevent.getcurrent()
return "foo2"
print gevent.getcurrent()
t = Greenlet(foo)
print t.ready()
t.start()
t.link(foo2)
t.join(0)
#t.kill()
print "yes"
print t.ready()
print t.successful()
#print t.get()
print t.value
class BaseMailSyncMonitor(Greenlet):
"""
The SYNC_MONITOR_CLS for all mail sync providers should subclass this.
Parameters
----------
account_id : int
Which account to sync.
email_address : str
Email address for `account_id`.
provider : str
Provider for `account_id`.
heartbeat : int
How often to check for commands.
"""
def __init__(self, account, heartbeat=1):
bind_context(self, 'mailsyncmonitor', account.id)
self.shutdown = event.Event()
# how often to check inbox, in seconds
self.heartbeat = heartbeat
self.log = log.new(component='mail sync', account_id=account.id)
self.account_id = account.id
self.namespace_id = account.namespace.id
self.email_address = account.email_address
self.provider_name = account.verbose_provider
Greenlet.__init__(self)
def _run(self):
try:
return retry_with_logging(self._run_impl,
account_id=self.account_id,
provider=self.provider_name,
logger=self.log)
except GreenletExit:
self._cleanup()
raise
def _run_impl(self):
self.sync = Greenlet(retry_with_logging, self.sync,
account_id=self.account_id,
provider=self.provider_name,
logger=self.log)
self.sync.start()
self.sync.join()
if self.sync.successful():
return self._cleanup()
self.log.error('mail sync should run forever',
provider=self.provider_name,
account_id=self.account_id,
exc=self.sync.exception)
raise self.sync.exception
def sync(self):
raise NotImplementedError
def _cleanup(self):
self.sync.kill()
with session_scope(self.namespace_id) as mailsync_db_session:
map(lambda x: x.set_stopped(mailsync_db_session),
self.folder_monitors)
self.folder_monitors.kill()
