def create_reader(bytes):
b = Buffer(1024)
for byte in bytes:
b.write_byte(byte)
b.flip()
p = PacketReader(b)
p.packet.position = b.position
p.packet.limit = b.limit
return p
def __init__(self):
self.state = self.STATE_INIT
self.buffer = Buffer(1024 * 16)
self.socket = None
self.reader = None
self.writer = None
self._time_command = False #whether to keep timing stats on a cmd
self._command_time = -1
self._incommand = False
self.current_resultset = None
def __init__(self, stream):
buffer_size = stream._read_buffer_size
if stream._reader is None:
if stream._reader_pool.get(buffer_size, []):
reader = stream._reader_pool[buffer_size].pop()
else:
reader = BufferedReader(None, Buffer(buffer_size))
else:
reader = stream._reader
reader.stream = stream._stream
self._reader = reader
self._stream = stream
def __init__(self, stream):
buffer_size = stream._write_buffer_size
if stream._writer is None:
if stream._writer_pool.get(buffer_size, []):
writer = stream._writer_pool[buffer_size].pop()
else:
writer = BufferedWriter(None, Buffer(buffer_size))
else:
writer = stream._writer
writer.stream = stream._stream
self._writer = writer
self._stream = stream
def testParserSpeed(self):
N = 500000
b = Buffer(1024)
b.write_bytes("GET /bla.html?piet=blaat&jaap=aap HTTP/1.1\r\n")
b.write_bytes("Content-length: 10\r\n")
b.write_bytes("\r\n")
b.flip()
with unittest.timer() as tmr:
for i in range(N):
p = _http.HTTPParser(b)
p.parse()
b.position = 0
print tmr.sec(N)
def fetch10(self, s, uri):
b = Buffer(1024)
b.clear()
b.write_bytes("GET %s HTTP/1.0\r\n" % uri)
b.write_bytes("\r\n")
b.flip()
s.write(b)
b.clear()
s.read(b)
b.flip()
return b.read_bytes(b.remaining)
def handle(client_socket):
buffer = Buffer(1024)
client_socket.read(buffer) #read the request
buffer.clear()
buffer.write_bytes(
"HTTP/1.0 200 OK\r\n" \
"Content-Length: 13\r\n" \
"Connection: close\r\n" \
"\r\n" \
"Hello World!\n"
)
buffer.flip()
client_socket.write(buffer)
client_socket.close()
def whois(self, query, hostname, flags):
"""Perform initial lookup with TLD whois server
then, if the quick flag is false, search that result
for the region-specifc whois server and do a lookup
there for contact details
"""
response = ''
engine = QueryEngine()
result = engine.asynchronous(hostname, adns.rr.ADDR)
if len(result[3]):
ips = [rr[1] for rr in result[3]]
ip = random.choice(ips)
try:
s = Socket.connect((ip, 43))
writer = BufferedWriter(s, Buffer(1024))
reader = BufferedReader(s, Buffer(1024))
if (hostname == NICClient.GERMNICHOST):
writer.write_bytes("-T dn,ace -C US-ASCII " + query + "\r\n")
else:
writer.write_bytes(query + "\r\n")
writer.flush()
while True:
try:
d = reader.read_bytes_available()
except EOFError:
break
response += d
if not d:
break
except IOError:
pass
nhost = None
if (flags & NICClient.WHOIS_RECURSE and nhost == None):
nhost = self.findwhois_server(response, hostname)
if (nhost != None):
response += self.whois(query, nhost, 0)
return response
def testParser(self):
b = Buffer(1024)
b.write_bytes(
"POST /bla.html?piet=blaat&jaap=aap#blaataap HTTP/1.1\r\n")
b.write_bytes("Content-length: 10\r\n")
b.write_bytes("Another-header: blaat: piet\r\n")
b.write_bytes("Another-header: blaat: piet\r\n")
b.write_bytes("Content-type: blaat/piet\r\n")
b.write_bytes("\r\n")
b.write_bytes("1234567890")
b.flip()
print b.limit, b.position
p = _http.HTTPParser(b)
print repr(p.environ)
print 'isfin', repr(p.is_finished())
print p.parse()
print 'isfin', repr(p.is_finished())
print b.limit, b.position
print repr(p.environ)
print p.parse()
def writer(self):
if self._writer is None:
self._writer = BufferedWriter(self._stream, Buffer(self._write_buffer_size))
return self._writer
def reader(self):
if self._reader is None:
self._reader = BufferedReader(self._stream, Buffer(self._read_buffer_size))
return self._reader
fd = s.fileno()
#we are connected, turn to non-blockig mode
s.setblocking(0)
#print s.fileno()
STATE_WRITE_SET_REQUEST = 0
STATE_READ_SET_RESPONSE = 1
STATE_WAIT_SET_RESPONSE = 2
state = STATE_WRITE_SET_REQUEST
N = 100000
#N = 1000
n = 0
buff = Buffer(1024)
def callback(flags):
#print 'cb', flags
if flags & event.EV_TIMEOUT:
raise Exception("Timeout")
global state
global n
while True:
if state == STATE_WRITE_SET_REQUEST:
buff.clear()
key = 'piet%d' % n
value = 'klaas%d' % n
buff.write_bytes("%s %s %d 0 %d\r\n%s\r\n" %
('set', key, 0, len(value), value))
def __init__(self, stream, buffer_size = 1024 * 8, read_buffer_size = 0, write_buffer_size = 0):
self.stream = stream
self.reader = BufferedReader(stream, Buffer(read_buffer_size or buffer_size))
self.writer = BufferedWriter(stream, Buffer(write_buffer_size or buffer_size))
