def update(self, spin):
try:
# If self.data is '' we read from the file.
if not self.data:
self.data = self.fd.read(self.BLOCK)
# If self.data is '' then we are done.
if not self.data:
# Spreads DUMPED_FILE so clients of this protocol
# can know when their files were sent.
zmap(spin, WRITE, self.update)
spawn(spin, DUMPED_FILE)
# We no more need to write.
# We are done.
return
size = spin.send(self.data)
# We use buffer to send faster.
self.data = buffer(self.data, size)
# If it arose error when sending we deal with it.
except socket.error as excpt:
err = excpt.args[0]
if err in CLOSE_ERR_CODE:
spawn(spin, CLOSE)
else:
spawn(spin, SEND_ERR, excpt)
except IOError as excpt:
err = excpt.args[0]
spawn(spin, READ_ERR, err)
def update(self, spin):
try:
# If self.data is '' we read from the file.
if not self.data:
self.data = self.fd.read(self.BLOCK)
# If self.data is '' then we are done.
if not self.data:
# Spreads DUMPED_FILE so clients of this protocol
# can know when their files were sent.
zmap(spin, WRITE, self.update)
spawn(spin, DUMPED_FILE)
# We no more need to write.
# We are done.
return
size = spin.send(self.data)
# We use buffer to send faster.
self.data = buffer(self.data, size)
# If it arose error when sending we deal with it.
except socket.error as excpt:
err = excpt.args[0]
if err in CLOSE_ERR_CODE:
spawn(spin, CLOSE)
else:
spawn(spin, SEND_ERR, excpt)
except IOError as excpt:
err = excpt.args[0]
spawn(spin, READ_ERR, err)
def check_data_size(self):
"""
"""
if not len(self.data) >= self.size:
return
zmap(self.spin, LOAD, self.get_data)
self.spawn_response()
def check_data_size(self):
"""
"""
if not len(self.data) >= self.size:
return
zmap(self.spin, LOAD, self.get_data)
self.spawn_response()
def update(self, spin):
# All linked to CONNECT is called.
err = spin.getsockopt(socket.SOL_SOCKET, socket.SO_ERROR)
# If the err is non zero the socket is in error.
if err != 0:
spawn(spin, CONNECT_ERR, err)
else:
spawn(spin, CONNECT)
# As we can connect just once, it unlinks self.update from
# WRITE.
zmap(spin, WRITE, self.update)
def update(self, spin):
# All linked to CONNECT is called.
err = spin.getsockopt(socket.SOL_SOCKET, socket.SO_ERROR)
# If the err is non zero the socket is in error.
if err != 0:
spawn(spin, CONNECT_ERR, err)
else:
spawn(spin, CONNECT)
# As we can connect just once, it unlinks self.update from
# WRITE.
zmap(spin, WRITE, self.update)
def get_header(self, spin, data):
"""
"""
DELIM = '\r\n\r\n'
self.header = self.header + data
if not DELIM in data:
return
self.header, self.data = self.header.split(DELIM, 1)
self.response, self.header = self.split_header(self.header)
zmap(spin, LOAD, self.get_header)
xmap(spin, LOAD, self.get_data)
def update(self, device):
try:
data = self.queue.popleft()
# As device.write returns None
# we don't need to worry whether it has sent all the bytes
# unlike with sockets.
device.write(data)
except IndexError:
# When the queue is empty then we don't need
# the WRITE event.
zmap(device, WRITE, self.update)
spawn(device, DUMPED)
except IOError as excpt:
# If something went wrong it spawns CLOSE with err.
# The err parameter gives a clue of what happened.
err = excpt.args[0]
spawn(device, CLOSE, err)
def update(self, device):
try:
data = self.queue.popleft()
device.write(data)
except IOError as excpt:
err = excpt.args[0]
spawn(device, CLOSE, err)
debug()
except IndexError:
# If the queue is empty we no more need
# the WRITE event.
zmap(device, WRITE, self.update)
# It is important to know when all data was
# fully sent. It spawns DUMPED when the queue
# is empty.
spawn(device, DUMPED)
def update(self, spin):
"""
This method is called on WRITE to send data.
It attempts to optmize the job of sending bytes by using
buffer.
The algorithm is explained in the class doc.
Events: DUMPED, CLOSE, SEND_ERR
See help(Stdin).
"""
try:
if not self.data:
self.data = self.queue.popleft()
# As we are in non blocking mode a call to send
# doesn't block. We just need to know the amount
# of bytes sent.
size = spin.send(self.data)
# We move the pointer size bytes ahead.
self.data = buffer(self.data, size)
except socket.error as excpt:
err = excpt.args[0]
# The err value contains the socket status error code.
# It is passed with either CLOSE or SEND_ERR so
# users of this protocol can know what happened
# exactly with the call to send.
if err in CLOSE_ERR_CODE:
spawn(spin, CLOSE, err)
else:
spawn(spin, SEND_ERR, err)
debug()
except IndexError:
# If the queue is empty we no more need
# the WRITE event.
zmap(spin, WRITE, self.update)
# It is important to know when all data was
# fully sent. It spawns DUMPED when the queue
# is empty.
spawn(spin, DUMPED)
def update(self, device):
try:
data = self.queue.popleft()
device.write(data)
except IOError as excpt:
err = excpt.args[0]
spawn(device, CLOSE, err)
debug()
except IndexError:
# If the queue is empty we no more need
# the WRITE event.
zmap(device, WRITE, self.update)
# It is important to know when all data was
# fully sent. It spawns DUMPED when the queue
# is empty.
spawn(device, DUMPED)
def update(self, spin):
"""
This method is called on WRITE to send data.
It attempts to optmize the job of sending bytes by using
buffer.
The algorithm is explained in the class doc.
Events: DUMPED, CLOSE, SEND_ERR
See help(Stdin).
"""
try:
if not self.data:
self.data = self.queue.popleft()
# As we are in non blocking mode a call to send
# doesn't block. We just need to know the amount
# of bytes sent.
size = spin.send(self.data)
# We move the pointer size bytes ahead.
self.data = buffer(self.data, size)
except socket.error as excpt:
err = excpt.args[0]
# The err value contains the socket status error code.
# It is passed with either CLOSE or SEND_ERR so
# users of this protocol can know what happened
# exactly with the call to send.
if err in CLOSE_ERR_CODE:
spawn(spin, CLOSE, err)
else:
spawn(spin, SEND_ERR, err)
debug()
except IndexError:
# If the queue is empty we no more need
# the WRITE event.
zmap(spin, WRITE, self.update)
# It is important to know when all data was
# fully sent. It spawns DUMPED when the queue
# is empty.
spawn(spin, DUMPED)
def update(self, device):
try:
data = self.queue.popleft()
# As device.write returns None
# we don't need to worry whether it has sent all the bytes
# unlike with sockets.
device.write(data)
except IndexError:
# When the queue is empty then we don't need
# the WRITE event.
zmap(device, WRITE, self.update)
spawn(device, DUMPED)
except IOError as excpt:
# If something went wrong it spawns CLOSE with err.
# The err parameter gives a clue of what happened.
err = excpt.args[0]
spawn(device, CLOSE, err)
def unset(con, *args):
for key, value in events:
zmap(irc.con, key, value)
def rm(server, nick, user, host, target,
msg, lang_x, lang_y, ident):
zmap(server, ident, listen, lang_x, lang_y)
def rm(server, nick, user, host, target, msg, lang_x, lang_y, ident):
zmap(server, ident, listen, lang_x, lang_y)
