class DccServer(Dispatcher):
"""
This class is used to send files. It is called DccServer cause the one sending
a file is the one who sets up a server.
"""
def __init__(self, fd, port, timeout=20):
"""
fd -> The file to be sent.
port -> The port which will be used.
timeout -> How long the server must be up.
"""
sock = socket(AF_INET, SOCK_STREAM)
sock.bind(('', port))
sock.listen(1)
self.local = SuperSocket(sock)
Server(self.local)
Dispatcher.__init__(self)
self.fd = fd
self.timeout = timeout
self.port = port
self.local.add_map(ACCEPT, self.on_accept)
self.timer = Timer(self.timeout, self.on_timeout)
def on_timeout(self):
self.drive(TIMEOUT)
lose(self.local)
def on_accept(self, local, ssock):
"""
"""
SockReader(ssock)
SockWriter(ssock)
Fixed(ssock)
ssock.dumpfile(self.fd)
ssock.add_map(CLOSE, lambda con, err: lose(con))
ssock.add_map(Fixed.FOUND, self.on_ack)
ssock.add_handle(
lambda ssock, event, args: self.drive(event, ssock, *args))
self.timer.cancel()
def on_ack(self, ssock, ack):
"""
"""
pos = unpack("!I", ack)[0]
if pos >= self.fd.tell():
self.run_done(ssock)
def run_done(self, ssock):
lose(ssock)
lose(self.local)
ssock.drive(DONE)
def setUp(self):
self.server = create_server('0.0.0.0', 1235, 5)
self.client = SuperSocket()
self.client.connect_ex(('0.0.0.0', 1235))
Client(self.client)
self.client.add_map(CONNECT, self.handle_connect)
self.server.add_map(ACCEPT, self.handle_accept)
def __init__(self, ip, port, nick, user, password, *chan_list):
""" It sets up the bot instance. """
sock = socket(AF_INET, SOCK_STREAM)
# We have to wrap our socket with a SuperSocket instance
# in order to have our events issued when data comes
# from the socket.
con = SuperSocket(sock)
# This protocol is required by uxirc.irc protocol.
# It spawns CONNECT.
Client(con)
# We use connect_ex since we do not want an exception.
# Untwisted uses non blocking sockets.
con.connect_ex((ip, port))
# We save whatever we might need.
self.nick = nick
self.user = user
self.password = password
self.chan_list = chan_list
self.ip = ip
self.port = port
# It maps CONNECT to self.send_auth so
# when our socket connects it sends NICK and USER info.
con.add_map(CONNECT, self.send_auth)
con.add_map(CONNECT_ERR, lambda con, err: lose(con))
def create_server(addr, port, backlog):
"""
"""
server = SuperSocket()
server.bind((addr, port))
server.listen(backlog)
Server(server)
server.add_map(ACCEPT, handles_wrapper)
return server
def __init__(self, server_port, backlog, irc_address, irc_port):
self.irc_address = irc_address
self.irc_port = irc_port
server = SuperSocket()
server.bind(('', server_port))
server.listen(int(backlog))
Server(server)
server.add_map(ACCEPT, self.handle_accept)
def __init__(self, host, port, fd, size):
"""
"""
Dispatcher.__init__(self)
sock = socket(AF_INET, SOCK_STREAM)
ssock = SuperSocket(sock)
self.port = port
self.fd = fd
self.size = size
Client(ssock)
ssock.connect_ex((host, port))
ssock.add_map(CONNECT, self.on_connect)
ssock.add_map(CONNECT_ERR, lambda con, err: lose(con))
ssock.add_handle(
lambda ssock, event, args: self.drive(event, ssock, *args))
def update(self, ssock):
while True:
try:
sock, addr = ssock.accept()
except socket.error as excpt:
if not excpt.args[0] in ACCEPT_ERR_CODE:
ssock.drive(CLOSE, excpt)
break
else:
ssock.drive(ACCEPT, SuperSocket(sock))
def __init__(self, fd, port, timeout=20):
"""
fd -> The file to be sent.
port -> The port which will be used.
timeout -> How long the server must be up.
"""
sock = socket(AF_INET, SOCK_STREAM)
sock.bind(('', port))
sock.listen(1)
self.local = SuperSocket(sock)
Server(self.local)
Dispatcher.__init__(self)
self.fd = fd
self.timeout = timeout
self.port = port
self.local.add_map(ACCEPT, self.on_accept)
self.timer = Timer(self.timeout, self.on_timeout)
class TestLose(unittest.TestCase):
def setUp(self):
self.server = create_server('0.0.0.0', 1235, 5)
self.client = SuperSocket()
self.client.connect_ex(('0.0.0.0', 1235))
Client(self.client)
self.client.add_map(CONNECT, self.handle_connect)
self.server.add_map(ACCEPT, self.handle_accept)
def handle_accept(self, server, ssock):
self.ssock = ssock
self.ssock.add_map(CLOSE, lambda ssock, err: die())
def handle_connect(self, client):
lose(client)
lose(self.server)
def test_accept(self):
core.gear.mainloop()
def main():
sock = socket(AF_INET, SOCK_STREAM)
con = SuperSocket(sock)
Client(con)
con.connect_ex((ADDRESS, PORT))
con.add_map(CONNECT, setup)
def create_connection(addr, port, msg):
sock = socket(AF_INET, SOCK_STREAM)
con = SuperSocket(sock)
Client(con)
con.connect_ex((addr, port))
con.add_map(CONNECT, setup, msg)
def main(address, port, nick, user, cmd, delay=1):
sock = socket(AF_INET, SOCK_STREAM)
con = SuperSocket(sock)
Client(con)
con.connect_ex((address, port))
con.add_map(CONNECT, send_auth, nick, user, cmd, delay)
return con
def __init__(self):
server = socket(AF_INET, SOCK_STREAM)
server.bind(('127.0.0.1', 0))
server.listen(1)
client = SuperSocket()
client.connect_ex(server.getsockname())
def consume(ssock):
ssock.recv(self.MAX_SIZE)
client.add_map(READ, consume)
self.con, addr = server.accept()
self.lock = Lock()
def __init__(self,
addr,
port,
user,
nick,
irccmd,
channels=[],
encoding='utf8'):
con = SuperSocket()
self.con = con
con.connect_ex((addr, int(port)))
Client(con)
con.add_map(CONNECT, self.on_connect)
con.add_map(CONNECT_ERR, self.e_connect_err)
self.misc = None
self.addr = addr
self.port = port
self.user = user
self.nick = nick
self.irccmd = irccmd
self.channels = channels
self.encoding = encoding
def create_client(addr, port):
"""
Shorthand function to create a client connection. It installs
automatically all extensions to send and receive data.
It also deals with CLOSE event properly.
"""
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# First attempt to connect otherwise it leaves
# an unconnected ssock instance in the reactor.
sock.connect_ex((addr, port))
ssock = SuperSocket(sock)
Client(ssock)
ssock.add_map(CONNECT, install_basic_handles)
ssock.add_map(CONNECT_ERR, handle_conerr)
return ssock
def handle_accept(self, server, client):
irc = SuperSocket()
Client(irc)
irc.add_map(CONNECT, self.handle_connect, client)
irc.connect_ex((self.irc_address, self.irc_port))
def create_connection(addr, port):
con = SuperSocket()
Client(con)
con.add_map(CONNECT, on_connect, addr, port)
con.add_map(CONNECT_ERR, on_connect_err, addr, port)
con.add_map(CONNECT, lambda con: die())
con.add_map(CONNECT_ERR, lambda con, err: die())
con.connect_ex((addr, port))
# It imports basic objects.
from untwisted.network import SuperSocket
from untwisted.server import Server, ACCEPT
from untwisted.client import lose, CLOSE
from untwisted.sock_writer import SockWriter
from untwisted.sock_reader import SockReader
from untwisted import core
from time import asctime
class TimeServ:
def __init__(self, server):
server.add_map(ACCEPT, self.handle_accept)
def handle_accept(self, server, con):
SockWriter(con)
SockReader(con)
con.dump(('%s\r\n' % asctime()).encode('utf-8'))
con.add_map(CLOSE, lambda con, err: lose(con))
if __name__ == '__main__':
server = SuperSocket()
server.bind(('', 1234))
server.listen(200)
Server(server)
TimeServ(server)
core.gear.mainloop()
def create_connection(addr, port):
ssock = SuperSocket()
Client(ssock)
ssock.add_map(CONNECT, is_open, port)
ssock.connect_ex((addr, port))
return ssock
SockReader(con)
SockWriter(con)
con.add_map(CLOSE, lambda con, err: lose(con))
con.add_map(LOAD, lambda con, data: sys.stdout.write('%s\r\n' % data))
if __name__ == '__main__':
from optparse import OptionParser
parser = OptionParser()
parser.add_option("-a",
"--addr",
dest="addr",
metavar="string",
default='0.0.0.0')
parser.add_option("-p", "--port", dest="port", type="int", default=1234)
parser.add_option("-b", "--backlog", dest="backlog", type="int", default=5)
(opt, args) = parser.parse_args()
sock = socket(AF_INET, SOCK_STREAM)
server = SuperSocket(sock)
server.bind((opt.addr, opt.port))
server.listen(opt.backlog)
Server(server)
server.add_map(ACCEPT, setup)
core.gear.mainloop()
from untwisted.network import SuperSocket
# Builtin handle/extension to spawn CONNECT, CONNECT_ERR events.
from untwisted.client import Client
# Builtin events.
from untwisted.event import CONNECT, CONNECT_ERR
from untwisted import core
def handle_connect(ssock):
print('Connected !')
def handle_connect_err(ssock, err):
print('Not connected:', err)
ssock = SuperSocket()
Client(ssock)
ssock.connect_ex(('httpbin.org', 80))
# Map handles to the events from Client handle.
ssock.add_map(CONNECT, handle_connect)
ssock.add_map(CONNECT_ERR, handle_connect_err)
# Start reactor to scale socket READ/WRITE events asynchronously.
core.gear.mainloop()
