def handle_write(self):
if not self._out_queue:
logging.error("handle_write called with empty output queue")
return
(ip, port, payload) = self._out_queue[0]
utils.IgnoreSignals(self.socket.sendto, payload, 0, (ip, port))
self._out_queue.pop(0)
def testIgnoreSignals(self):
sock_err_intr = socket.error(errno.EINTR, "Message")
sock_err_inval = socket.error(errno.EINVAL, "Message")
env_err_intr = EnvironmentError(errno.EINTR, "Message")
env_err_inval = EnvironmentError(errno.EINVAL, "Message")
self.assertRaises(socket.error, self._Raise, sock_err_intr)
self.assertRaises(socket.error, self._Raise, sock_err_inval)
self.assertRaises(EnvironmentError, self._Raise, env_err_intr)
self.assertRaises(EnvironmentError, self._Raise, env_err_inval)
self.assertEquals(utils.IgnoreSignals(self._Raise, sock_err_intr), None)
self.assertEquals(utils.IgnoreSignals(self._Raise, env_err_intr), None)
self.assertRaises(socket.error, utils.IgnoreSignals, self._Raise,
sock_err_inval)
self.assertRaises(EnvironmentError, utils.IgnoreSignals, self._Raise,
env_err_inval)
self.assertEquals(utils.IgnoreSignals(self._Return, True), True)
self.assertEquals(utils.IgnoreSignals(self._Return, 33), 33)
def handle_read(self):
recv_result = utils.IgnoreSignals(self.socket.recvfrom,
constants.MAX_UDP_DATA_SIZE)
if recv_result is not None:
payload, address = recv_result
if self._family == socket.AF_INET6:
# we ignore 'flow info' and 'scope id' as we don't need them
ip, port, _, _ = address
else:
ip, port = address
self.handle_datagram(payload, ip, port)
def handle_accept(self):
"""Accept a new client connection.
Creates a new instance of the handler class, which will use asyncore to
serve the client.
"""
accept_result = utils.IgnoreSignals(self.accept)
if accept_result is not None:
connected_socket, client_address = accept_result
if self.family == socket.AF_UNIX:
# override the client address, as for unix sockets nothing meaningful
# is passed in from accept anyway
client_address = netutils.GetSocketCredentials(
connected_socket)
logging.info(
"Accepted connection from %s",
netutils.FormatAddress(client_address, family=self.family))
self.handle_connection(connected_socket, client_address)
def handle_read(self):
utils.IgnoreSignals(self.recv, 4096)
if self.signal_fn:
self.signal_fn()
self.need_signal = True
