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
