def create_connection(addr, port, msg): sock = socket(AF_INET, SOCK_STREAM) con = Spin(sock) Client(con) con.connect_ex((addr, port)) xmap(con, CONNECT, setup, msg)
def create_connection(addr, port): sock = socket(AF_INET, SOCK_STREAM) spin = Spin(sock) Client(spin) xmap(spin, CONNECT, is_open, port) spin.connect_ex((addr, port)) return spin
def create_connection(addr, port): con = Spin() Client(con) xmap(con, CONNECT, on_connect, addr, port) xmap(con, CONNECT_ERR, on_connect_err, addr, port) xmap(con, CONNECT, lambda con: die()) xmap(con, CONNECT_ERR, lambda con, err: die()) con.connect_ex((addr, port))
def __init__(self, server_port, backlog, irc_address, irc_port): self.irc_address = irc_address self.irc_port = irc_port server = Spin() server.bind(('', server_port)) server.listen(int(backlog)) Server(server) xmap(server, ACCEPT, self.handle_accept)
def kpost(rsc, username, password, payload): ADDR = 'baas.kinvey.com' PORT = 80 HEADER = {'Host': '%s' % ADDR, 'Authorization': auth(username, password)} con = Spin() data = post_data(rsc, data=json.loads(payload), header=HEADER) Client(con) con.connect_ex((ADDR, PORT)) xmap(con, CONNECT, set_up_con, data) return con
def __init__(self, addr, port, user, nick, irccmd, channels=[]): con = Spin() self.con = con con.connect_ex((addr, int(port))) Client(con) xmap(con, CONNECT, self.on_connect) xmap(con, 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
def connect(rsc, username, password): ADDR = 'baas.kinvey.com' PORT = 80 HEADER = {'Host': '%s' % ADDR, 'Authorization': auth(username, password)} con = Spin() data = get(rsc, header=HEADER) Client(con) con.connect_ex((ADDR, PORT)) xmap(con, CONNECT, set_up_con, data) xmap(con, CONNECT_ERR, lambda con, err: lose(con)) return con
def connect(addr, port, rsc): HEADER = { 'Host': '%s' % addr, 'User-Agent': "uxreq/1.0", 'Accept-Charset': 'ISO-8859-1,utf-8;q=0.7,*;q=0.7', 'Connection': 'close', } con = Spin() data = get(rsc, header=HEADER) Client(con) con.connect_ex((addr, port)) xmap(con, CONNECT, set_up_con, data) xmap(con, CONNECT_ERR, lambda con, err: lose(con)) return con
def create_server(addr, port, backlog): """ Set up a TCP server and installs the basic handles Stdin, Stdout in the clients. Example: def send_data(server, client): # No need to install Stdin or Stdout. client.dump('foo bar!') server = create_server('0.0.0.0', 1024, 50) xmap(server, on_accept, send_data) """ server = Spin() server.bind((addr, port)) server.listen(backlog) Server(server) server.add_map(ACCEPT, lambda server, spin: install_basic_handles(spin)) return server
def handle_accept(self, server, client): Stdin(client) Stdout(client) Terminator(client, delim='\r\n') xmap(client, Terminator.FOUND, self.handle_found) xmap(client, CLOSE, self.down_connection) irc = Spin() Client(irc) Stdin(irc) Stdout(irc) Shrug(irc, delim='\r\n') xmap(irc, Terminator.FOUND, self.handle_found) xmap(irc, CONNECT, self.handle_connect) xmap(irc, CONNECT_ERR, self.down_connection) xmap(irc, CLOSE, self.down_connection) irc.arrow = client client.arrow = irc irc.connect_ex((self.irc_address, self.irc_port))
def create_client(addr, port): """ Set up a TCP client and installs the basic handles Stdin, Stdout. def send_data(client): client.dump('GET / HTTP/1.1\r\n') xmap(client, LOAD, iostd.put) client = create_client('www.google.com.br', 80) xmap(client, CONNECT, send_data) """ sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # First attempt to connect otherwise it leaves # an unconnected spin instance in the reactor. sock.connect_ex((addr, port)) spin = Spin(sock) Client(spin) spin.add_map(CONNECT, install_basic_handles) spin.add_map(CONNECT_ERR, lambda con, err: lose(con)) return spin
def update(self, spin): # Calls repeatedly accept to improve efficience. while True: try: sock, addr = spin.accept() # Instantiate a new Spin and spreads it. # Since it is connected is_on=True new = Spin(sock) spawn(spin, ACCEPT, new) except socket.error as excpt: # If there is no client accept throws # an exception that is spreaded too. err = excpt.args[0] if not err in ACCEPT_ERR_CODE: # It spawns ACCEPT_ERR just if the socket # it isn't a peculiar set of conditions. # As we are calling accpet inside a while # we would have continously EAGAIN, EWOULDBLOCK etc. spawn(spin, ACCEPT_ERR, err) debug() else: break
def __init__(self, spin, wrap = lambda sock: Spin(sock)): spin.add_map(READ, self.update) self.wrap = wrap
Stdin(con) Stdout(con) xmap(con, CLOSE, lambda con, err: lose(con)) xmap(con, 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 = Spin(sock) server.bind((opt.addr, opt.port)) server.listen(opt.backlog) Server(server) xmap(server, ACCEPT, setup) core.gear.mainloop()
die() if __name__ == '__main__': import sys fd = open(sys.argv[1], 'r') code = fd.read() fd.close() ADDR = 'codepad.org' PORT = 80 HEADER = { 'Host': ADDR, 'User-Agent': "uxreq/1.0", 'Accept-Charset': 'ISO-8859-1,utf-8;q=0.7,*;q=0.7', 'Connection': 'close', } PARAMS = {'code': code, 'lang': 'Plain Text', 'submit': 'Submit'} con = Spin() Client(con) con.connect_ex((ADDR, PORT)) xmap(con, CONNECT, set_up_con, post_data('/', data=PARAMS, header=HEADER)) xmap(con, CONNECT_ERR, lambda con, err: lose(con)) core.gear.mainloop()
self.send_msg(client, reduce(operator.add, args, 0)) def on_sub(self, client, args): self.send_msg(client, reduce(operator.sub, args, 0)) def on_div(self, client, args): self.send_msg(client, reduce(operator.div, args, args.pop(0))) def on_mul(self, client, args): self.send_msg(client, reduce(operator.mul, args, args.pop(0))) def on_error(self, client, excpt): self.send_msg(client, excpt) def handle_close(self, client, err): client.destroy() client.close() def send_msg(self, client, msg): client.dump('%s\r\n' % msg) if __name__ == '__main__': server = Spin() server.bind(('', 1234)) server.listen(5) Server(server) CalcServer(server) core.gear.mainloop()
# Name: foo.py # Description: This example connects to a local socket it sends # a chunk of text and disconnects. from untwisted.network import xmap, Spin, core from untwisted.utils.stdio import Client, Stdin, CONNECT, DUMPED, lose from socket import * def set_up_con(con): # We install Stdin to be able of sending data. Stdin(con) # When everything is sent it just disconnects. xmap(con, DUMPED, lose) # Stdin installs dump method in con. # So, we can use it to send data. con.dump('Hello world\r\n') sock = socket(AF_INET, SOCK_STREAM) con = Spin(sock) Client(con) con.connect_ex(('localhost', 1234)) xmap(con, CONNECT, set_up_con) core.gear.mainloop()
def connect(servaddr, port, nick, user, nick_passwd, adm_passwd, chan_list, plugmap): sock = socket(AF_INET, SOCK_STREAM) ip = gethostbyname(servaddr) server = Spin(sock) Client(server) def auto_join(server, *args): send_cmd(server, nick_passwd) for ind in chan_list: send_cmd(server, 'JOIN %s' % ind) @coroutine def get_myaddr(server, servaddr, nick, msg): server.nick = nick send_cmd(server, 'USERHOST %s' % nick) args = yield server, '302' _, _, ident = args user, myaddr = ident.split('@') server.myaddr = myaddr def update_nick(server, nick_x, user, host, nick_y): if server.nick == nick_x: server.nick = nick_y def handle_connect(server): Stdin(server) Stdout(server) Terminator(server) Irc(server) CTCP(server) Misc(server) adm.install(server) xmap( server, 'PING', lambda server, prefix, servaddr: send_cmd( server, 'PONG :%s' % servaddr)) xmap(server, CLOSE, lambda server, err: lose(server)) logcon(server) xmap(server, '376', auto_join) xmap(server, '376', get_myaddr) xmap(server, 'NICK', update_nick) plugmap(server) server.servaddr = servaddr server.port = port server.nick = nick server.user = user server.chan_list = chan_list server.nick_passwd = nick_passwd server.adm_passwd = adm_passwd server.plugmap = plugmap send_cmd(server, 'NICK %s' % nick) send_cmd(server, 'USER %s' % user) xmap(server, CONNECT, handle_connect) xmap(server, CONNECT_ERR, lambda server, err: lose(server)) server.connect_ex((ip, port)) return server