def testPushPop(self):
self.assertEquals(TIMEOUT_NEVER, Timeout.current())
Timeout.push(30)
self.assertAlmostEqual(30, Timeout.current(), places=1)
Timeout.pop()
self.assertEquals(TIMEOUT_NEVER, Timeout.current())
Timeout.push(30)
self.assertAlmostEqual(30, Timeout.current(), places=1)
Tasklet.sleep(1.0)
self.assertAlmostEqual(29, Timeout.current(), places=1)
#push a temporary short timeout
Timeout.push(5)
self.assertAlmostEqual(5, Timeout.current(), places=1)
Timeout.pop()
self.assertAlmostEqual(29, Timeout.current(), places=1)
#try to push a new longer timeout than the parent timeout
#this should fail, e.g. it will keep the parent timeout
Timeout.push(60)
self.assertAlmostEqual(29, Timeout.current(), places=1)
Timeout.pop()
self.assertAlmostEqual(29, Timeout.current(), places=1)
Timeout.pop()
self.assertEquals(TIMEOUT_NEVER, Timeout.current())
def testPushPop(self):
self.assertEquals(TIMEOUT_NEVER, Timeout.current())
Timeout.push(30)
self.assertAlmostEqual(30, Timeout.current(), places = 1)
Timeout.pop()
self.assertEquals(TIMEOUT_NEVER, Timeout.current())
Timeout.push(30)
self.assertAlmostEqual(30, Timeout.current(), places = 1)
Tasklet.sleep(1.0)
self.assertAlmostEqual(29, Timeout.current(), places = 1)
#push a temporary short timeout
Timeout.push(5)
self.assertAlmostEqual(5, Timeout.current(), places = 1)
Timeout.pop()
self.assertAlmostEqual(29, Timeout.current(), places = 1)
#try to push a new longer timeout than the parent timeout
#this should fail, e.g. it will keep the parent timeout
Timeout.push(60)
self.assertAlmostEqual(29, Timeout.current(), places = 1)
Timeout.pop()
self.assertAlmostEqual(29, Timeout.current(), places = 1)
Timeout.pop()
self.assertEquals(TIMEOUT_NEVER, Timeout.current())
def testPushPop4(self):
self.assertEquals(TIMEOUT_NEVER, Timeout.current())
Tasklet.set_current_timeout(10.0)
self.assertAlmostEqual(10.0, Timeout.current(), places=1)
Timeout.push(TIMEOUT_CURRENT)
self.assertAlmostEqual(10.0, Timeout.current(), places=1)
Timeout.pop()
self.assertAlmostEqual(10.0, Timeout.current(), places=1)
Tasklet.set_current_timeout(TIMEOUT_NEVER)
def testPushPop4(self):
self.assertEquals(TIMEOUT_NEVER, Timeout.current())
Tasklet.set_current_timeout(10.0)
self.assertAlmostEqual(10.0, Timeout.current(), places = 1)
Timeout.push(TIMEOUT_CURRENT)
self.assertAlmostEqual(10.0, Timeout.current(), places = 1)
Timeout.pop()
self.assertAlmostEqual(10.0, Timeout.current(), places = 1)
Tasklet.set_current_timeout(TIMEOUT_NEVER)
def writeToStream(self):
#forward data to receiving socket
self.buffer.flip()
while self.buffer.remaining:
if not self.writeStream.write(self.buffer, Timeout.current()):
return False
return True
def connect(self, addr):
assert self._stream is None, "must not be disconneted before connecting"
self._stream = BufferedStream(Socket.connect(addr, Timeout.current()))
self._command_queue = Deque()
self._response_queue = Deque()
self._command_writer_task = Tasklet.new(self._command_writer)()
self._response_reader_task = Tasklet.new(self._response_reader)()
def connect(self, addr):
assert self._stream is None, "must not be disconneted before connecting"
self._stream = BufferedStream(Socket.connect(addr, Timeout.current()))
self._command_queue = Deque()
self._response_queue = Deque()
self._command_writer_task = Tasklet.new(self._command_writer)()
self._response_reader_task = Tasklet.new(self._response_reader)()
def connect(cls, endpoint):
if isinstance(endpoint, Connector):
assert False, "TODO"
else:
#default is to connect to Socket and endpoint is address
from concurrence.io.socket import Socket
from concurrence.timer import Timeout
return Socket.connect(endpoint, Timeout.current())
def connect(cls, endpoint):
if isinstance(endpoint, Connector):
assert False, "TODO"
else:
#default is to connect to Socket and endpoint is address
from concurrence.io.socket import Socket
from concurrence.timer import Timeout
return Socket.connect(endpoint, Timeout.current())
def readFromStream(self):
#read some data from stream into buffer
if self.remaining:
#some leftover partially read packet from previous read, put it in front of buffer
self.buffer.limit = self.buffer.position + self.remaining
self.buffer.compact()
else:
#normal clear, position = 0, limit = capacity
self.buffer.clear()
#read data from socket
return self.readStream.read(self.buffer, Timeout.current())
def connect(self,
host="localhost",
port=3306,
user="",
passwd="",
db="",
autocommit=None,
charset=None):
"""connects to the given host and port with user and passwd"""
#self.log.debug("connect mysql client %s %s %s %s %s", id(self), host, port, user, passwd)
try:
#print 'connect', host, user, passwd, db
#parse addresses of form str <host:port>
if type(host) == str:
if host[0] == '/': #assume unix domain socket
addr = host
elif ':' in host:
host, port = host.split(':')
port = int(port)
addr = (host, port)
else:
addr = (host, port)
assert self.state == self.STATE_INIT, "make sure connection is not already connected or closed"
self.state = self.STATE_CONNECTING
self.socket = Socket.connect(addr, timeout=Timeout.current())
self.reader = BufferedPacketReader(self.socket, self.buffer)
self.writer = BufferedPacketWriter(self.socket, self.buffer)
self._handshake(user, passwd, db)
#handshake complete client can now send commands
self.state = self.STATE_CONNECTED
if autocommit == False:
self.set_autocommit(False)
elif autocommit == True:
self.set_autocommit(True)
else:
pass #whatever is the default of the db (ON in the case of mysql)
if charset is not None:
self.set_charset(charset)
return self
except TimeoutError:
self.state = self.STATE_INIT
raise
except ClientLoginError:
self.state = self.STATE_INIT
raise
except:
self.state = self.STATE_ERROR
raise
def testTimer(self):
ch = Channel()
def sender(times):
for i in range(times):
Tasklet.sleep(1.0)
ch.send(True)
with Timeout.push(10):
Tasklet.new(sender)(4)
for i in range(4):
ch.receive(Timeout.current())
start = time.time()
try:
with Timeout.push(2.5):
Tasklet.new(sender)(4)
for i in range(4):
ch.receive(Timeout.current())
self.fail('expected timeout')
except TimeoutError, e:
end = time.time()
self.assertAlmostEqual(2.5, end - start, places=1)
def testTimer(self):
ch = Channel()
def sender(times):
for i in range(times):
Tasklet.sleep(1.0)
ch.send(True)
with Timeout.push(10):
Tasklet.new(sender)(4)
for i in range(4):
ch.receive(Timeout.current())
start = time.time()
try:
with Timeout.push(2.5):
Tasklet.new(sender)(4)
for i in range(4):
ch.receive(Timeout.current())
self.fail('expected timeout')
except TimeoutError, e:
end = time.time()
self.assertAlmostEqual(2.5, end - start, places = 1)
def connect(self, host = "localhost", port = 3306, user = "", passwd = "", db = "", autocommit = None, charset = None):
"""connects to the given host and port with user and passwd"""
#self.log.debug("connect mysql client %s %s %s %s %s", id(self), host, port, user, passwd)
try:
#print 'connect', host, user, passwd, db
#parse addresses of form str <host:port>
if type(host) == str:
if host[0] == '/': #assume unix domain socket
addr = host
elif ':' in host:
host, port = host.split(':')
port = int(port)
addr = (host, port)
else:
addr = (host, port)
assert self.state == self.STATE_INIT, "make sure connection is not already connected or closed"
self.state = self.STATE_CONNECTING
self.socket = Socket.connect(addr, timeout = Timeout.current())
self.reader = BufferedPacketReader(self.socket, self.buffer)
self.writer = BufferedPacketWriter(self.socket, self.buffer)
self._handshake(user, passwd, db)
#handshake complete client can now send commands
self.state = self.STATE_CONNECTED
if autocommit == False:
self.set_autocommit(False)
elif autocommit == True:
self.set_autocommit(True)
else:
pass #whatever is the default of the db (ON in the case of mysql)
if charset is not None:
self.set_charset(charset)
return self
except TimeoutError:
self.state = self.STATE_INIT
raise
except ClientLoginError:
self.state = self.STATE_INIT
raise
except:
self.state = self.STATE_ERROR
raise
def testPushPop2(self):
self.assertEquals(-1, Timeout.current())
Timeout.push(-1)
self.assertEquals(-1, Timeout.current())
Timeout.pop()
self.assertEquals(-1, Timeout.current())
Timeout.push(10)
self.assertAlmostEqual(10, Timeout.current(), places=1)
Timeout.push(5)
self.assertAlmostEqual(5, Timeout.current(), places=1)
Timeout.pop()
self.assertAlmostEqual(10, Timeout.current(), places=1)
Timeout.pop()
self.assertEquals(-1, Timeout.current())
def testPushPop2(self):
self.assertEquals(TIMEOUT_NEVER, Timeout.current())
Timeout.push(TIMEOUT_NEVER)
self.assertEquals(TIMEOUT_NEVER, Timeout.current())
Timeout.pop()
self.assertEquals(TIMEOUT_NEVER, Timeout.current())
Timeout.push(10)
self.assertAlmostEqual(10, Timeout.current(), places=1)
Timeout.push(5)
self.assertAlmostEqual(5, Timeout.current(), places=1)
Timeout.pop()
self.assertAlmostEqual(10, Timeout.current(), places=1)
Timeout.pop()
self.assertEquals(TIMEOUT_NEVER, Timeout.current())
def testPushPop2(self):
self.assertEquals(-1, Timeout.current())
Timeout.push(-1)
self.assertEquals(-1, Timeout.current())
Timeout.pop()
self.assertEquals(-1, Timeout.current())
Timeout.push(10)
self.assertAlmostEqual(10, Timeout.current(), places = 1)
Timeout.push(5)
self.assertAlmostEqual(5, Timeout.current(), places = 1)
Timeout.pop()
self.assertAlmostEqual(10, Timeout.current(), places = 1)
Timeout.pop()
self.assertEquals(-1, Timeout.current())
def testPushPop2(self):
self.assertEquals(TIMEOUT_NEVER, Timeout.current())
Timeout.push(TIMEOUT_NEVER)
self.assertEquals(TIMEOUT_NEVER, Timeout.current())
Timeout.pop()
self.assertEquals(TIMEOUT_NEVER, Timeout.current())
Timeout.push(10)
self.assertAlmostEqual(10, Timeout.current(), places = 1)
Timeout.push(5)
self.assertAlmostEqual(5, Timeout.current(), places = 1)
Timeout.pop()
self.assertAlmostEqual(10, Timeout.current(), places = 1)
Timeout.pop()
self.assertEquals(TIMEOUT_NEVER, Timeout.current())
def _get_connection_from_pool(self):
self.log.debug("get conn from pool")
return self._pool.pop(True, Timeout.current())
def _get_connection_from_pool(self):
self.log.debug("get conn from pool")
return self._pool.pop(True, Timeout.current())
def _read_more(self):
#any partially read data will be put in front, otherwise normal clear:
self.buffer.compact()
if not self.stream.read(self.buffer, Timeout.current()):
raise EOFError("while reading")
self.buffer.flip() #prepare to read from buffer
def flush(self):
self.buffer.flip()
while self.buffer.remaining:
if not self.stream.write(self.buffer, Timeout.current()):
raise EOFError("while writing")
self.buffer.clear()
