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()