Python network.xmap函数代码示例

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