def handle(self, socket, application):
stream = BufferedStream(socket)
#implements http1.1 keep alive handler
#there are several concurrent tasks for each connection;
#1 for reading requests, 1 or more for handling requests and 1 for writing responses
#the current task (the one created to handle the socket connection) is the controller task,
#e.g. it coordinates the actions of it's children by message passing
control = Tasklet.current()
#writes responses back to the client when they are ready:
response_writer = Tasklet.new(self.write_responses,
name='response_writer')(control, stream)
#reads requests from clients:
request_reader = Tasklet.new(self.read_requests,
name='request_reader')(control, stream)
#typical flow:
#1. reader reads in request, sends notification to control (MSG_REQUEST_READ)
#2. control starts handler for the request
#3. handler works on request and sends notification to control when finished (MSG_REQUEST_HANDLED)
#4. control sends message to writer to start writing the response (MSG_WRITE_RESPONSE)
#5. writer notififies control when response is wriiten (MSG_RESPONSE_WRITTEN)
#control wait for msgs to arrive:
for msg, (request, response), kwargs in Tasklet.receive():
if msg.match(self.MSG_REQUEST_READ):
#we use reque to be able to send the responses back in the correct order later
self._reque.start(request)
Tasklet.new(self.handle_request,
name='request_handler')(control, request,
application)
elif msg.match(self.MSG_REQUEST_HANDLED):
#we use reque to retire (send out) the responses in the correct order
for request, response in self._reque.finish(request, response):
self.MSG_WRITE_RESPONSE.send(response_writer)(request,
response)
elif msg.match(self.MSG_RESPONSE_WRITTEN):
if request.version == 'HTTP/1.0':
break #no keep-alive support in http 1.0
elif request.get_response_header('Connection') == 'close':
break #response indicated to close after response
elif request.get_request_header('Connection') == 'close':
break #request indicated to close after response
elif msg.match(self.MSG_READ_ERROR):
break #stop and close the connection
elif msg.match(self.MSG_WRITE_ERROR):
break #stop and close the connection
else:
assert False, "unexpected msg in control loop"
#kill reader and writer
#any outstanding request will continue, but will exit by themselves
response_writer.kill()
request_reader.kill()
#close our side of the socket
stream.close()
def connect(self, endpoint):
"""Connect to the webserver at *endpoint*. *endpoint* is a tuple (<host>, <port>)."""
self._host = None
if type(endpoint) == type(()):
try:
self._host = endpoint[0]
except:
pass
self._stream = BufferedStream(Connector.connect(endpoint))
def handle(client_socket):
stream = BufferedStream(client_socket)
with stream.get_writer() as writer:
writer.write_bytes("HTTP/1.0 200 OK\r\n")
writer.write_bytes("Content-Length: 12\r\n")
writer.write_bytes("\r\n")
writer.write_bytes("Hello World!")
writer.flush()
stream.close()
def handler(client_socket):
"""writes the familiar greeting to client"""
stream = BufferedStream(client_socket)
writer = stream.writer
writer.write_bytes("HTTP/1.0 200 OK\r\n")
writer.write_bytes("Content-Length: 12\r\n")
writer.write_bytes("\r\n")
writer.write_bytes("Hello World!")
writer.flush()
stream.close()
def start(self, client_socket):
''' Start the task: start one tasklet listing for incomming connections. '''
#self.__receiving_tasklet = Tasklet.new(self.__serve)()
self.__client_socket = client_socket
self.__stream = BufferedStream(self.__client_socket)
q.logger.log("[SocketTaskHandler] Client connected.", 3)
self.__sending_tasklet = Tasklet.new(self.__send)()
self.__receiving_tasklet = Tasklet.new(self.__receive())()
def handler(client_socket):
"""writes the familiar greeting to client"""
cur_thread = threading.current_thread()
stream = BufferedStream(client_socket)
writer = stream.writer
writer.write_bytes("HTTP/1.0 200 OK\r\n")
writer.write_bytes("Content-Length: 12\r\n")
writer.write_bytes("\r\n")
writer.write_bytes("[%s:%s] - " % (cur_thread, Tasklet.current()))
writer.flush()
stream.close()
def handler(client_socket):
"""writes the familiar greeting to client"""
stream = BufferedStream(client_socket)
writer = stream.writer
writer.write_bytes("ok\r\n")
reader = stream.reader
buf = reader.read_bytes()
print buf
writer.write_bytes(buf + ':' + compute(buf) + '\n')
writer.flush()
stream.close()
def connect(self, endpoint):
"""Connect to the webserver at *endpoint*. *endpoint* is a tuple (<host>, <port>)."""
self._host = None
if type(endpoint) == type(()):
try:
self._host = endpoint[0]
except Exception:
pass
self._stream = BufferedStream(Connector.connect(endpoint),
read_buffer_size=1024 * 8,
write_buffer_size=1024 * 4)
def truncator():
while len(clients) < N:
Tasklet.sleep(1.0)
Tasklet.sleep(5.0)
while True:
print 'connecting truncator'
client = Socket.connect(('localhost', 6379))
stream = BufferedStream(client)
print 'issueing trunc of append only log'
bgrewriteaof(stream)
stream.close()
Tasklet.sleep(120.0)
def handler(client_socket):
print >> sys.stderr, 'info: connection from %r' % (
client_socket.socket.getpeername(), )
stream = BufferedStream(client_socket)
reader = stream.reader # Strips \r\n and \n from the end.
writer = stream.writer
# Read HTTP request.
line1 = None
try:
while True:
line = reader.read_line()
if not line: # Empty line, end of HTTP request.
break
if line1 is None:
line1 = line
except EOFError:
pass
# Parse HTTP request.
# Please note that an assertion here doesn't abort the server.
items = line1.split(' ')
assert 3 == len(items)
assert items[2] in ('HTTP/1.0', 'HTTP/1.1')
assert items[0] == 'GET'
assert items[1].startswith('/')
try:
num = int(items[1][1:])
except ValueError:
num = None
# Write HTTP response.
if num is None:
writer.write_bytes(
'HTTP/1.0 200 OK\r\nContent-Type: text/html\r\n\r\n')
writer.write_bytes('<a href="/0">start at 0</a><p>Hello, World!\n')
else:
next_num = lprng.Lprng(num).next()
writer.write_bytes(
'HTTP/1.0 200 OK\r\nContent-Type: text/html\r\n\r\n')
writer.write_bytes('<a href="/%d">continue with %d</a>\n' %
(next_num, next_num))
writer.flush()
stream.close()
def handle(client_socket):
"""handles a single client connected to the chat server"""
stream = BufferedStream(client_socket)
client_task = Tasklet.current() #this is the current task as started by server
connected_clients.add(client_task)
def writer():
for msg, args, kwargs in Tasklet.receive():
if msg.match(MSG_WRITE_LINE):
stream.writer.write_bytes(args[0] + '\n')
stream.writer.flush()
def reader():
for line in stream.reader.read_lines():
line = line.strip()
if line == 'quit':
MSG_QUIT.send(client_task)()
else:
MSG_LINE_READ.send(client_task)(line)
reader_task = Tasklet.new(reader)()
writer_task = Tasklet.new(writer)()
MSG_WRITE_LINE.send(writer_task)("type 'quit' to exit..")
for msg, args, kwargs in Tasklet.receive():
if msg.match(MSG_QUIT):
break
elif msg.match(MSG_LINE_READ):
#a line was recv from our client, multicast it to the other clients
for task in connected_clients:
if task != client_task: #don't echo the line back to myself
MSG_WRITE_LINE.send(task)(args[0])
elif msg.match(MSG_WRITE_LINE):
MSG_WRITE_LINE.send(writer_task)(args[0])
connected_clients.remove(client_task)
reader_task.kill()
writer_task.kill()
client_socket.close()
def __init__(self, client_stream):
self._client_stream = BufferedStream(client_stream)
self._object_reader = ObjectReader(self._client_stream.reader)
self._object_writer = ObjectWriter(self._client_stream.writer)
def testTextProtocol(self):
from concurrence.io import Socket, BufferedStream
from concurrence.memcache.protocol import MemcacheProtocol
socket = Socket.connect((MEMCACHE_IP, 11211))
stream = BufferedStream(socket)
writer = stream.writer
reader = stream.reader
try:
protocol = MemcacheProtocol.create("textblaat")
self.fail("expected error")
except MemcacheError:
pass
protocol = MemcacheProtocol.create("text")
self.assertTrue(protocol is MemcacheProtocol.create(protocol))
protocol.set_codec("raw")
protocol.write_set(writer, 'hello', 'world', 0, 0)
writer.flush()
self.assertEquals((MemcacheResult.STORED, None),
protocol.read_set(reader))
N = 100
for i in range(N):
protocol.write_set(writer, 'test%d' % i, 'hello world %d' % i, 0,
0)
writer.flush()
self.assertEquals((MemcacheResult.STORED, None),
protocol.read_set(reader))
#single get
for i in range(N):
protocol.write_get(writer, ['test%d' % i])
writer.flush()
result = protocol.read_get(reader)
self.assertEquals((MemcacheResult.OK, {
'test%d' % i: 'hello world %d' % i
}), result)
#multi get
for i in range(0, N, 10):
keys = ['test%d' % x for x in range(i, i + 10)]
protocol.write_get(writer, keys)
writer.flush()
result, values = protocol.read_get(reader)
self.assertEquals(MemcacheResult.OK, result)
self.assertEquals(10, len(values))
#multi get pipeline, e.g. write N gets, but don't read out the results yet
for i in range(0, N, 10):
keys = ['test%d' % x for x in range(i, i + 10)]
protocol.write_get(writer, keys)
writer.flush()
#now read the results
for i in range(0, N, 10):
result, values = protocol.read_get(reader)
self.assertEquals(10, len(values))
self.assertTrue(('test%d' % i) in values)
#pipelined multiget with same set of keys
protocol.write_get(writer, [
'test2', 'test8', 'test9', 'test11', 'test23', 'test24', 'test29',
'test31', 'test34'
])
writer.flush()
protocol.write_get(writer, [
'test2', 'test8', 'test9', 'test11', 'test23', 'test24', 'test29',
'test31', 'test34'
])
writer.flush()
result1 = protocol.read_get(reader)
result2 = protocol.read_get(reader)
self.assertEquals(result1, result2)
def connector():
for i in range(N):
client = Socket.connect(('localhost', 6379))
clients.append(BufferedStream(client))
print i
print 'connector done', N
def connect(self):
self._stream = BufferedStream(Socket.connect(self._address))
def __init__(self, server, client_socket):
self._server = server
self._stream = BufferedStream(client_socket)
def connect(self, endpoint):
self._stream = BufferedStream(Connector.connect(endpoint))
self._message_writer_task = Tasklet.new(self._message_writer)()
self._message_reader_task = Tasklet.new(self._message_reader)()
