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 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 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 dump(self, data):
        """
        It sends data asynchronously through the device.
        """

        self.queue.append(data)
        xmap(self.device, WRITE, self.update)

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_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 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 __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 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 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, 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 __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 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, 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 __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, 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 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