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 handle_connect(server):
Stdin(server)
Stdout(server)
Shrug(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)
def set_up_con(con, data):
Stdin(con)
Stdout(con)
HttpClient(con)
xmap(con, CLOSE, lambda con, err: lose(con))
con.dump(data)
def __init__(self, server):
fd = open(join(dirname(__file__), 'quote_database'), 'r')
data = fd.read()
fd.close()
self.data = split('\n+', data)
xmap(server, 'CMSG', self.send_quote)
def dump(self, data):
# If the queue is empty we map it to WRITE
# otherwise it is already mapped.
if not self.queue:
xmap(self.device, WRITE, self.update)
# Addes it to be sent.
self.queue.append(data)
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 __init__(self, area, addr, port):
con = Spin()
con.connect_ex((addr, int(port)))
Client(con)
xmap(con, CONNECT, lambda con: self.set_up_con(con, area))
xmap(con, CONNECT_ERR, self.on_connect_err)
def dump(self, data):
"""
It sends data asynchronously through the device.
"""
self.queue.append(data)
xmap(self.device, WRITE, self.update)
def scan(addr, min, max):
task = Task()
for ind in range(min, max):
task.add(create_connection(addr, ind), CONNECT, CONNECT_ERR)
task.start()
xmap(task, DONE, lambda task: die())
def handle_accept(self, server, client):
irc = Spin()
Client(irc)
xmap(irc, CONNECT, self.handle_connect, client)
xmap(irc, CONNECT_ERR, self.down_connection)
irc.connect_ex((self.irc_address, self.irc_port))
def __init__(self, spin):
self.request = None
xmap(spin, TransferHandle.DONE, self.process)
# It will not be spawned if it is a websocket connection.
xmap(spin, TmpFile.DONE,
lambda spin, fd, data: spawn(spin,
RequestHandle.DONE, self.request))
def __init__(self, spin):
"""
It installs self.update on WRITE. A call a select with this socket
in the writting list of sockets would succed if the socket is connected.
"""
xmap(spin, WRITE, self.update)
def dump(self, data):
# If the queue is empty we maps it WRITE
# otherwise it is already mapped.
if not self.queue:
xmap(self.spin, WRITE, self.update)
# Addes it to be sent.
self.queue.append(buffer(data))
def __init__(self, spin):
"""
It maps READ to self.update so whenever
there is data available we can read from the socket.
"""
# Maps READ to self.update.
xmap(spin, READ, self.update)
def set_up_con(self, con, area):
Stdin(con)
Stdout(con)
Shrug(con)
Irc(con)
xmap(con, CLOSE, lambda con, err: lose(con))
self.set_common_irc_handles(area, con)
self.set_common_irc_commands(area, con)
def set_up_con(con, data):
Stdin(con)
Stdout(con)
HttpClient(con)
xmap(con, HTTP_RESPONSE, handle_http_response)
xmap(con, CLOSE, lambda con, err: lose(con))
con.dump(data)
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')
def __init__(self, spin, fd):
self.fd = fd
self.data = ''
self.BLOCK = 1024 * 124
# It maps WRITE to self.update.
# Whenever WRITE occurs self.update runs.
# Install dump method into spin.
xmap(spin, WRITE, self.update)
def __init__(self, server, db=['Ameliabot rocks'], excpt=['#freenode']):
"""
"""
self.pmed = list()
xmap(server, 'CMSG', self.send_spam)
# The list of chans whose users shouldnt be spammed.
self.db = db
self.excpt = excpt
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 record(self, con, header, fd, data, version):
REQUEST = '/appdata/%s/%s' % (data['appkey'][0], data['collection'][0])
kcon = kpost(REQUEST, data['username'][0], data['password'][0], data['json'][0])
def kresponse(kcon, version, code, reason, header, data):
response = Response()
response.set_response('HTTP/1.1 200 OK')
response.add_data(data)
send_response(con, response)
xmap(kcon, HTTP_RESPONSE, kresponse)
con.ACTIVE = True
def __init__(self, spin):
"""
"""
xmap(spin, LOAD, self.get_header)
self.spin = spin
self.header = ''
self.data = ''
self.response = ''
self.size = 0
def __init__(self, server, questions, suggestions, pmed_file='pmed',
blacklist_file='blacklist', timeout=60 * 3):
self.questions = self.load(questions)
self.suggestions = self.load(suggestions)
self.timeout = timeout
self.pmed = self.load(pmed_file)
self.pmed_file = pmed_file
self.blacklist = self.load(blacklist_file)
self.blacklist_file = blacklist_file
xmap(server, 'JOIN', self.send_question)
xmap(server, 'PMSG', self.check_answer)
def __init__(self, server, folder):
"""
The folder is where to save the logs.
Example:
LogMsg(server, '/home/tau')
Notice it shouldn't be '/home/tau/'.
"""
self.folder = folder
xmap(server, 'CMSG', self.store_chan)
xmap(server, 'PMSG', self.store_user)
def __init__(self, server, n_lines, n_secs, cmd):
"""
The n_lines means the number of lines per n_secs.
Example for command:
cmd = 'kick {chan} {nick} :Amelia rocks!'
cmd = 'chanserv akick {chan} add *!*@{host} : get out!
"""
xmap(server, 'CMSG', self.watcher)
self.data = {}
self.n_lines = n_lines
self.n_secs = n_secs
self.cmd = cmd
def check_data_existence(self):
"""
"""
try:
self.size = int(self.header['Content-Length'])
except KeyError:
pass
# Assume there is a body size larger than 0.
# Since we will call check_data_size anyway.
xmap(self.spin, LOAD, self.get_data)
self.check_data_size()
def handle_accept(self, local, spin):
Stdin(spin)
Stdout(spin)
AccUntil(spin)
TransferHandle(spin)
RequestHandle(spin)
MethodHandle(spin)
# must be improved.
Locate(spin)
# InvalidRequest(client)
xmap(spin, CLOSE, lambda con, err: lose(con))
def __init__(self, spin):
"""
"""
xmap(spin, LOAD, self.get_header)
xmap(spin, CLOSE, self.spawn_response)
self.spin = spin
self.header = ''
self.data = ''
self.response = ''
self.size = None
def get_header(self, spin, data):
"""
"""
DELIM = '\r\n\r\n'
self.header = self.header + data
if not DELIM in data:
return
self.header, self.data = self.header.split(DELIM, 1)
self.response, self.header = self.split_header(self.header)
zmap(spin, LOAD, self.get_header)
xmap(spin, LOAD, self.get_data)
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, irc, area, chan):
self.irc = irc
self.area = area
self.chan = chan
self.peers = set()
events = (('PRIVMSG->%s' % chan , self.e_privmsg),
('332->%s' % chan, self.e_332),
('PART->%s' % chan, self.e_part),
('JOIN->%s' % chan, self.e_join),
# ('*NICK', self.e_nick),
('NICK', self.e_nick),
('QUIT', self.e_quit),
('353->%s' % chan, self.e_353),
('KICK->%s' % chan, self.e_kick),
('MODE->%s' % chan, self.e_mode),
(CLOSE, self.e_close))
def unset(con, *args):
for key, value in events:
zmap(irc.con, key, value)
for key, value in events:
xmap(irc.con, key, value)
once(irc.con, '*PART->%s' % chan, unset)
xmap(irc.con, '*KICK->%s' % chan, unset)
area.bind('<Destroy>', lambda event:
unset(irc.con), add=True)
# When area is destroyed, it sends a PART.
area.bind('<Destroy>', lambda event:
send_cmd(irc.con, 'PART %s' % chan), add=True)
# Hook to send msgs.
area.hook('vyirc', 'IRC', '<Key-i>', lambda event: Get(
events={'<Escape>': lambda wid: True,
'<Return>': lambda wid:
self.irc.drop_msg(area, wid, chan)}))
# It unbinds the above callback.
# In case the part command as sent by text
# by the user. After part it should destroy the
# area.
once(irc.con, '*PART->%s' % chan, lambda con, *args:
area.unbind('<Destroy>'))
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 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 connect(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)
xmap(con, CONNECT_ERR, lambda con, err: lose(con))
return con
def locate(self, spin, request):
path = join(spin.app.app_dir, spin.app.static_dir,
basename(request.path))
if not isfile(path):
return
# Where we are going to serve files.
# I might spawn an event like FILE_NOT_FOUND.
# So, users could use it to send appropriate answers.
type_file, encoding = guess_type(path)
default_type = 'application/octet-stream'
spin.add_header(
('Content-Type', type_file if type_file else default_type),
('Content-Length', getsize(path)))
spin.send_headers()
xmap(spin, OPEN_FILE_ERR, lambda con, err: lose(con))
drop(spin, path)
def __init__(self):
# I have to improve this code.
# i have to handle the exception
# if the port is in use etc.
Spin.__init__(self)
server = socket(AF_INET, SOCK_STREAM)
server.bind(('127.0.0.1', 0))
server.listen(1)
self.connect_ex(server.getsockname())
sock, addr = server.accept()
self.sock = sock
server.close()
xmap(self, READ, self.dispatch)
self.lock = Lock()
self.ident = None
self.data = None
def install_events(self):
"""
"""
# When one of the AreaVi instances are destroyed then
# the process is killed.
self.output.hook('shell', -1, '<Destroy>',
lambda event: self.terminate_process())
self.area.hook('shell', -1, '<Destroy>',
lambda event: self.terminate_process())
# self.output.hook('shell', 'NORMAL', '<Control-F2>', lambda event:
# self.map_process_input())
self.map_process_input()
# When call.terminnate is called it may happen of having still data to be
# processed. It would attempt to write on an AreaVi instance that no more exist.
# So, it executes quietly the AreaVi.append method.
xmap(self.expect, LOAD,
lambda expect, data: exec_quiet(self.output.append, data))
xmap(self.expect, CLOSE, self.handle_close)
def __init__(self,
addr,
port,
user,
nick,
irccmd,
channels=[],
encoding='utf8'):
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
self.encoding = encoding
class Get(object):
def __init__(self, server, folder):
self.folder = folder
xmap(server, 'DCC SEND', self.dcc_get)
def dcc_get(self, server, (nick, user, host,
target, msg), filename, address, port, size):
path = join(self.folder, filename)
if isfile(path):
send_msg(server, nick, 'File already exists.')
else:
fd = open(path, 'wb')
dccclient = DccClient(long_to_ip(int(address)),
int(port), fd, int(size))
def is_done(dcclient, msg):
send_msg(server, nick, msg)
fd.close()
xmap(dccclient, DONE, is_done, 'Done.')
xmap(dccclient, CLOSE, lambda dccclient, spin, err: is_done(spin, 'Failed.'))
xmap(dccclient, CONNECT_ERR, lambda dccclient, spin, err: is_done("It couldn't connect."))
def main(addr, port, host):
sock = socket(AF_INET, SOCK_STREAM)
context = ssl.create_default_context()
con = SSL(
context.wrap_socket(sock,
do_handshake_on_connect=False,
server_hostname=host))
con.connect_ex((addr, port))
ClientSSL(con)
xmap(con, SSL_CONNECT, on_connect, host)
xmap(con, SSL_CONNECT_ERR, lambda con, err: die(err))
xmap(con, SSL_CERTIFICATE_ERR, lambda con, err: die(err))
def __init__(self, spin):
self.timer = Timer(PersistentConnection.TIMEOUT, lambda: lose(spin))
self.count = 0
xmap(spin, TmpFile.DONE, self.process)
xmap(spin, DUMPED, self.install_timeout)
xmap(spin, TransferHandle.DONE,
lambda spin, request, data: self.timer.cancel())
spin.add_header(('connection', 'keep-alive'))
spin.add_header(
('keep-alive', 'timeout=%s, max=%s' %
(PersistentConnection.TIMEOUT, PersistentConnection.MAX)))
def start(self):
self.child = Popen(self.cmd,
shell=0,
stdout=PIPE,
stdin=PIPE,
preexec_fn=setsid,
stderr=STDOUT,
env=environ)
self.stdout = Device(self.child.stdout)
self.stdin = Device(self.child.stdin)
Stdout(self.stdout)
Stdin(self.stdin)
xmap(self.stdout, LOAD, lambda con, data: sys.stdout.write(data))
xmap(self.stdin, CLOSE, lambda dev, err: lose(dev))
xmap(self.stdout, CLOSE, lambda dev, err: lose(dev))
def start(self):
print('Ibash - Bash process started...')
self.child = Popen(self.cmd,
shell=0,
stdout=PIPE,
stdin=PIPE,
preexec_fn=setsid,
stderr=STDOUT,
env=environ)
self.stdout = Device(self.child.stdout)
self.stdin = Device(self.child.stdin)
Stdout(self.stdout)
Stdin(self.stdin)
xmap(self.stdout, LOAD,
lambda con, data: sys.stdout.write(data.decode('utf8')))
xmap(self.stdin, CLOSE, lambda dev, err: lose(dev))
xmap(self.stdout, CLOSE, lambda dev, err: lose(dev))
def __init__(self, server):
self.database = dict()
xmap(server, 'CMSG', self.record)
xmap(server, 'CMSG', self.check)
def install(server):
xmap(server, 'JOIN', send_welcome)
def __init__(self, spin):
xmap(spin, HTTP_RESPONSE, self.spawn_method)
# 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 __init__(self, spin):
xmap(spin, FOUND, self.split)
def __init__(self, server, folder):
self.folder = folder
xmap(server, 'DCC SEND', self.dcc_get)
def __init__(self, server):
self.title = Title()
xmap(server, 'CMSG', self.check)
def __init__(self, server, folder):
"""
"""
self.folder = folder
xmap(server, 'CMSG', self.list_folder)
def __init__(self,server): xmap(server,'CMSG',self.getinfo)
def __init__(self, spin, regstr, event, encoding='utf8'):
self.encoding = encoding
self.regstr = regstr
self.event = event
xmap(spin, Terminator.FOUND, self.handle_found)
def install(server):
xmap(server, 'PMSG', login)
def __init__(self, spin):
xmap(spin, 'which is your nick?', self.get_nick)
def __init__(self, spin):
xmap(spin, LOAD, self.update)
spin.accumulator = self
self.data = ''
def on_connect(self, con):
area = self.create_area(self.addr)
area.bind('<Destroy>',
lambda event: send_cmd(con, 'QUIT :vy rules!'),
add=True)
Stdin(con)
Stdout(con)
Terminator(con)
Irc(con)
self.misc = Misc(con)
xmap(con, CLOSE, lambda con, err: lose(con))
xmap(con, '*JOIN', self.create_channel)
xmap(
con, Terminator.FOUND,
lambda con, data: area.append('%s\n' % data.decode(self.encoding)))
xmap(con, 'PMSG', self.e_pmsg)
xmap(con, '376', lambda con, *args: send_cmd(con, self.irccmd))
xmap(con, '376', self.auto_join)
xmap(
con, 'PING',
lambda con, prefix, servaddr: send_cmd(con, 'PONG :%s' % servaddr))
send_cmd(con, 'NICK %s' % self.nick)
send_cmd(con, 'USER %s' % self.user)
def install(server):
xmap(server, CLOSE, reconnect)
def install(server):
xmap(server, 'CMSG', send_spam)
from untwisted.expect import Expect, LOAD, CLOSE
from untwisted.network import core, xmap, die
def handle(expect, data):
print data
expect = Expect('python', '-i', '-u')
xmap(expect, LOAD, handle)
xmap(expect, CLOSE, lambda expect: die())
expect.send('print "hello world"\nquit()\n')
core.gear.mainloop()