Time out question

[DarkBlue]

My application makes several connections to
a remote database server via tcp/ip.
Usually all is fine,but occasionally the server is
down or the internet does not work and then there is
the 30 sec to several minutes timeout wait for the
tcp to give up.
Is there anything I can do without using
threads,sockets ,twisted etc. to have following :

pseudocode :

try for 10 seconds
if database.connec ted :
do your remote thing
except raise after 10 seconds
abort any connection attempt
do something else
Thanks

[Alex Martelli]

DarkBlue <no****@nixmail .comwrote:

My application makes several connections to
a remote database server via tcp/ip.
Usually all is fine,but occasionally the server is
down or the internet does not work and then there is
the 30 sec to several minutes timeout wait for the
tcp to give up.
Is there anything I can do without using
threads,sockets ,twisted etc. to have following :

pseudocode :

try for 10 seconds
if database.connec ted :
do your remote thing
except raise after 10 seconds
abort any connection attempt
do something else

Sure, see function setdefaulttimeo ut in module socket. Just call it as
you wish before trying the DB connection and catch the resulting
exception.
Alex

[DarkBlue]

>
Sure, see function setdefaulttimeo ut in module socket. Just call it as
you wish before trying the DB connection and catch the resulting
exception.
Alex

That should do it.

Thanks
Db

[Nick Craig-Wood]

Alex Martelli <al***@mac.comw rote:

DarkBlue <no****@nixmail .comwrote:

try for 10 seconds
if database.connec ted :
do your remote thing
except raise after 10 seconds
abort any connection attempt
do something else

Sure, see function setdefaulttimeo ut in module socket. Just call it as
you wish before trying the DB connection and catch the resulting
exception.

It would be nice to have language support for the general case, ie a
general purpose timeout.

In python 2.5 wouldn't it be nice to write

with timeout(seconds =10) as time_exceeded:
do potentially time consuming stuff not necessarily involving sockets
if time_exceeded:
report an error or whatever

Here is some code I came up with to implement this idea for
python2.3+. It should be cross platform but I only tested it on
linux. I think there may still be a threading bug in there (see
FIXME), but it seems to work. It requires ctypes for access to
PyThreadState_S etAsyncExc).

It is mostly test code as it took absolutely ages to debug! Threading
code is hard ;-)

............... ............... ............... ............... .

"""
General purpose timeout mechanism not using alarm(), ie cross platform

Eg

from timeout import Timeout, TimeoutError

def might_infinite_ loop(arg):
while 1:
pass

try:
Timeout(10, might_infinite_ loop, "some arg")
except TimeoutError:
print "Oops took too long"
else:
print "Ran just fine"

"""

import threading
import time
import sys
import ctypes
import os

class TimeoutError(Ex ception):
"""Thrown on a timeout"""
PyThreadState_S etAsyncExc = ctypes.pythonap i.PyThreadState _SetAsyncExc
_c_TimeoutError = ctypes.py_objec t(TimeoutError)

class Timeout(threadi ng.Thread):
"""
A General purpose timeout class
timeout is int/float in seconds
action is a callable
*args, **kwargs are passed to the callable
"""
def __init__(self, timeout, action, *args, **kwargs):
threading.Threa d.__init__(self )
self.action = action
self.args = args
self.kwargs = kwargs
self.stopped = False
self.exc_value = None
self.end_lock = threading.Lock( )
# start subtask
self.setDaemon( True) # FIXME this shouldn't be needed but is, indicating sub tasks aren't ending
self.start()
# Wait for subtask to end naturally
self.join(timeo ut)
# Use end_lock to kill the thread in a non-racy
# fashion. (Using isAlive is racy). Poking exceptions into
# the Thread cleanup code isn't a good idea either
if self.end_lock.a cquire(False):
# gained end_lock =sub thread is still running
# sub thread is still running so kill it with a TimeoutError
self.exc_value = TimeoutError()
PyThreadState_S etAsyncExc(self .id, _c_TimeoutError )
# release the lock so it can progress into thread cleanup
self.end_lock.r elease()
# shouldn't block since we've killed the thread
self.join()
# re-raise any exception
if self.exc_value:
raise self.exc_value
def run(self):
self.id = threading._get_ ident()
try:
self.action(*se lf.args, **self.kwargs)
except:
self.exc_value = sys.exc_value
# only end if we can acquire the end_lock
self.end_lock.a cquire()

if __name__ == "__main__":

def _spin(t):
"""Spins for t seconds"""
start = time.time()
end = start + t
while time.time() < end:
pass

def _test_time_limi t(name, expecting_time_ out, t_limit, fn, *args, **kwargs):
"""Test Timeout"""
start = time.time()

if expecting_time_ out:
print "Test",name,"sh ould timeout"
else:
print "Test",name,"sh ouldn't timeout"

try:
Timeout(t_limit , fn, *args, **kwargs)
except TimeoutError, e:
if expecting_time_ out:
print "Timeout generated OK"
else:
raise RuntimeError("W asn't expecting TimeoutError Here")
else:
if expecting_time_ out:
raise RuntimeError("W as expecting TimeoutError Here")
else:
print "No TimeoutError generated OK"

elapsed = time.time() - start
print "That took",elapsed," seconds for timeout of",t_limit

def test():
"""Test code"""

# NB the commented out bits of code don't work with this type
# of timeout nesting.

# no nesting
_test_time_limi t("simple #1", True, 5, _spin, 10)
_test_time_limi t("simple #2", False, 10, _spin, 5)

# 1 level of nesting
_test_time_limi t("nested #1", True, 4, _test_time_limi t,
"nested #1a", True, 5, _spin, 10)
_test_time_limi t("nested #2", False, 6, _test_time_limi t,
"nested #2a", True, 5, _spin, 10)
#_test_time_lim it("nested #3", True, 4, _test_time_limi t,
# "nested #3a", False, 10, _spin, 5)
_test_time_limi t("nested #4", False, 6, _test_time_limi t,
"nested #4a", False, 10, _spin, 5)

# 2 level of nesting
_test_time_limi t("nested #5", True, 3, _test_time_limi t,
"nested #5a", True, 4, _test_time_limi t,
"nested #5b", True, 5, _spin, 10)
#_test_time_lim it("nested #6", True, 3, _test_time_limi t,
# "nested #6a", False, 6, _test_time_limi t,
# "nested #6b", True, 5, _spin, 10)
#_test_time_lim it("nested #7", True, 3, _test_time_limi t,
# "nested #7a", True, 4, _test_time_limi t,
# "nested #7b", False, 10, _spin, 5)
#_test_time_lim it("nested #8", True, 3, _test_time_limi t,
# "nested #8a", False, 6, _test_time_limi t,
# "nested #8b", False, 10, _spin, 5)
_test_time_limi t("nested #9", False, 7, _test_time_limi t,
"nested #9a", True, 4, _test_time_limi t,
"nested #9b", True, 5, _spin, 10)
_test_time_limi t("nested #10", False, 7, _test_time_limi t,
"nested #10a",False, 6, _test_time_limi t,
"nested #10b",True, 5, _spin, 10)
#_test_time_lim it("nested #11", False, 7, _test_time_limi t,
# "nested #11a",True, 4, _test_time_limi t,
# "nested #11b",False, 10, _spin, 5)
_test_time_limi t("nested #12", False, 7, _test_time_limi t,
"nested #12a",False, 6, _test_time_limi t,
"nested #12b",False, 10, _spin, 5)

print "All tests OK"

test()
--
Nick Craig-Wood <ni**@craig-wood.com-- http://www.craig-wood.com/nick

[Grant Edwards]

On 2006-07-03, Nick Craig-Wood <ni**@craig-wood.comwrote:

Alex Martelli <al***@mac.comw rote:

> DarkBlue <no****@nixmail .comwrote:

try for 10 seconds
if database.connec ted :
do your remote thing
except raise after 10 seconds
abort any connection attempt
do something else

Sure, see function setdefaulttimeo ut in module socket. Just call it as
you wish before trying the DB connection and catch the resulting
exception.

It would be nice to have language support for the general case, ie a
general purpose timeout.

I just use signal.alarm():

import signal,sys

def alarmHandler(si gnum, frame):
raise 'Timeout'

signal.signal(s ignal.SIGALRM, alarmHandler)

while 1:
try:
signal.alarm(5)
t = sys.stdin.readl ine()
signal.alarm(0)
print t
except 'Timeout':
print "too slow"

--
Grant Edwards grante Yow! I will SHAVE and
at buy JELL-O and bring my
visi.com MARRIAGE MANUAL!!

[Rune Strand]

Grant Edwards wrote:

I just use signal.alarm():

import signal,sys

def alarmHandler(si gnum, frame):
raise 'Timeout'

signal.signal(s ignal.SIGALRM, alarmHandler)

while 1:
try:
signal.alarm(5)
t = sys.stdin.readl ine()
signal.alarm(0)
print t
except 'Timeout':
print "too slow"

--

Very nice, but UNIX only.

[Nick Craig-Wood]

Grant Edwards <gr****@visi.co mwrote:

On 2006-07-03, Nick Craig-Wood <ni**@craig-wood.comwrote:

Alex Martelli <al***@mac.comw rote:

DarkBlue <no****@nixmail .comwrote:
try for 10 seconds
if database.connec ted :
do your remote thing
except raise after 10 seconds
abort any connection attempt
do something else

Sure, see function setdefaulttimeo ut in module socket. Just call it as
you wish before trying the DB connection and catch the resulting
exception.

It would be nice to have language support for the general case, ie a
general purpose timeout.

I just use signal.alarm():

There are quite a lot of problems with alarm()

1) doesn't work on windows
2) there is only one alarm so nested alarms are tricky
3) alarm() only has 1 second resolution, however you can use the POSIX
setitimer() which has better resolution
4) signals make havoc with some things (signals are basically
interrupts passed to user space under unix)
5) alarm() doesn't play nice with threads

All that said it does work under unix for a lot of programs. Here is
a module which fixes point 2) anyway...

It is a lot easier to follow than the threads example I posted
earlier. There are still potential race conditions though even with
something as simple as alarm()!

............... ............... ............... ............... .

"""
Implement time limited function calls. Only works on platforms which
support the signal module and signal.alarm()

Eg

from time_limit import time_limit, TimeOut

def might_infinite_ loop(arg):
while 1:
pass

try:
time_limit(10, might_infinite_ loop, "some arg")
except TimeOut:
print "Oops took too long"
else:
print "Ran just fine"

"""

import signal
import time
import inspect

class TimeOut(Excepti on):
"""Thrown on alarm"""
pass

class _NestedTimeOut( Exception):
"""Thrown on TimeOut detected for next layer"""
pass

def _sig_alarm(sign um, frame):
"""Alarm handler for this module"""
raise TimeOut()

def time_limit(t_li mit, fn, *args, **kwargs):
"""
Calls fn with the *args and **kwargs returning its result or
raising a TimeOut exception if it doesn't complete within t
seconds
"""

# Turn alarm off and read old value
old_t_limit = signal.alarm(0)
start_time = time.time()
# Install new handler remembering old
old_handler = signal.signal(s ignal.SIGALRM, _sig_alarm)
# Set the timer going
signal.alarm(t_ limit)

try:
try:
try:
rc = fn(*args, **kwargs)
except _NestedTimeOut:
raise TimeOut()
finally:
# Disable alarm
signal.alarm(0)
finally:
# Alarm will be disabled or will have gone off when we get here
# Restore the old handler
signal.signal(s ignal.SIGALRM, old_handler)
# If there was an alarm running restore it
if old_t_limit 0:
# Calculate how much of the old timeout is left
elapsed_time = time.time() - start_time
old_t_limit = int(round(old_t _limit - elapsed_time, 0))
if old_t_limit <= 0:
# Alarm should have gone off so call old signal handler
if old_handler == _sig_alarm:
# If handler is our handler then...
raise _NestedTimeOut( )
else:
# Call old handler
old_handler(sig nal.SIGALRM, inspect.current frame())
else:
# Re-enable alarm
signal.alarm(ol d_t_limit)

return rc

if __name__ == "__main__":

def _spin(t):
"""Spins for t seconds"""
start = time.time()
end = start + t
while time.time() < end:
pass

def _test_time_limi t(name, expecting_time_ out, t_limit, fn, *args, **kwargs):
"""Test time_limit"""
start = time.time()

if expecting_time_ out:
print "Test",name,"sh ould timeout"
else:
print "Test",name,"sh ouldn't timeout"

try:
time_limit(t_li mit, fn, *args, **kwargs)
except TimeOut, e:
if expecting_time_ out:
print "Timeout generated OK"
else:
raise RuntimeError("W asn't expecting TimeOut Here")
else:
if expecting_time_ out:
raise RuntimeError("W as expecting TimeOut Here")
else:
print "No timeout generated OK"

elapsed = time.time() - start
print "That took",elapsed," seconds for timeout of",t_limit

def test():
"""Test code"""

# no nesting
_test_time_limi t("simple #1", True, 5, _spin, 10)
_test_time_limi t("simple #2", False, 10, _spin, 5)

# 1 level of nesting
_test_time_limi t("nested #1", True, 4, _test_time_limi t, "nested #1a", True, 5, _spin, 10)
_test_time_limi t("nested #2", False, 6, _test_time_limi t, "nested #2a", True, 5, _spin, 10)
_test_time_limi t("nested #3", True, 4, _test_time_limi t, "nested #3a", False, 10, _spin, 5)
_test_time_limi t("nested #4", False, 6, _test_time_limi t, "nested #4a", False, 10, _spin, 5)

# 2 level of nesting
_test_time_limi t("nested #5", True, 3, _test_time_limi t, "nested #5a", True, 4, _test_time_limi t, "nested #5b", True, 5, _spin, 10)
_test_time_limi t("nested #6", True, 3, _test_time_limi t, "nested #6a", False, 6, _test_time_limi t, "nested #6b", True, 5, _spin, 10)
_test_time_limi t("nested #7", True, 3, _test_time_limi t, "nested #7a", True, 4, _test_time_limi t, "nested #7b", False, 10, _spin, 5)
_test_time_limi t("nested #8", True, 3, _test_time_limi t, "nested #8a", False, 6, _test_time_limi t, "nested #8b", False, 10, _spin, 5)
_test_time_limi t("nested #9", False, 7, _test_time_limi t, "nested #9a", True, 4, _test_time_limi t, "nested #9b", True, 5, _spin, 10)
_test_time_limi t("nested #10", False, 7, _test_time_limi t, "nested #10a", False, 6, _test_time_limi t, "nested #10b", True, 5, _spin, 10)
_test_time_limi t("nested #11", False, 7, _test_time_limi t, "nested #11a", True, 4, _test_time_limi t, "nested #11b", False, 10, _spin, 5)
_test_time_limi t("nested #12", False, 7, _test_time_limi t, "nested #12a", False, 6, _test_time_limi t, "nested #12b", False, 10, _spin, 5)

print "All tests OK"

test()

--
Nick Craig-Wood <ni**@craig-wood.com-- http://www.craig-wood.com/nick